mapd v2

remove old mapd, sla, ssc
Revert "ui: Global Brightness Override (#1579 )"
2026-06-11 23:24:40 +08:00 · 2026-01-13 20:49:08 -07:00 · 2026-01-13 20:25:37 -07:00 · 2026-01-10 21:24:44 +01:00 · 2026-01-09 18:40:09 -05:00 · 2026-01-04 00:33:32 -05:00
134 changed files with 3126 additions and 3975 deletions
--- a/.github/workflows/sunnypilot-master-dev-prep.yaml
+++ b/.github/workflows/sunnypilot-master-dev-prep.yaml
@@ -174,6 +174,24 @@ jobs:
          echo '    pushurl = ${{ env.LFS_PUSH_URL }}' >> .lfsconfig
          echo '    locksverify = false' >> .lfsconfig

+      - name: Restore workflows from source
+        run: |
+          TARGET_BRANCH="${{ inputs.target_branch || env.DEFAULT_TARGET_BRANCH }}"
+          SOURCE_BRANCH="${{ inputs.source_branch || env.DEFAULT_SOURCE_BRANCH }}"
+
+          # Ensure we are on the target branch
+          git checkout $TARGET_BRANCH
+
+          echo "Restoring .github/workflows from $SOURCE_BRANCH"
+          git checkout origin/$SOURCE_BRANCH -- .github/workflows
+
+          if ! git diff --cached --quiet; then
+            echo "Workflows differ. Committing restoration."
+            git commit -m "chore: restore .github/workflows from $SOURCE_BRANCH"
+          else
+            echo "Workflows match $SOURCE_BRANCH."
+          fi
+
      - uses: actions/create-github-app-token@v2
        id: ci-token
        with:
--- a/.github/workflows/tests.yaml
+++ b/.github/workflows/tests.yaml
@@ -107,8 +107,8 @@ jobs:

  build_mac:
    name: build macOS
-    if: false # tmp disable due to brew install not working
    runs-on: ${{ ((github.repository == 'commaai/openpilot') && ((github.event_name != 'pull_request') || (github.event.pull_request.head.repo.full_name == 'commaai/openpilot'))) && 'namespace-profile-macos-8x14' || 'macos-latest' }}
+    if: false  # There'll be one day that this works. That day is not today.
    steps:
    - uses: actions/checkout@v4
      with:
--- a/README.md
+++ b/README.md
@@ -11,66 +11,10 @@ Join the official sunnypilot community forum to stay up to date with all the lat
 https://docs.sunnypilot.ai/ is your one stop shop for everything from features to installation to FAQ about the sunnypilot

 ## 🚘 Running on a dedicated device in a car
-* A supported device to run this software
-    * a [comma three](https://comma.ai/shop/products/three) or a [C3X](https://comma.ai/shop/comma-3x)
-* This software
-* One of [the 325+ supported cars](https://github.com/sunnypilot/sunnypilot/blob/master/docs/CARS.md). We support Honda, Toyota, Hyundai, Nissan, Kia, Chrysler, Lexus, Acura, Audi, VW, Ford, and more. If your car is not supported but has adaptive cruise control and lane-keeping assist, it's likely able to run sunnypilot.
-* A [car harness](https://comma.ai/shop/products/car-harness) to connect to your car
-
-Detailed instructions for [how to mount the device in a car](https://comma.ai/setup).
+First, check out this list of items you'll need to [get started](https://community.sunnypilot.ai/t/getting-started-using-sunnypilot-in-your-supported-car/251).

 ## Installation
-Please refer to [Recommended Branches](#recommended-branches) to find your preferred/supported branch. This guide will assume you want to install the latest `staging` branch.
-
-### If you want to use our newest branches (our rewrite)
-> [!TIP]
->You can see the rewrite state on our [rewrite project board](https://github.com/orgs/sunnypilot/projects/2), and to install the new branches, you can use the following links
-
-* sunnypilot not installed or you installed a version before 0.8.17?
-  1. [Factory reset/uninstall](https://github.com/commaai/openpilot/wiki/FAQ#how-can-i-reset-the-device) the previous software if you have another software/fork installed.
-  2. After factory reset/uninstall and upon reboot, select `Custom Software` when given the option.
-  3. Input the installation URL per [Recommended Branches](#recommended-branches). Example: ```https://staging.sunnypilot.ai```.
-  4. Complete the rest of the installation following the onscreen instructions.
-
-* sunnypilot already installed and you installed a version after 0.8.17?
-  1. On the comma three/3X, go to `Settings` ▶️ `Software`.
-  2. At the `Download` option, press `CHECK`. This will fetch the list of latest branches from sunnypilot.
-  3. At the `Target Branch` option, press `SELECT` to open the Target Branch selector.
-  4. Scroll to select the desired branch per  Recommended Branches (see below). Example: `staging`
-
-### Recommended Branches
-|      Branch     |                 Installation URL              |
-|:---------------:|:---------------------------------------------:|
-| `release`       | `https://release.sunnypilot.ai`               |
-| `staging`       | `https://staging.sunnypilot.ai`               |
-|   `dev`         | `https://dev.sunnypilot.ai`                   |
-| `custom-branch` | `https://install.sunnypilot.ai/{branch_name}` |
-
-> [!TIP]
-> You can use sunnypilot/targetbranch as an install URL. Example: 'sunnypilot/staging'.
-
-> [!NOTE]
-> Do you require further assistance with software installation? Join the [sunnypilot community forum](https://community.sunnypilot.ai/new-topic?category=general/qa) and create a topic in the General/Q&A Category channel.
-
-
-<details>
-
-<summary>Older legacy branches</summary>
-
-### If you want to use our older legacy branches (*not recommended*)
-
-> [**IMPORTANT**]
-> It is recommended to [re-flash AGNOS](https://flash.comma.ai/) if you intend to downgrade from the new branches.
-> You can still restore the latest sunnylink backup made on the old branches.
-
-|    Branch    |         Installation URL         |
-|:------------:|:--------------------------------:|
-| `release-c3` | https://release-c3.sunnypilot.ai |
-| `staging-c3` | https://staging-c3.sunnypilot.ai |
-|   `dev-c3`   | https://dev-c3.sunnypilot.ai     |
-
-</details>
-
+Next, refer to the sunnypilot community forum for [installation instructions](https://community.sunnypilot.ai/t/read-before-installing-sunnypilot/254), as well as a complete list of [Recommended Branch Installations](https://community.sunnypilot.ai/t/recommended-branch-installations/235).

 ## 🎆 Pull Requests
 We welcome both pull requests and issues on GitHub. Bug fixes are encouraged.
--- a/cereal/custom.capnp
+++ b/cereal/custom.capnp
@@ -288,6 +288,7 @@ struct LongitudinalPlanSP @0xf35cc4560bbf6ec2 {
    sccVision @1;
    sccMap @2;
    speedLimitAssist @3;
+    mapd @4;
  }

  struct E2eAlerts {
@@ -475,11 +476,125 @@ struct CustomReserved15 @0xbd443b539493bc68 {
 struct CustomReserved16 @0xfc6241ed8877b611 {
 }

-struct CustomReserved17 @0xa30662f84033036c {
+struct MapdDownloadLocationDetails @0xff889853e7b0987f {
+  location @0 :Text;
+  totalFiles @1 :UInt32;
+  downloadedFiles @2 :UInt32;
 }

-struct CustomReserved18 @0xc86a3d38d13eb3ef {
+struct MapdDownloadProgress @0xfaa35dcac85073a2 {
+  active @0 :Bool;
+  cancelled @1 :Bool;
+  totalFiles @2 :UInt32;
+  downloadedFiles @3 :UInt32;
+  locations @4 :List(Text);
+  locationDetails @5 :List(MapdDownloadLocationDetails);
 }

-struct CustomReserved19 @0xa4f1eb3323f5f582 {
+struct MapdPathPoint @0xd6f78acca1bc3939 {
+  latitude @0 :Float64;
+  longitude @1 :Float64;
+  curvature @2 :Float32;
+  targetVelocity @3 :Float32;
+}
+
+struct MapdExtendedOut @0xa30662f84033036c {
+  downloadProgress @0 :MapdDownloadProgress;
+  settings @1 :Text;
+  path @2 :List(MapdPathPoint);
+}
+
+enum MapdInputType {
+  download @0;
+  setTargetLateralAccel @1;
+  setSpeedLimitOffset @2;
+  setSpeedLimitControl @3;
+  setMapCurveSpeedControl @4;
+  setVisionCurveSpeedControl @5;
+  setLogLevel @6;
+  setVisionCurveTargetLatA @7;
+  setVisionCurveMinTargetV @8;
+  reloadSettings @9;
+  saveSettings @10;
+  setEnableSpeed @11;
+  setVisionCurveUseEnableSpeed @12;
+  setMapCurveUseEnableSpeed @13;
+  setSpeedLimitUseEnableSpeed @14;
+  setHoldLastSeenSpeedLimit @15;
+  setTargetSpeedJerk @16;
+  setTargetSpeedAccel @17;
+  setTargetSpeedTimeOffset @18;
+  setDefaultLaneWidth @19;
+  setMapCurveTargetLatA @20;
+  loadDefaultSettings @21;
+  loadRecommendedSettings @22;
+  setSlowDownForNextSpeedLimit @23;
+  setSpeedUpForNextSpeedLimit @24;
+  setHoldSpeedLimitWhileChangingSetSpeed @25;
+  loadPersistentSettings @26;
+  cancelDownload @27;
+  setLogJson @28;
+  setLogSource @29;
+  setExternalSpeedLimitControl @30;
+  setExternalSpeedLimit @31;
+  setSpeedLimitPriority @32;
+  setSpeedLimitChangeRequiresAccept @33;
+  acceptSpeedLimit @34;
+  setPressGasToAcceptSpeedLimit @35;
+  setAdjustSetSpeedToAcceptSpeedLimit @36;
+  setAcceptSpeedLimitTimeout @37;
+  setPressGasToOverrideSpeedLimit @38;
+}
+
+enum WaySelectionType {
+  current @0;
+  predicted @1;
+  possible @2;
+  extended @3;
+  fail @4;
+}
+
+enum SpeedLimitOffsetType {
+  static @0;
+  percent @1;
+}
+
+struct MapdIn @0xc86a3d38d13eb3ef {
+  type @0 :MapdInputType;
+  float @1 :Float32;
+  str @2 :Text;
+  bool @3 :Bool;
+}
+
+enum RoadContext {
+  freeway @0;
+  city @1;
+  unknown @2;
+}
+
+struct MapdOut @0xa4f1eb3323f5f582 {
+  wayName @0 :Text;
+  wayRef @1 :Text;
+  roadName @2 :Text;
+  speedLimit @3 :Float32;
+  nextSpeedLimit @4 :Float32;
+  nextSpeedLimitDistance @5 :Float32;
+  hazard @6 :Text;
+  nextHazard @7 :Text;
+  nextHazardDistance @8 :Float32;
+  advisorySpeed @9 :Float32;
+  nextAdvisorySpeed @10 :Float32;
+  nextAdvisorySpeedDistance @11 :Float32;
+  oneWay @12 :Bool;
+  lanes @13 :UInt8;
+  tileLoaded @14 :Bool;
+  speedLimitSuggestedSpeed @15 :Float32;
+  suggestedSpeed @16 :Float32;
+  estimatedRoadWidth @17 :Float32;
+  roadContext @18 :RoadContext;
+  distanceFromWayCenter @19 :Float32;
+  visionCurveSpeed @20 :Float32;
+  mapCurveSpeed @21 :Float32;
+  waySelectionType @22 :WaySelectionType;
+  speedLimitAccepted @23 :Bool;
 }
--- a/cereal/log.capnp
+++ b/cereal/log.capnp
@@ -2642,9 +2642,9 @@ struct Event {
    customReserved14 @140 :Custom.CustomReserved14;
    customReserved15 @141 :Custom.CustomReserved15;
    customReserved16 @142 :Custom.CustomReserved16;
-    customReserved17 @143 :Custom.CustomReserved17;
-    customReserved18 @144 :Custom.CustomReserved18;
-    customReserved19 @145 :Custom.CustomReserved19;
+    mapdExtendedOut @143 :Custom.MapdExtendedOut;
+    mapdIn @144 :Custom.MapdIn;
+    mapdOut @145 :Custom.MapdOut;

    # *********** legacy + deprecated ***********
    model @9 :Legacy.ModelData; # TODO: rename modelV2 and mark this as deprecated
--- a/cereal/services.py
+++ b/cereal/services.py
@@ -98,9 +98,9 @@ _services: dict[str, tuple] = {
  "carParamsSP": (True, 0.02, 1),
  "carControlSP": (True, 100., 10),
  "carStateSP": (True, 100., 10),
-  "liveMapDataSP": (True, 1., 1),
  "modelDataV2SP": (True, 20., None, QueueSize.BIG),
  "liveLocationKalman": (True, 20.),
+  "mapdOut": (True, 20., 20, QueueSize.MEDIUM),

  # debug
  "uiDebug": (True, 0., 1),
--- a/common/params_keys.h
+++ b/common/params_keys.h
@@ -95,7 +95,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"Offroad_NeosUpdate", {CLEAR_ON_MANAGER_START, JSON}},
    {"Offroad_NoFirmware", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, JSON}},
    {"Offroad_Recalibration", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, JSON}},
-    {"Offroad_StorageMissing", {CLEAR_ON_MANAGER_START, JSON}},
    {"Offroad_TemperatureTooHigh", {CLEAR_ON_MANAGER_START, JSON}},
    {"Offroad_UnregisteredHardware", {CLEAR_ON_MANAGER_START, JSON}},
    {"Offroad_UpdateFailed", {CLEAR_ON_MANAGER_START, JSON}},
@@ -146,6 +145,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"CarParamsSPPersistent", {PERSISTENT, BYTES}},
    {"CarPlatformBundle", {PERSISTENT | BACKUP, JSON}},
    {"ChevronInfo", {PERSISTENT | BACKUP, INT, "4"}},
+    {"CompletedSunnylinkConsentVersion", {PERSISTENT, STRING, "0"}},
    {"CustomAccIncrementsEnabled", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"CustomAccLongPressIncrement", {PERSISTENT | BACKUP, INT, "5"}},
    {"CustomAccShortPressIncrement", {PERSISTENT | BACKUP, INT, "1"}},
@@ -155,6 +155,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"EnableGithubRunner", {PERSISTENT | BACKUP, BOOL}},
    {"GreenLightAlert", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"GithubRunnerSufficientVoltage", {CLEAR_ON_MANAGER_START , BOOL}},
+    {"HasAcceptedTermsSP", {PERSISTENT, STRING, "0"}},
    {"HideVEgoUI", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"IntelligentCruiseButtonManagement", {PERSISTENT | BACKUP , BOOL}},
    {"InteractivityTimeout", {PERSISTENT | BACKUP, INT, "0"}},
@@ -192,6 +193,9 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"ModelManager_LastSyncTime", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, INT, "0"}},
    {"ModelManager_ModelsCache", {PERSISTENT | BACKUP, JSON}},

+    {"MapdSettings", {PERSISTENT, JSON}},
+    {"Offroad_OSMUpdateRequired", {CLEAR_ON_MANAGER_START, JSON}},
+
    // Neural Network Lateral Control
    {"NeuralNetworkLateralControl", {PERSISTENT | BACKUP, BOOL, "0"}},

@@ -214,48 +218,19 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"SubaruStopAndGo", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"SubaruStopAndGoManualParkingBrake", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"TeslaCoopSteering", {PERSISTENT | BACKUP, BOOL, "0"}},
+    {"ToyotaEnforceStockLongitudinal", {PERSISTENT | BACKUP, BOOL, "0"}},

    {"DynamicExperimentalControl", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"BlindSpot", {PERSISTENT | BACKUP, BOOL, "0"}},

    // sunnypilot model params
+    {"CameraOffset", {PERSISTENT | BACKUP, FLOAT, "0.0"}},
    {"LagdToggle", {PERSISTENT | BACKUP, BOOL, "1"}},
    {"LagdToggleDelay", {PERSISTENT | BACKUP, FLOAT, "0.2"}},
    {"LagdValueCache", {PERSISTENT, FLOAT, "0.2"}},
    {"LaneTurnDesire", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"LaneTurnValue", {PERSISTENT | BACKUP, FLOAT, "19.0"}},
-
-    // mapd
-    {"MapAdvisorySpeedLimit", {CLEAR_ON_ONROAD_TRANSITION, FLOAT}},
-    {"MapdVersion", {PERSISTENT, STRING}},
-    {"MapSpeedLimit", {CLEAR_ON_ONROAD_TRANSITION, FLOAT, "0.0"}},
-    {"NextMapSpeedLimit", {CLEAR_ON_ONROAD_TRANSITION, JSON}},
-    {"Offroad_OSMUpdateRequired", {CLEAR_ON_MANAGER_START, JSON}},
-    {"OsmDbUpdatesCheck", {CLEAR_ON_MANAGER_START, BOOL}},  // mapd database update happens with device ON, reset on boot
-    {"OSMDownloadBounds", {PERSISTENT, STRING}},
-    {"OsmDownloadedDate", {PERSISTENT, STRING, "0.0"}},
-    {"OSMDownloadLocations", {PERSISTENT, JSON}},
-    {"OSMDownloadProgress", {CLEAR_ON_MANAGER_START, JSON}},
-    {"OsmLocal", {PERSISTENT, BOOL}},
-    {"OsmLocationName", {PERSISTENT, STRING}},
-    {"OsmLocationTitle", {PERSISTENT, STRING}},
-    {"OsmLocationUrl", {PERSISTENT, STRING}},
-    {"OsmStateName", {PERSISTENT, STRING, "All"}},
-    {"OsmStateTitle", {PERSISTENT, STRING}},
-    {"OsmWayTest", {PERSISTENT, STRING}},
-    {"RoadName", {CLEAR_ON_ONROAD_TRANSITION, STRING}},
-    {"RoadNameToggle", {PERSISTENT, STRING}},
-
-    // Speed Limit
-    {"SpeedLimitMode", {PERSISTENT | BACKUP, INT, "1"}},
-    {"SpeedLimitOffsetType", {PERSISTENT | BACKUP, INT, "0"}},
-    {"SpeedLimitPolicy", {PERSISTENT | BACKUP, INT, "3"}},
-    {"SpeedLimitValueOffset", {PERSISTENT | BACKUP, INT, "0"}},
-
-    // Smart Cruise Control
-    {"MapTargetVelocities", {CLEAR_ON_ONROAD_TRANSITION, STRING}},
-    {"SmartCruiseControlMap", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"SmartCruiseControlVision", {PERSISTENT | BACKUP, BOOL, "0"}},
+    {"PlanplusControl", {PERSISTENT | BACKUP, FLOAT, "1.0"}},

    // Torque lateral control custom params
    {"CustomTorqueParams", {PERSISTENT | BACKUP , BOOL}},
--- a/docs/CONTRIBUTING.md
+++ b/docs/CONTRIBUTING.md
@@ -39,7 +39,7 @@ All of these are examples of good PRs:
 ### First contribution

 [Projects / openpilot bounties](https://github.com/orgs/commaai/projects/26/views/1?pane=info) is the best place to get started and goes in-depth on what's expected when working on a bounty.
-There's lot of bounties that don't require a comma 3/3X or a car.
+There's lot of bounties that don't require a comma 3X or a car.

 ## Pull Requests

--- a/docs/how-to/connect-to-comma.md
+++ b/docs/how-to/connect-to-comma.md
@@ -1,11 +1,11 @@
-# connect to a comma 3/3X
+# connect to a comma 3X

-A comma 3/3X is a normal [Linux](https://github.com/commaai/agnos-builder) computer that exposes [SSH](https://wiki.archlinux.org/title/Secure_Shell) and a [serial console](https://wiki.archlinux.org/title/Working_with_the_serial_console).
+A comma 3X is a normal [Linux](https://github.com/commaai/agnos-builder) computer that exposes [SSH](https://wiki.archlinux.org/title/Secure_Shell) and a [serial console](https://wiki.archlinux.org/title/Working_with_the_serial_console).

 ## Serial Console

 On both the comma three and 3X, the serial console is accessible from the main OBD-C port.
-Connect the comma 3/3X to your computer with a normal USB C cable, or use a [comma serial](https://comma.ai/shop/comma-serial) for steady 12V power.
+Connect the comma 3X to your computer with a normal USB C cable, or use a [comma serial](https://comma.ai/shop/comma-serial) for steady 12V power.

 On the comma three, the serial console is exposed through a UART-to-USB chip, and `tools/scripts/serial.sh` can be used to connect.

@@ -45,7 +45,7 @@ In order to use ADB on your device, you'll need to perform the following steps u
    * Here's an example command for connecting to your device using its tethered connection: `adb connect 192.168.43.1:5555`

 > [!NOTE]
-> The default port for ADB is 5555 on the comma 3/3X.
+> The default port for ADB is 5555 on the comma 3X.

 For more info on ADB, see the [Android Debug Bridge (ADB) documentation](https://developer.android.com/tools/adb).

--- a/docs/how-to/replay-a-drive.md
+++ b/docs/how-to/replay-a-drive.md
@@ -8,7 +8,7 @@ Replaying is a critical tool for openpilot development and debugging.
 Just run `tools/replay/replay --demo`.

 ## Replaying CAN data
-*Hardware required: jungle and comma 3/3X*
+*Hardware required: jungle and comma 3X*

 1. Connect your PC to a jungle.
 2.
--- a/docs/how-to/turn-the-speed-blue.md
+++ b/docs/how-to/turn-the-speed-blue.md
@@ -3,7 +3,7 @@

 In 30 minutes, we'll get an openpilot development environment set up on your computer and make some changes to openpilot's UI.

-And if you have a comma 3/3X, we'll deploy the change to your device for testing.
+And if you have a comma 3X, we'll deploy the change to your device for testing.

 ## 1. Set up your development environment

--- a/launch_openpilot.sh
+++ b/launch_openpilot.sh
@@ -1,3 +1,20 @@
 #!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+
+# On any failure, run the fallback launcher
+trap 'exec ./launch_chffrplus.sh' ERR
+C3_LAUNCH_SH="./sunnypilot/system/hardware/c3/launch_chffrplus.sh"
+
+MODEL="$(tr -d '\0' < "/sys/firmware/devicetree/base/model")"
+export MODEL
+
+if [ "$MODEL" = "comma tici" ]; then
+  # Force a failure if the launcher doesn't exist
+  [ -x "$C3_LAUNCH_SH" ] || false
+
+  # If it exists, run it
+  exec "$C3_LAUNCH_SH"
+fi

 exec ./launch_chffrplus.sh
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -21,7 +21,7 @@ nav:
    - What is openpilot?: getting-started/what-is-openpilot.md
  - How-to:
    - Turn the speed blue: how-to/turn-the-speed-blue.md
-    - Connect to a comma 3/3X: how-to/connect-to-comma.md
+    - Connect to a comma 3X: how-to/connect-to-comma.md
    # - Make your first pull request: how-to/make-first-pr.md
    #- Replay a drive: how-to/replay-a-drive.md
  - Concepts:
--- a/2
+++ b/2
--- a/2
+++ b/2
--- a/selfdrive/car/card.py
+++ b/selfdrive/car/card.py
@@ -217,7 +217,6 @@ class Car:
    if can_rcv_valid and REPLAY:
      self.can_log_mono_time = messaging.log_from_bytes(can_strs[0]).logMonoTime

-    self.v_cruise_helper.update_speed_limit_assist(self.is_metric, self.sm['longitudinalPlanSP'])
    self.v_cruise_helper.update_v_cruise(CS, self.sm['carControl'].enabled, self.is_metric)
    if self.sm['carControl'].enabled and not self.CC_prev.enabled:
      # Use CarState w/ buttons from the step selfdrived enables on
--- a/selfdrive/car/cruise.py
+++ b/selfdrive/car/cruise.py
@@ -53,7 +53,6 @@ class VCruiseHelper(VCruiseHelperSP):
      if not self.CP.pcmCruise or (not self.CP_SP.pcmCruiseSpeed and _enabled):
        # if stock cruise is completely disabled, then we can use our own set speed logic
        self._update_v_cruise_non_pcm(CS, _enabled, is_metric)
-        self.update_speed_limit_assist_v_cruise_non_pcm()
        self.v_cruise_cluster_kph = self.v_cruise_kph
        self.update_button_timers(CS, enabled)
      else:
@@ -105,12 +104,6 @@ class VCruiseHelper(VCruiseHelperSP):
    if not self.button_change_states[button_type]["enabled"]:
      return

-    # Speed Limit Assist for Non PCM long cars.
-    # True: Disallow set speed changes when user confirmed the target set speed during preActive state
-    # False: Allow set speed changes as SLA is not requesting user confirmation
-    if self.update_speed_limit_assist_pre_active_confirmed(button_type):
-      return
-
    long_press, v_cruise_delta = VCruiseHelperSP.update_v_cruise_delta(self, long_press, v_cruise_delta)
    if long_press and self.v_cruise_kph % v_cruise_delta != 0:  # partial interval
      self.v_cruise_kph = CRUISE_NEAREST_FUNC[button_type](self.v_cruise_kph / v_cruise_delta) * v_cruise_delta
--- a/selfdrive/controls/plannerd.py
+++ b/selfdrive/controls/plannerd.py
@@ -27,12 +27,11 @@ def main():
  longitudinal_planner = LongitudinalPlanner(CP, CP_SP)
  pm = messaging.PubMaster(['longitudinalPlan', 'driverAssistance', 'longitudinalPlanSP'])
  sm = messaging.SubMaster(['carControl', 'carState', 'controlsState', 'liveParameters', 'radarState', 'modelV2', 'selfdriveState',
-                            'liveMapDataSP', 'carStateSP', gps_location_service],
+                            'carStateSP', 'mapdOut', gps_location_service],
                           poll='carState')

  while True:
    sm.update()
-    longitudinal_planner.sla.update_car_state(sm['carState'])
    if sm.updated['modelV2']:
      longitudinal_planner.update(sm)
      longitudinal_planner.publish(sm, pm)
--- a/selfdrive/mapd
+++ b/selfdrive/mapd
--- a/selfdrive/monitoring/helpers.py
+++ b/selfdrive/monitoring/helpers.py
@@ -449,7 +449,7 @@ class DriverMonitoring:
      rpyCalib = [0., 0., 0.]
    else:
      highway_speed = sm['carState'].vEgo
-      enabled = sm['selfdriveState'].enabled
+      enabled = sm['selfdriveState'].enabled or sm['carControl'].latActive
      wrong_gear = sm['carState'].gearShifter not in (car.CarState.GearShifter.drive, car.CarState.GearShifter.low)
      standstill = sm['carState'].standstill
      driver_engaged = sm['carState'].steeringPressed or sm['carState'].gasPressed
--- a/selfdrive/monitoring/test_monitoring.py
+++ b/selfdrive/monitoring/test_monitoring.py
@@ -1,6 +1,7 @@
 import numpy as np
+import pytest

-from cereal import log
+from cereal import log, car
 from openpilot.common.realtime import DT_DMON
 from openpilot.selfdrive.monitoring.helpers import DriverMonitoring, DRIVER_MONITOR_SETTINGS
 from openpilot.system.hardware import HARDWARE
@@ -204,3 +205,66 @@ class TestMonitoring:
    assert EventName.driverUnresponsive in \
                              events[int((INVISIBLE_SECONDS_TO_RED-1+DT_DMON*d_status.settings._HI_STD_FALLBACK_TIME+0.1)/DT_DMON)].names

+
+@pytest.mark.parametrize("enabled_state, lat_active_state, expected", [
+  (False, False, False), # Both Disabled
+  (True, False, True),   # OP Enabled, Lat Inactive
+  (False, True, True),   # OP Disabled, Lat Active (e.g. MADS)
+  (True, True, True)     # Both Active
+])
+def test_enabled_states(enabled_state, lat_active_state, expected):
+  """
+  Test DriverMonitoring.run_step with all 4 combinations of:
+  - selfdriveState.enabled (True/False)
+  - carControl.latActive (True/False)
+  """
+  cs = car.CarState.new_message()
+  cs.vEgo = 30.0
+  cs.gearShifter = car.CarState.GearShifter.drive
+  cs.standstill = False
+  cs.steeringPressed = False
+  cs.gasPressed = False
+
+  ss = log.SelfdriveState.new_message()
+  ss.enabled = enabled_state
+
+  cc = car.CarControl.new_message()
+  cc.latActive = lat_active_state
+
+  mv2 = log.ModelDataV2.new_message()
+  mv2.meta.disengagePredictions.brakeDisengageProbs = [0.0]
+
+  lc = log.LiveCalibrationData.new_message()
+  lc.rpyCalib = [0.0, 0.0, 0.0]
+
+  ds = make_msg(False)
+
+  sm = {
+      'carState': cs,
+      'selfdriveState': ss,
+      'carControl': cc,
+      'modelV2': mv2,
+      'liveCalibration': lc,
+      'driverStateV2': ds
+  }
+
+  driver_monitoring = DriverMonitoring()
+
+  # run_test doesn't assign enabled to a variable, so we need to spy on _update_events to see its value
+  captured_args = []
+  original_update_events = driver_monitoring._update_events
+
+  def spy_update_events(driver_engaged, op_engaged, standstill, wrong_gear, car_speed):
+      captured_args.append(op_engaged)
+      return original_update_events(driver_engaged, op_engaged, standstill, wrong_gear, car_speed)
+
+  driver_monitoring._update_events = spy_update_events
+
+  driver_monitoring.run_step(sm, demo=False)
+
+  # Assertion
+  assert len(captured_args) == 1, "Expected _update_events to be called exactly once"
+  actual_enabled = captured_args[0]
+
+  assert actual_enabled == expected, f"Expected op_engaged={expected}, but got {actual_enabled}"
+
--- a/selfdrive/pandad/pandad.py
+++ b/selfdrive/pandad/pandad.py
@@ -99,11 +99,6 @@ def main() -> None:
      cloudlog.event("pandad.flash_and_connect", count=count)
      params.remove("PandaSignatures")

-      # TODO: remove this in the next AGNOS
-      # wait until USB is up before counting
-      if time.monotonic() < 60.:
-        no_internal_panda_count = 0
-
      # Handle missing internal panda
      if no_internal_panda_count > 0:
        if no_internal_panda_count == 3:
--- a/selfdrive/pandad/tests/bootstub.panda.bin
+++ b/selfdrive/pandad/tests/bootstub.panda.bin
--- a/selfdrive/pandad/tests/test_pandad.py
+++ b/selfdrive/pandad/tests/test_pandad.py
@@ -21,8 +21,6 @@ class TestPandad:
    if len(Panda.list()) == 0:
      self._run_test(60)

-    self.spi = HARDWARE.get_device_type() != 'tici'
-
  def teardown_method(self):
    managed_processes['pandad'].stop()

@@ -94,14 +92,12 @@ class TestPandad:
    # - 0.2s pandad -> pandad
    # - plus some buffer
    print("startup times", ts, sum(ts) / len(ts))
-    assert 0.1 < (sum(ts)/len(ts)) < (0.7 if self.spi else 5.0)
+    assert 0.1 < (sum(ts)/len(ts)) < 0.7

-  def test_protocol_version_check(self):
-    if not self.spi:
-      pytest.skip("SPI test")
-    # flash old fw
-    fn = os.path.join(HERE, "bootstub.panda_h7_spiv0.bin")
-    self._flash_bootstub_and_test(fn, expect_mismatch=True)
+  def test_old_spi_protocol(self):
+    # flash firmware with old SPI protocol
+    self._flash_bootstub(os.path.join(HERE, "bootstub.panda_h7_spiv0.bin"))
+    self._run_test(45)

  def test_release_to_devel_bootstub(self):
    self._flash_bootstub(None)
--- a/selfdrive/pandad/tests/test_pandad_spi.py
+++ b/selfdrive/pandad/tests/test_pandad_spi.py
@@ -6,7 +6,6 @@ import random

 import cereal.messaging as messaging
 from cereal.services import SERVICE_LIST
-from openpilot.system.hardware import HARDWARE
 from openpilot.selfdrive.test.helpers import with_processes
 from openpilot.selfdrive.pandad.tests.test_pandad_loopback import setup_pandad, send_random_can_messages

@@ -16,8 +15,6 @@ JUNGLE_SPAM = "JUNGLE_SPAM" in os.environ
 class TestBoarddSpi:
  @classmethod
  def setup_class(cls):
-    if HARDWARE.get_device_type() == 'tici':
-      pytest.skip("only for spi pandas")
    os.environ['STARTED'] = '1'
    os.environ['SPI_ERR_PROB'] = '0.001'
    if not JUNGLE_SPAM:
--- a/selfdrive/selfdrived/alerts_offroad.json
+++ b/selfdrive/selfdrived/alerts_offroad.json
@@ -29,10 +29,6 @@
    "text": "Failed to register with comma.ai backend. It will not connect or upload to comma.ai servers, and receives no support from comma.ai. If this is a device purchased at comma.ai/shop, open a ticket at https://comma.ai/support.",
    "severity": 1
  },
-  "Offroad_StorageMissing": {
-    "text": "NVMe drive not mounted.",
-    "severity": 1
-  },
  "Offroad_CarUnrecognized": {
    "text": "sunnypilot was unable to identify your car. Your car is either unsupported or its ECUs are not recognized. Please submit a pull request to add the firmware versions to the proper vehicle. Need help? Join discord.comma.ai.",
    "severity": 0
--- a/selfdrive/selfdrived/selfdrived.py
+++ b/selfdrive/selfdrived/selfdrived.py
@@ -21,7 +21,6 @@ from openpilot.selfdrive.selfdrived.helpers import ExcessiveActuationCheck
 from openpilot.selfdrive.selfdrived.state import StateMachine
 from openpilot.selfdrive.selfdrived.alertmanager import AlertManager, set_offroad_alert

-from openpilot.system.hardware import HARDWARE
 from openpilot.system.version import get_build_metadata
 from openpilot.system.hardware import HARDWARE

@@ -144,14 +143,7 @@ class SelfdriveD(CruiseHelper):
    self.state_machine = StateMachine()
    self.rk = Ratekeeper(100, print_delay_threshold=None)

-    # some comma three with NVMe experience NVMe dropouts mid-drive that
-    # cause loggerd to crash on write, so ignore it only on that platform
-    self.ignored_processes = set()
-    nvme_expected = os.path.exists('/dev/nvme0n1') or (not os.path.isfile("/persist/comma/living-in-the-moment"))
-    if HARDWARE.get_device_type() == 'tici' and nvme_expected:
-      self.ignored_processes = {'loggerd', }
-
-    self.ignored_processes.update({'mapd'})
+    self.ignored_processes = {'mapd', }

    # Determine startup event
    is_remote = build_metadata.openpilot.comma_remote or build_metadata.openpilot.sunnypilot_remote
--- a/selfdrive/ui/layouts/onboarding.py
+++ b/selfdrive/ui/layouts/onboarding.py
@@ -11,7 +11,9 @@ from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.button import Button, ButtonStyle
 from openpilot.system.ui.widgets.label import Label
 from openpilot.selfdrive.ui.ui_state import ui_state
-from openpilot.system.version import terms_version, training_version
+from openpilot.system.version import terms_version, training_version, terms_version_sp
+
+from openpilot.selfdrive.ui.sunnypilot.layouts.onboarding import SunnylinkOnboarding

 DEBUG = False

@@ -33,6 +35,7 @@ class OnboardingState(IntEnum):
  TERMS = 0
  ONBOARDING = 1
  DECLINE = 2
+  SUNNYLINK_CONSENT = 3


 class TrainingGuide(Widget):
@@ -110,14 +113,14 @@ class TermsPage(Widget):
    self._on_decline = on_decline

    self._title = Label(tr("Welcome to sunnypilot"), font_size=90, font_weight=FontWeight.BOLD, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_LEFT)
-    self._desc = Label(tr("You must accept the Terms and Conditions to use sunnypilot. Read the latest terms at https://comma.ai/terms before continuing."),
+    self._desc = Label(tr("You must accept the Terms of Service to use sunnypilot. Read the latest terms at https://sunnypilot.ai/terms before continuing."),
                       font_size=90, font_weight=FontWeight.MEDIUM, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_LEFT)

    self._decline_btn = Button(tr("Decline"), click_callback=on_decline)
    self._accept_btn = Button(tr("Agree"), button_style=ButtonStyle.PRIMARY, click_callback=on_accept)

  def _render(self, _):
-    welcome_x = self._rect.x + 165
+    welcome_x = self._rect.x + 95
    welcome_y = self._rect.y + 165
    welcome_rect = rl.Rectangle(welcome_x, welcome_y, self._rect.width - welcome_x, 90)
    self._title.render(welcome_rect)
@@ -143,7 +146,7 @@ class TermsPage(Widget):
 class DeclinePage(Widget):
  def __init__(self, back_callback=None):
    super().__init__()
-    self._text = Label(tr("You must accept the Terms and Conditions in order to use sunnypilot."),
+    self._text = Label(tr("You must accept the Terms of Service in order to use sunnypilot."),
                       font_size=90, font_weight=FontWeight.MEDIUM, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_LEFT)
    self._back_btn = Button(tr("Back"), click_callback=back_callback)
    self._uninstall_btn = Button(tr("Decline, uninstall sunnypilot"), button_style=ButtonStyle.DANGER,
@@ -180,9 +183,21 @@ class OnboardingWindow(Widget):
    self._training_guide: TrainingGuide | None = None
    self._decline_page = DeclinePage(back_callback=self._on_decline_back)

+    # sunnylink consent pages
+    self._accepted_terms = self._accepted_terms and ui_state.params.get("HasAcceptedTermsSP") == terms_version_sp
+    self._sunnylink = SunnylinkOnboarding()
+    if not self._accepted_terms:
+      self._state = OnboardingState.TERMS
+    elif not self._sunnylink.completed:
+      self._state = OnboardingState.SUNNYLINK_CONSENT
+    elif not self._training_done:
+      self._state = OnboardingState.ONBOARDING
+    else:
+      self._state = OnboardingState.ONBOARDING
+
  @property
  def completed(self) -> bool:
-    return self._accepted_terms and self._training_done
+    return self._accepted_terms and self._sunnylink.completed and self._training_done

  def _on_terms_declined(self):
    self._state = OnboardingState.DECLINE
@@ -192,8 +207,12 @@ class OnboardingWindow(Widget):

  def _on_terms_accepted(self):
    ui_state.params.put("HasAcceptedTerms", terms_version)
-    self._state = OnboardingState.ONBOARDING
-    if self._training_done:
+    ui_state.params.put("HasAcceptedTermsSP", terms_version_sp)
+    if not self._sunnylink.completed:
+      self._state = OnboardingState.SUNNYLINK_CONSENT
+    elif not self._training_done:
+      self._state = OnboardingState.ONBOARDING
+    else:
      gui_app.set_modal_overlay(None)

  def _on_completed_training(self):
@@ -206,8 +225,18 @@ class OnboardingWindow(Widget):

    if self._state == OnboardingState.TERMS:
      self._terms.render(self._rect)
-    if self._state == OnboardingState.ONBOARDING:
-      self._training_guide.render(self._rect)
+    elif self._state == OnboardingState.SUNNYLINK_CONSENT:
+      self._sunnylink.render(self._rect)
+      if self._sunnylink.completed:
+        if not self._training_done:
+          self._state = OnboardingState.ONBOARDING
+        else:
+          gui_app.set_modal_overlay(None)
+    elif self._state == OnboardingState.ONBOARDING:
+      if not self._training_done:
+        self._training_guide.render(self._rect)
+      else:
+        gui_app.set_modal_overlay(None)
    elif self._state == OnboardingState.DECLINE:
      self._decline_page.render(self._rect)
    return -1
--- a/selfdrive/ui/layouts/sidebar.py
+++ b/selfdrive/ui/layouts/sidebar.py
@@ -9,6 +9,8 @@ from openpilot.system.ui.lib.multilang import tr, tr_noop
 from openpilot.system.ui.lib.text_measure import measure_text_cached
 from openpilot.system.ui.widgets import Widget

+from openpilot.selfdrive.ui.sunnypilot.layouts.sidebar import SidebarSP
+
 SIDEBAR_WIDTH = 300
 METRIC_HEIGHT = 126
 METRIC_WIDTH = 240
@@ -62,9 +64,10 @@ class MetricData:
    self.color = color


-class Sidebar(Widget):
+class Sidebar(Widget, SidebarSP):
  def __init__(self):
-    super().__init__()
+    Widget.__init__(self)
+    SidebarSP.__init__(self)
    self._net_type = NETWORK_TYPES.get(NetworkType.none)
    self._net_strength = 0

@@ -112,6 +115,7 @@ class Sidebar(Widget):
    self._update_temperature_status(device_state)
    self._update_connection_status(device_state)
    self._update_panda_status()
+    SidebarSP._update_sunnylink_status(self)

  def _update_network_status(self, device_state):
    self._net_type = NETWORK_TYPES.get(device_state.networkType.raw, tr_noop("Unknown"))
@@ -200,6 +204,13 @@ class Sidebar(Widget):
    rl.draw_text_ex(self._font_regular, tr(self._net_type), text_pos, FONT_SIZE, 0, Colors.WHITE)

  def _draw_metrics(self, rect: rl.Rectangle):
+    if gui_app.sunnypilot_ui():
+      metrics, start_y, spacing = SidebarSP._draw_metrics_w_sunnylink(self, rect, self._temp_status, self._panda_status, self._connect_status)
+      for idx, metric in enumerate(metrics):
+        self._draw_metric(rect, metric, start_y + idx * spacing)
+
+      return
+
    metrics = [(self._temp_status, 338), (self._panda_status, 496), (self._connect_status, 654)]

    for metric, y_offset in metrics:
--- a/selfdrive/ui/mici/layouts/home.py
+++ b/selfdrive/ui/mici/layouts/home.py
@@ -109,7 +109,7 @@ class MiciHomeLayout(Widget):
    self._cell_high_txt = gui_app.texture("icons_mici/settings/network/cell_strength_high.png", 55, 35)
    self._cell_full_txt = gui_app.texture("icons_mici/settings/network/cell_strength_full.png", 55, 35)

-    self._openpilot_label = MiciLabel("sunnypilot", font_size=96, color=rl.Color(255, 255, 255, int(255 * 0.9)), font_weight=FontWeight.DISPLAY)
+    self._openpilot_label = MiciLabel("sunnypilot", font_size=90, color=rl.Color(255, 255, 255, int(255 * 0.9)), font_weight=FontWeight.AUDIOWIDE)
    self._version_label = MiciLabel("", font_size=36, font_weight=FontWeight.ROMAN)
    self._large_version_label = MiciLabel("", font_size=64, color=rl.GRAY, font_weight=FontWeight.ROMAN)
    self._date_label = MiciLabel("", font_size=36, color=rl.GRAY, font_weight=FontWeight.ROMAN)
--- a/selfdrive/ui/mici/layouts/main.py
+++ b/selfdrive/ui/mici/layouts/main.py
@@ -4,6 +4,7 @@ import cereal.messaging as messaging
 from openpilot.selfdrive.ui.mici.layouts.home import MiciHomeLayout
 from openpilot.selfdrive.ui.mici.layouts.settings.settings import SettingsLayout
 from openpilot.selfdrive.ui.mici.layouts.offroad_alerts import MiciOffroadAlerts
+from openpilot.selfdrive.ui.mici.layouts.mapd_panel import MapdInfoPanel
 from openpilot.selfdrive.ui.mici.onroad.augmented_road_view import AugmentedRoadView
 from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.selfdrive.ui.mici.layouts.onboarding import OnboardingWindow
@@ -11,6 +12,9 @@ from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.scroller import Scroller
 from openpilot.system.ui.lib.application import gui_app

+if gui_app.sunnypilot_ui():
+  from openpilot.selfdrive.ui.sunnypilot.mici.layouts.settings import SettingsLayoutSP as SettingsLayout
+

 ONROAD_DELAY = 2.5  # seconds

@@ -37,17 +41,19 @@ class MiciMainLayout(Widget):
    self._alerts_layout = MiciOffroadAlerts()
    self._settings_layout = SettingsLayout()
    self._onroad_layout = AugmentedRoadView(bookmark_callback=self._on_bookmark_clicked)
+    self._mapd_panel = MapdInfoPanel()

    # Initialize widget rects
-    for widget in (self._home_layout, self._settings_layout, self._alerts_layout, self._onroad_layout):
+    for widget in (self._home_layout, self._settings_layout, self._alerts_layout, self._onroad_layout, self._mapd_panel):
      # TODO: set parent rect and use it if never passed rect from render (like in Scroller)
      widget.set_rect(rl.Rectangle(0, 0, gui_app.width, gui_app.height))

    self._scroller = Scroller([
-      self._alerts_layout,
-      self._home_layout,
-      self._onroad_layout,
-    ], spacing=0, pad_start=0, pad_end=0)
+        self._alerts_layout,
+        self._home_layout,
+        self._mapd_panel,
+        self._onroad_layout,
+      ], spacing=0, pad_start=0, pad_end=0)
    self._scroller.set_reset_scroll_at_show(False)

    # Disable scrolling when onroad is interacting with bookmark
@@ -104,6 +110,14 @@ class MiciMainLayout(Widget):
      self._layouts[mode].show_event()
      self._current_mode = mode

+  def _is_on_side_panel(self) -> bool:
+    onroad_x = self._onroad_layout.rect.x
+    current_scroll = self._scroller.scroll_panel.get_offset()
+    return abs(current_scroll - onroad_x) > self._rect.width / 2
+
+  def _is_on_mapd_panel(self) -> bool:
+    return self._is_on_side_panel()
+
  def _handle_transitions(self):
    if ui_state.started != self._prev_onroad:
      self._prev_onroad = ui_state.started
@@ -120,15 +134,16 @@ class MiciMainLayout(Widget):

    CS = ui_state.sm["carState"]
    if not CS.standstill and self._prev_standstill:
-      self._set_mode(MainState.MAIN)
-      self._scroll_to(self._onroad_layout)
+      if not self._is_on_mapd_panel():
+        self._set_mode(MainState.MAIN)
+        self._scroll_to(self._onroad_layout)
    self._prev_standstill = CS.standstill

  def _set_mode_for_started(self, onroad_transition: bool = False):
    if ui_state.started:
      CS = ui_state.sm["carState"]
      # Only go onroad if car starts or is not at a standstill
-      if not CS.standstill or onroad_transition:
+      if (not CS.standstill or onroad_transition) and not self._is_on_mapd_panel():
        self._set_mode(MainState.MAIN)
        self._scroll_to(self._onroad_layout)
    else:
--- a/selfdrive/ui/mici/layouts/mapd_panel.py
+++ b/selfdrive/ui/mici/layouts/mapd_panel.py
@@ -0,0 +1,217 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+
+import pyray as rl
+from dataclasses import dataclass
+from openpilot.common.constants import CV
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.widgets import Widget
+
+METER_TO_KM = 0.001
+METER_TO_MILE = 0.000621371
+
+@dataclass(frozen=True)
+class MapdPanelColors:
+  white: rl.Color = rl.WHITE
+  black: rl.Color = rl.BLACK
+  red: rl.Color = rl.Color(255, 0, 0, 255)
+  green: rl.Color = rl.Color(0, 255, 0, 255)
+  grey: rl.Color = rl.Color(145, 155, 149, 241)
+  light_grey: rl.Color = rl.Color(200, 200, 200, 255)
+  dark_grey: rl.Color = rl.Color(100, 100, 100, 255)
+  bg_dark: rl.Color = rl.Color(30, 30, 30, 255)
+  card_bg: rl.Color = rl.Color(50, 50, 50, 200)
+
+COLORS = MapdPanelColors()
+
+class MapdInfoPanel(Widget):
+  def __init__(self):
+    super().__init__()
+    self.speed_limit: float = 0.0
+    self.speed_limit_valid: bool = False
+    self.next_speed_limit: float = 0.0
+    self.next_speed_limit_distance: float = 0.0
+    self.road_name: str = ""
+    self.current_speed: float = 0.0
+    self.lanes: int = 0
+    self.road_context: str = ""
+    self.hazard: str = ""
+    self.vision_curve_speed: float = 0.0
+    self.map_curve_speed: float = 0.0
+    self.tile_loaded: bool = False
+
+    self._font_bold: rl.Font = gui_app.font(FontWeight.BOLD)
+    self._font_semi_bold: rl.Font = gui_app.font(FontWeight.SEMI_BOLD)
+    self._font_medium: rl.Font = gui_app.font(FontWeight.MEDIUM)
+
+  def _update_state(self) -> None:
+    sm = ui_state.sm
+    speed_conv = CV.MS_TO_KPH if ui_state.is_metric else CV.MS_TO_MPH
+    if sm.valid["mapdOut"]:
+      mapd = sm["mapdOut"]
+      self.speed_limit = mapd.speedLimit * speed_conv
+      self.speed_limit_valid = mapd.speedLimit > 0
+      self.next_speed_limit = mapd.nextSpeedLimit * speed_conv
+      self.next_speed_limit_distance = mapd.nextSpeedLimitDistance
+      self.road_name = mapd.roadName
+      self.lanes = mapd.lanes
+      self.hazard = mapd.hazard
+      self.vision_curve_speed = mapd.visionCurveSpeed * speed_conv
+      self.map_curve_speed = mapd.mapCurveSpeed * speed_conv
+      self.tile_loaded = mapd.tileLoaded
+
+      road_ctx = mapd.roadContext
+      if hasattr(road_ctx, 'raw'):
+        ctx_val = road_ctx.raw
+      else:
+        ctx_val = int(road_ctx)
+      self.road_context = ["Freeway", "City", "Unknown"][ctx_val] if ctx_val < 3 else "Unknown"
+    else:
+      self.speed_limit_valid = False
+
+    if sm.updated["carState"]:
+      self.current_speed = sm["carState"].vEgo * speed_conv
+
+  def _render(self, rect: rl.Rectangle) -> None:
+    self._update_state()
+
+    rl.draw_rectangle(int(rect.x), int(rect.y), int(rect.width), int(rect.height), COLORS.bg_dark)
+    margin = 15
+    left_width = 130
+    right_x = rect.x + left_width + margin + 10
+    right_width = rect.width - left_width - margin * 3
+    sign_x = rect.x + margin + 5
+    sign_y = rect.y + (rect.height - 140) / 2
+    self._draw_speed_limit_sign(sign_x, sign_y)
+    info_y = rect.y + 25
+
+    # Road name
+    self._draw_road_name(right_x, info_y, right_width)
+    info_y += 55
+
+    # Road context (Freeway/City) and lanes
+    self._draw_road_details(right_x, info_y, right_width)
+    info_y += 45
+
+    # Next speed limit
+    self._draw_next_speed_limit(right_x, info_y, right_width)
+    info_y += 45
+
+    # Curve speeds
+    self._draw_curve_speeds(right_x, info_y, right_width)
+    info_y += 45
+
+    # Hazard warning Beta
+    if self.hazard:
+      self._draw_hazard(right_x, info_y, right_width)
+
+    status_text = tr("Map Loaded") if self.tile_loaded else tr("No Map Data")
+    status_color = COLORS.green if self.tile_loaded else COLORS.red
+    status_size = measure_text_cached(self._font_medium, status_text, 18)
+    status_pos = rl.Vector2(rect.x + (rect.width - status_size.x) / 2, rect.y + rect.height - 30)
+    rl.draw_text_ex(self._font_medium, status_text, status_pos, 18, 0, status_color)
+
+  def _draw_speed_limit_sign(self, x: float, y: float) -> None:
+    sign_width = 110 if ui_state.is_metric else 100
+    sign_height = 120 if ui_state.is_metric else 110
+
+    speed_str = str(round(self.speed_limit)) if self.speed_limit_valid else "--"
+    speed_color = COLORS.black if not self.speed_limit_valid or self.current_speed <= self.speed_limit else COLORS.red
+
+    if ui_state.is_metric:
+      self._draw_vienna_sign(x, y, sign_width, sign_height, speed_str, speed_color)
+    else:
+      self._draw_mutcd_sign(x, y, sign_width, sign_height, speed_str, speed_color)
+
+  def _draw_road_name(self, x: float, y: float, width: float) -> None:
+    road_display = self.road_name if self.road_name else "--"
+    road_size = measure_text_cached(self._font_semi_bold, road_display, 34)
+    if road_size.x > width:
+      road_display = road_display[:20] + "..."
+    rl.draw_text_ex(self._font_semi_bold, road_display, rl.Vector2(x, y), 34, 0, COLORS.white)
+
+  def _draw_road_details(self, x: float, y: float, width: float) -> None:
+    details = []
+    if self.road_context and self.road_context != "Unknown":
+      details.append(self.road_context)
+    if self.lanes > 0:
+      details.append(f"{self.lanes} {tr('lanes')}")
+    details_text = " • ".join(details) if details else "--"
+    rl.draw_text_ex(self._font_medium, details_text, rl.Vector2(x, y), 26, 0, COLORS.light_grey)
+
+  def _draw_next_speed_limit(self, x: float, y: float, width: float) -> None:
+    if self.next_speed_limit > 0 and self.next_speed_limit != self.speed_limit:
+      next_text = f"{tr('Next')}: {round(self.next_speed_limit)} ({self._format_distance(self.next_speed_limit_distance)})"
+    else:
+      next_text = f"{tr('Next')}: --"
+    rl.draw_text_ex(self._font_medium, next_text, rl.Vector2(x, y), 26, 0, COLORS.light_grey)
+
+  def _draw_curve_speeds(self, x: float, y: float, width: float) -> None:
+    unit = tr("km/h") if ui_state.is_metric else tr("mph")
+    vision_val = str(round(self.vision_curve_speed)) if self.vision_curve_speed > 0 else "--"
+    map_val = str(round(self.map_curve_speed)) if self.map_curve_speed > 0 else "--"
+    curve_text = f"{tr('Curve')}: V:{vision_val} M:{map_val} {unit}"
+    rl.draw_text_ex(self._font_medium, curve_text, rl.Vector2(x, y), 24, 0, COLORS.light_grey)
+
+  def _draw_hazard(self, x: float, y: float, width: float) -> None:
+    hazard_text = f"⚠ {self.hazard}"
+    rl.draw_text_ex(self._font_semi_bold, hazard_text, rl.Vector2(x, y), 26, 0, COLORS.red)
+
+  def _draw_vienna_sign(self, x: float, y: float, width: float, height: float, speed_str: str, speed_color: rl.Color) -> None:
+    center = rl.Vector2(x + width / 2, y + height / 2)
+    outer_radius = min(width, height) / 2
+
+    rl.draw_circle_v(center, outer_radius, COLORS.white)
+    ring_width = outer_radius * 0.18
+    rl.draw_ring(center, outer_radius - ring_width, outer_radius, 0, 360, 36, COLORS.red)
+
+    font_size = outer_radius * (0.7 if len(speed_str) >= 3 else 0.9)
+    text_size = measure_text_cached(self._font_bold, speed_str, int(font_size))
+    text_pos = rl.Vector2(center.x - text_size.x / 2, center.y - text_size.y / 2)
+    rl.draw_text_ex(self._font_bold, speed_str, text_pos, font_size, 0, speed_color)
+
+  def _draw_mutcd_sign(self, x: float, y: float, width: float, height: float, speed_str: str, speed_color: rl.Color) -> None:
+    sign_rect = rl.Rectangle(x, y, width, height)
+    rl.draw_rectangle_rounded(sign_rect, 0.2, 10, COLORS.white)
+    rl.draw_rectangle_rounded_lines_ex(sign_rect, 0.2, 10, 3, COLORS.black)
+
+    speed_label = tr("SPEED")
+    limit_label = tr("LIMIT")
+    label_size = 16
+
+    speed_text_size = measure_text_cached(self._font_semi_bold, speed_label, label_size)
+    speed_pos = rl.Vector2(x + (width - speed_text_size.x) / 2, y + 8)
+    rl.draw_text_ex(self._font_semi_bold, speed_label, speed_pos, label_size, 0, COLORS.black)
+
+    limit_text_size = measure_text_cached(self._font_semi_bold, limit_label, label_size)
+    limit_pos = rl.Vector2(x + (width - limit_text_size.x) / 2, y + 26)
+    rl.draw_text_ex(self._font_semi_bold, limit_label, limit_pos, label_size, 0, COLORS.black)
+
+    font_size = 40 if len(speed_str) >= 3 else 50
+    num_size = measure_text_cached(self._font_bold, speed_str, font_size)
+    num_pos = rl.Vector2(x + (width - num_size.x) / 2, y + 45)
+    rl.draw_text_ex(self._font_bold, speed_str, num_pos, font_size, 0, speed_color)
+
+  def _format_distance(self, distance: float) -> str:
+    if ui_state.is_metric:
+      if distance < 50:
+        return tr("Near")
+      if distance >= 1000:
+        return f"{distance * METER_TO_KM:.1f}" + tr("km")
+      if distance < 200:
+        rounded = max(10, int(distance / 10) * 10)
+      else:
+        rounded = int(distance / 100) * 100
+      return str(rounded) + tr("m")
+    else:
+      distance_mi = distance * METER_TO_MILE
+      if distance_mi < 0.1:
+        return tr("Near")
+      return f"{distance_mi:.1f}" + tr("mi")
--- a/selfdrive/ui/mici/layouts/onboarding.py
+++ b/selfdrive/ui/mici/layouts/onboarding.py
@@ -17,13 +17,16 @@ from openpilot.selfdrive.ui.mici.onroad.driver_state import DriverStateRenderer
 from openpilot.selfdrive.ui.mici.onroad.driver_camera_dialog import DriverCameraDialog
 from openpilot.system.ui.widgets.label import gui_label
 from openpilot.system.ui.lib.multilang import tr
-from openpilot.system.version import terms_version, training_version
+from openpilot.system.version import terms_version, training_version, terms_version_sp
+
+from openpilot.selfdrive.ui.sunnypilot.mici.layouts.onboarding import SunnylinkOnboarding


 class OnboardingState(IntEnum):
  TERMS = 0
  ONBOARDING = 1
  DECLINE = 2
+  SUNNYLINK_CONSENT = 3


 class DriverCameraSetupDialog(DriverCameraDialog):
@@ -412,10 +415,10 @@ class TermsPage(SetupTermsPage):
    super().__init__(on_accept, on_decline, "decline")

    info_txt = gui_app.texture("icons_mici/setup/green_info.png", 60, 60)
-    self._title_header = TermsHeader("terms & conditions", info_txt)
+    self._title_header = TermsHeader("terms of service", info_txt)

-    self._terms_label = UnifiedLabel("You must accept the Terms and Conditions to use sunnypilot. " +
-                                     "Read the latest terms at https://comma.ai/terms before continuing.", 36,
+    self._terms_label = UnifiedLabel("You must accept the Terms of Service to use sunnypilot. " +
+                                     "Read the latest terms at https://sunnypilot.ai/terms before continuing.", 36,
                                     FontWeight.ROMAN)

  @property
@@ -449,6 +452,18 @@ class OnboardingWindow(Widget):
    self._training_guide = TrainingGuide(completed_callback=self._on_completed_training)
    self._decline_page = DeclinePage(back_callback=self._on_decline_back)

+    # sunnylink consent pages
+    self._accepted_terms = self._accepted_terms and ui_state.params.get("HasAcceptedTermsSP") == terms_version_sp
+    self._sunnylink = SunnylinkOnboarding()
+    if not self._accepted_terms:
+      self._state = OnboardingState.TERMS
+    elif not self._sunnylink.completed:
+      self._state = OnboardingState.SUNNYLINK_CONSENT
+    elif not self._training_done:
+      self._state = OnboardingState.ONBOARDING
+    else:
+      self._state = OnboardingState.ONBOARDING
+
  def show_event(self):
    super().show_event()
    device.set_override_interactive_timeout(300)
@@ -459,7 +474,7 @@ class OnboardingWindow(Widget):

  @property
  def completed(self) -> bool:
-    return self._accepted_terms and self._training_done
+    return self._accepted_terms and self._sunnylink.completed and self._training_done

  def _on_terms_declined(self):
    self._state = OnboardingState.DECLINE
@@ -473,7 +488,13 @@ class OnboardingWindow(Widget):

  def _on_terms_accepted(self):
    ui_state.params.put("HasAcceptedTerms", terms_version)
-    self._state = OnboardingState.ONBOARDING
+    ui_state.params.put("HasAcceptedTermsSP", terms_version_sp)
+    if not self._sunnylink.completed:
+      self._state = OnboardingState.SUNNYLINK_CONSENT
+    elif not self._training_done:
+      self._state = OnboardingState.ONBOARDING
+    else:
+      self.close()

  def _on_completed_training(self):
    ui_state.params.put("CompletedTrainingVersion", training_version)
@@ -482,8 +503,18 @@ class OnboardingWindow(Widget):
  def _render(self, _):
    if self._state == OnboardingState.TERMS:
      self._terms.render(self._rect)
+    elif self._state == OnboardingState.SUNNYLINK_CONSENT:
+      self._sunnylink.render(self._rect)
+      if self._sunnylink.completed:
+        if not self._training_done:
+          self._state = OnboardingState.ONBOARDING
+        else:
+          self.close()
    elif self._state == OnboardingState.ONBOARDING:
-      self._training_guide.render(self._rect)
+      if not self._training_done:
+        self._training_guide.render(self._rect)
+      else:
+        self.close()
    elif self._state == OnboardingState.DECLINE:
      self._decline_page.render(self._rect)
    return -1
--- a/selfdrive/ui/mici/onroad/confidence_ball.py
+++ b/selfdrive/ui/mici/onroad/confidence_ball.py
@@ -6,6 +6,8 @@ from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.common.filter_simple import FirstOrderFilter

+from openpilot.selfdrive.ui.sunnypilot.mici.onroad.confidence_ball import ConfidenceBallSP
+

 def draw_circle_gradient(center_x: float, center_y: float, radius: int,
                         top: rl.Color, bottom: rl.Color) -> None:
@@ -21,9 +23,10 @@ def draw_circle_gradient(center_x: float, center_y: float, radius: int,
               20, rl.BLACK)


-class ConfidenceBall(Widget):
+class ConfidenceBall(Widget, ConfidenceBallSP):
  def __init__(self, demo: bool = False):
-    super().__init__()
+    Widget.__init__(self)
+    ConfidenceBallSP.__init__(self)
    self._demo = demo
    self._confidence_filter = FirstOrderFilter(-0.5, 0.5, 1 / gui_app.target_fps)

@@ -37,6 +40,8 @@ class ConfidenceBall(Widget):
    # animate status dot in from bottom
    if ui_state.status == UIStatus.DISENGAGED:
      self._confidence_filter.update(-0.5)
+    elif ui_state.status in (UIStatus.LAT_ONLY, UIStatus.LONG_ONLY):
+      self._confidence_filter.update(1 - max(self.get_animate_status_probs() or [1]))
    else:
      self._confidence_filter.update((1 - max(ui_state.sm['modelV2'].meta.disengagePredictions.brakeDisengageProbs or [1])) *
                                                        (1 - max(ui_state.sm['modelV2'].meta.disengagePredictions.steerOverrideProbs or [1])))
@@ -65,6 +70,9 @@ class ConfidenceBall(Widget):
        top_dot_color = rl.Color(255, 0, 21, 255)
        bottom_dot_color = rl.Color(255, 0, 89, 255)

+    elif ui_state.status in (UIStatus.LAT_ONLY, UIStatus.LONG_ONLY):
+      top_dot_color = bottom_dot_color = self.get_lat_long_dot_color()
+
    elif ui_state.status == UIStatus.OVERRIDE:
      top_dot_color = rl.Color(255, 255, 255, 255)
      bottom_dot_color = rl.Color(82, 82, 82, 255)
--- a/selfdrive/ui/mici/onroad/model_renderer.py
+++ b/selfdrive/ui/mici/onroad/model_renderer.py
@@ -12,6 +12,8 @@ from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.lib.shader_polygon import draw_polygon, Gradient
 from openpilot.system.ui.widgets import Widget

+from openpilot.selfdrive.ui.sunnypilot.mici.onroad.model_renderer import LANE_LINE_COLORS_SP
+
 CLIP_MARGIN = 500
 MIN_DRAW_DISTANCE = 10.0
 MAX_DRAW_DISTANCE = 100.0
@@ -32,6 +34,7 @@ LANE_LINE_COLORS = {
  UIStatus.DISENGAGED: rl.Color(200, 200, 200, 255),
  UIStatus.OVERRIDE: rl.Color(255, 255, 255, 255),
  UIStatus.ENGAGED: rl.Color(0, 255, 64, 255),
+  **LANE_LINE_COLORS_SP,
 }


@@ -77,6 +80,9 @@ class ModelRenderer(Widget):
    self._transform_dirty = True
    self._clip_region = None

+    self._counter = -1
+    self._camera_offset = ui_state.params.get("CameraOffset", return_default=True) if ui_state.active_bundle else 0.0
+
    self._exp_gradient = Gradient(
      start=(0.0, 1.0),  # Bottom of path
      end=(0.0, 0.0),  # Top of path
@@ -96,6 +102,10 @@ class ModelRenderer(Widget):
  def _render(self, rect: rl.Rectangle):
    sm = ui_state.sm

+    if self._counter % 180 == 0:  # This runs at 60fps, so we query every 3 seconds
+      self._camera_offset = ui_state.params.get("CameraOffset", return_default=True) if ui_state.active_bundle else 0.0
+    self._counter += 1
+
    self._torque_filter.update(-ui_state.sm['carOutput'].actuatorsOutput.torque)

    # Check if data is up-to-date
@@ -147,13 +157,13 @@ class ModelRenderer(Widget):

  def _update_raw_points(self, model):
    """Update raw 3D points from model data"""
-    self._path.raw_points = np.array([model.position.x, model.position.y, model.position.z], dtype=np.float32).T
+    self._path.raw_points = np.array([model.position.x, np.array(model.position.y) + self._camera_offset, model.position.z], dtype=np.float32).T

    for i, lane_line in enumerate(model.laneLines):
-      self._lane_lines[i].raw_points = np.array([lane_line.x, lane_line.y, lane_line.z], dtype=np.float32).T
+      self._lane_lines[i].raw_points = np.array([lane_line.x, np.array(lane_line.y) + self._camera_offset, lane_line.z], dtype=np.float32).T

    for i, road_edge in enumerate(model.roadEdges):
-      self._road_edges[i].raw_points = np.array([road_edge.x, road_edge.y, road_edge.z], dtype=np.float32).T
+      self._road_edges[i].raw_points = np.array([road_edge.x, np.array(road_edge.y) + self._camera_offset, road_edge.z], dtype=np.float32).T

    self._lane_line_probs = np.array(model.laneLineProbs, dtype=np.float32)
    self._road_edge_stds = np.array(model.roadEdgeStds, dtype=np.float32)
@@ -171,7 +181,7 @@ class ModelRenderer(Widget):

        # Get z-coordinate from path at the lead vehicle position
        z = self._path.raw_points[idx, 2] if idx < len(self._path.raw_points) else 0.0
-        point = self._map_to_screen(d_rel, -y_rel, z + self._path_offset_z)
+        point = self._map_to_screen(d_rel, -y_rel + self._camera_offset, z + self._path_offset_z)
        if point:
          self._lead_vehicles[i] = self._update_lead_vehicle(d_rel, v_rel, point, self._rect)

--- a/selfdrive/ui/mici/onroad/speed_limit_ui.py
+++ b/selfdrive/ui/mici/onroad/speed_limit_ui.py
@@ -0,0 +1,181 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import pyray as rl
+from dataclasses import dataclass
+from openpilot.common.constants import CV
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.widgets import Widget
+
+METER_TO_KM = 0.001
+METER_TO_MILE = 0.000621371
+
+SPEED_LIMIT_WIDTH_METRIC = 200
+SPEED_LIMIT_WIDTH_IMPERIAL = 172
+SPEED_LIMIT_HEIGHT = 204
+
+
+@dataclass(frozen=True)
+class SpeedLimitColors:
+  white: rl.Color = rl.WHITE
+  black: rl.Color = rl.BLACK
+  red: rl.Color = rl.Color(255, 0, 0, 255)
+  grey: rl.Color = rl.Color(145, 155, 149, 241)
+  green: rl.Color = rl.Color(0, 255, 0, 255)
+  light_grey: rl.Color = rl.Color(200, 200, 200, 255)
+  dark_grey: rl.Color = rl.Color(180, 180, 180, 255)
+  border_grey: rl.Color = rl.Color(77, 77, 77, 255)
+  black_translucent: rl.Color = rl.Color(0, 0, 0, 166)
+  border_translucent: rl.Color = rl.Color(255, 255, 255, 75)
+
+
+COLORS = SpeedLimitColors()
+
+
+class SpeedLimitRenderer(Widget):
+  def __init__(self):
+    super().__init__()
+    self.speed_limit: float = 0.0
+    self.speed_limit_valid: bool = False
+    self.next_speed_limit: float = 0.0
+    self.next_speed_limit_distance: float = 0.0
+    self.road_name: str = ""
+    self.current_speed: float = 0.0
+
+    self._font_semi_bold: rl.Font = gui_app.font(FontWeight.SEMI_BOLD)
+    self._font_bold: rl.Font = gui_app.font(FontWeight.BOLD)
+    self._font_medium: rl.Font = gui_app.font(FontWeight.MEDIUM)
+
+  def _update_state(self) -> None:
+    sm = ui_state.sm
+    if sm.recv_frame["carState"] < ui_state.started_frame:
+      return
+
+    speed_conv = CV.MS_TO_KPH if ui_state.is_metric else CV.MS_TO_MPH
+    if sm.valid["mapdOut"]:
+      mapd = sm["mapdOut"]
+      self.speed_limit = mapd.speedLimit * speed_conv
+      self.speed_limit_valid = mapd.speedLimit > 0
+      self.next_speed_limit = mapd.nextSpeedLimit * speed_conv
+      self.next_speed_limit_distance = mapd.nextSpeedLimitDistance
+      self.road_name = mapd.roadName
+    else:
+      self.speed_limit_valid = False
+
+    if sm.updated["carState"]:
+      self.current_speed = sm["carState"].vEgo * speed_conv
+
+  def _render(self, rect: rl.Rectangle) -> None:
+    self._update_state()
+
+    sign_width = SPEED_LIMIT_WIDTH_METRIC if ui_state.is_metric else SPEED_LIMIT_WIDTH_IMPERIAL
+    sign_height = SPEED_LIMIT_HEIGHT
+    sign_margin = 12
+    sign_x = rect.x + sign_margin
+    sign_y = rect.y + 45
+
+    sign_rect = rl.Rectangle(sign_x, sign_y, sign_width, sign_height)
+
+    speed_str = str(round(self.speed_limit)) if self.speed_limit_valid else "--"
+    speed_color = COLORS.white if not self.speed_limit_valid or self.current_speed <= self.speed_limit else COLORS.red
+
+    if ui_state.is_metric:
+      self._draw_vienna_sign(sign_rect, speed_str, "", speed_color, self.speed_limit_valid)
+    else:
+      self._draw_mutcd_sign(sign_rect, speed_str, "", speed_color, self.speed_limit_valid)
+
+    if self.next_speed_limit > 0 and self.next_speed_limit != self.speed_limit:
+      self._draw_upcoming_speed_limit(sign_rect)
+
+  def _draw_vienna_sign(self, sign_rect: rl.Rectangle, speed_str: str, sub_text: str, speed_color: rl.Color, has_speed_limit: bool) -> None:
+    """Draw EU/Vienna"""
+    center = rl.Vector2(sign_rect.x + sign_rect.width / 2, sign_rect.y + sign_rect.height / 2)
+    outer_radius = min(sign_rect.width, sign_rect.height) / 2
+    circle_size = outer_radius * 2
+
+    rl.draw_circle_v(center, outer_radius, COLORS.white)
+    ring_width = outer_radius * 0.18
+    rl.draw_ring(center, outer_radius - ring_width, outer_radius, 0, 360, 36, COLORS.red)
+
+    font_size = circle_size * (0.35 if len(speed_str) >= 3 else 0.45)
+    text_size = measure_text_cached(self._font_bold, speed_str, int(font_size))
+    text_pos = rl.Vector2(center.x - text_size.x / 2, center.y - text_size.y / 2)
+    rl.draw_text_ex(self._font_bold, speed_str, text_pos, font_size, 0, speed_color)
+
+  def _draw_mutcd_sign(self, sign_rect: rl.Rectangle, speed_str: str, sub_text: str, speed_color: rl.Color, has_speed_limit: bool) -> None:
+    """Draw US/Canada MUTCD sign."""
+    padding = 8
+    inner_rect = rl.Rectangle(sign_rect.x + padding, sign_rect.y + padding, sign_rect.width - (padding * 2), sign_rect.height - (padding * 2))
+    rl.draw_rectangle_rounded(inner_rect, 0.35, 10, COLORS.white)
+    rl.draw_rectangle_rounded_lines_ex(inner_rect, 0.35, 10, 4, COLORS.black)
+
+    border_width = 4
+    border_rect = rl.Rectangle(
+      inner_rect.x + border_width, inner_rect.y + border_width, inner_rect.width - (border_width * 2), inner_rect.height - (border_width * 2)
+    )
+    speed_text = tr("SPEED")
+    limit_text = tr("LIMIT")
+
+    speed_size = measure_text_cached(self._font_semi_bold, speed_text, 40)
+    limit_size = measure_text_cached(self._font_semi_bold, limit_text, 40)
+
+    speed_pos = rl.Vector2(border_rect.x + (border_rect.width - speed_size.x) / 2, sign_rect.y + 27)
+    limit_pos = rl.Vector2(border_rect.x + (border_rect.width - limit_size.x) / 2, sign_rect.y + 65)
+
+    rl.draw_text_ex(self._font_semi_bold, speed_text, speed_pos, 40, 0, COLORS.black)
+    rl.draw_text_ex(self._font_semi_bold, limit_text, limit_pos, 40, 0, COLORS.black)
+
+    font_size = 70 if len(speed_str) >= 3 else 90
+    speed_value_size = measure_text_cached(self._font_bold, speed_str, font_size)
+    speed_value_pos = rl.Vector2(border_rect.x + (border_rect.width - speed_value_size.x) / 2, sign_rect.y + 100)
+    rl.draw_text_ex(self._font_bold, speed_str, speed_value_pos, font_size, 0, speed_color)
+
+  def _draw_upcoming_speed_limit(self, sign_rect: rl.Rectangle) -> None:
+    """Draw upcoming speed limit indicator."""
+    speed_str = str(round(self.next_speed_limit))
+    distance_str = self._format_distance(self.next_speed_limit_distance)
+
+    ahead_width = 150
+    ahead_height = 100
+    ahead_x = sign_rect.x + (sign_rect.width - ahead_width) / 2
+    ahead_y = sign_rect.y + sign_rect.height + 6
+    ahead_rect = rl.Rectangle(ahead_x, ahead_y, ahead_width, ahead_height)
+
+    rl.draw_rectangle_rounded(ahead_rect, 0.2, 10, rl.Color(0, 0, 0, 180))
+    rl.draw_rectangle_rounded_lines_ex(ahead_rect, 0.2, 10, 3, rl.Color(255, 255, 255, 100))
+
+    ahead_label = tr("AHEAD")
+    ahead_size = measure_text_cached(self._font_semi_bold, ahead_label, 28)
+    ahead_pos = rl.Vector2(ahead_rect.x + (ahead_rect.width - ahead_size.x) / 2, ahead_rect.y + 4)
+    rl.draw_text_ex(self._font_semi_bold, ahead_label, ahead_pos, 28, 0, COLORS.light_grey)
+
+    speed_size = measure_text_cached(self._font_bold, speed_str, 48)
+    speed_pos = rl.Vector2(ahead_rect.x + (ahead_rect.width - speed_size.x) / 2, ahead_rect.y + 26)
+    rl.draw_text_ex(self._font_bold, speed_str, speed_pos, 48, 0, COLORS.white)
+
+    distance_size = measure_text_cached(self._font_medium, distance_str, 28)
+    distance_pos = rl.Vector2(ahead_rect.x + (ahead_rect.width - distance_size.x) / 2, ahead_rect.y + 70)
+    rl.draw_text_ex(self._font_medium, distance_str, distance_pos, 28, 0, COLORS.dark_grey)
+
+  def _format_distance(self, distance: float) -> str:
+    if ui_state.is_metric:
+      if distance < 50:
+        return tr("Near")
+      if distance >= 1000:
+        return f"{distance * METER_TO_KM:.1f}" + tr("km")
+      if distance < 200:
+        rounded = max(10, int(distance / 10) * 10)
+      else:
+        rounded = int(distance / 100) * 100
+      return str(rounded) + tr("m")
+    else:
+      distance_mi = distance * METER_TO_MILE
+      if distance_mi < 0.1:
+        return tr("Near")
+      return f"{distance_mi:.1f}" + tr("mi")
--- a/selfdrive/ui/mici/onroad/torque_bar.py
+++ b/selfdrive/ui/mici/onroad/torque_bar.py
@@ -185,13 +185,13 @@ class TorqueBar(Widget):

    # animate alpha and angle span
    if not self._demo:
-      self._torque_line_alpha_filter.update(ui_state.status != UIStatus.DISENGAGED)
+      self._torque_line_alpha_filter.update(ui_state.status not in (UIStatus.DISENGAGED, UIStatus.LONG_ONLY))
    else:
      self._torque_line_alpha_filter.update(1.0)

    torque_line_bg_alpha = np.interp(abs(self._torque_filter.x), [0.5, 1.0], [0.25, 0.5])
    torque_line_bg_color = rl.Color(255, 255, 255, int(255 * torque_line_bg_alpha * self._torque_line_alpha_filter.x))
-    if ui_state.status != UIStatus.ENGAGED and not self._demo:
+    if ui_state.status not in (UIStatus.ENGAGED, UIStatus.LAT_ONLY) and not self._demo:
      torque_line_bg_color = rl.Color(255, 255, 255, int(255 * 0.15 * self._torque_line_alpha_filter.x))

    # draw curved line polygon torque bar
@@ -234,7 +234,7 @@ class TorqueBar(Widget):
      max(0, abs(self._torque_filter.x) - 0.75) * 4,
    )

-    if ui_state.status != UIStatus.ENGAGED and not self._demo:
+    if ui_state.status not in (UIStatus.ENGAGED, UIStatus.LAT_ONLY) and not self._demo:
      start_color = end_color = rl.Color(255, 255, 255, int(255 * 0.35 * self._torque_line_alpha_filter.x))

    gradient = Gradient(
--- a/selfdrive/ui/onroad/augmented_road_view.py
+++ b/selfdrive/ui/onroad/augmented_road_view.py
@@ -16,6 +16,9 @@ from openpilot.common.transformations.orientation import rot_from_euler

 if gui_app.sunnypilot_ui():
  from openpilot.selfdrive.ui.sunnypilot.onroad.hud_renderer import HudRendererSP as HudRenderer
+  from openpilot.selfdrive.ui.sunnypilot.onroad.driver_state import DriverStateRendererSP as DriverStateRenderer
+
+from openpilot.selfdrive.ui.sunnypilot.onroad.augmented_road_view import BORDER_COLORS_SP

 OpState = log.SelfdriveState.OpenpilotState
 CALIBRATED = log.LiveCalibrationData.Status.calibrated
@@ -27,6 +30,7 @@ BORDER_COLORS = {
  UIStatus.DISENGAGED: rl.Color(0x12, 0x28, 0x39, 0xFF),  # Blue for disengaged state
  UIStatus.OVERRIDE: rl.Color(0x89, 0x92, 0x8D, 0xFF),  # Gray for override state
  UIStatus.ENGAGED: rl.Color(0x16, 0x7F, 0x40, 0xFF),  # Green for engaged state
+  **BORDER_COLORS_SP,
 }

 WIDE_CAM_MAX_SPEED = 10.0  # m/s (22 mph)
--- a/selfdrive/ui/onroad/hud_renderer.py
+++ b/selfdrive/ui/onroad/hud_renderer.py
@@ -2,6 +2,7 @@ import pyray as rl
 from dataclasses import dataclass
 from openpilot.common.constants import CV
 from openpilot.selfdrive.ui.onroad.exp_button import ExpButton
+from openpilot.selfdrive.ui.onroad.speed_limit_ui import SpeedLimitRenderer
 from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus
 from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.lib.multilang import tr
@@ -71,6 +72,7 @@ class HudRenderer(Widget):
    self._font_medium: rl.Font = gui_app.font(FontWeight.MEDIUM)

    self._exp_button: ExpButton = ExpButton(UI_CONFIG.button_size, UI_CONFIG.wheel_icon_size)
+    self._speed_limit_renderer: SpeedLimitRenderer = SpeedLimitRenderer()

  def _update_state(self) -> None:
    """Update HUD state based on car state and controls state."""
@@ -112,6 +114,8 @@ class HudRenderer(Widget):
      COLORS.HEADER_GRADIENT_END,
    )

+    self._speed_limit_renderer.render(rect)
+
    if self.is_cruise_available:
      self._draw_set_speed(rect)

--- a/selfdrive/ui/onroad/model_renderer.py
+++ b/selfdrive/ui/onroad/model_renderer.py
@@ -11,6 +11,8 @@ from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.lib.shader_polygon import draw_polygon, Gradient
 from openpilot.system.ui.widgets import Widget

+from openpilot.selfdrive.ui.sunnypilot.onroad.model_renderer import ChevronMetrics, ModelRendererSP
+
 CLIP_MARGIN = 500
 MIN_DRAW_DISTANCE = 10.0
 MAX_DRAW_DISTANCE = 100.0
@@ -41,9 +43,11 @@ class LeadVehicle:
  fill_alpha: int = 0


-class ModelRenderer(Widget):
+class ModelRenderer(Widget, ChevronMetrics, ModelRendererSP):
  def __init__(self):
-    super().__init__()
+    Widget.__init__(self)
+    ChevronMetrics.__init__(self)
+    ModelRendererSP.__init__(self)
    self._longitudinal_control = False
    self._experimental_mode = False
    self._blend_filter = FirstOrderFilter(1.0, 0.25, 1 / gui_app.target_fps)
@@ -52,7 +56,8 @@ class ModelRenderer(Widget):
    self._road_edge_stds = np.zeros(2, dtype=np.float32)
    self._lead_vehicles = [LeadVehicle(), LeadVehicle()]
    self._path_offset_z = HEIGHT_INIT[0]
-
+    self._counter = -1
+    self._camera_offset = ui_state.params.get("CameraOffset", return_default=True) if ui_state.active_bundle else 0.0
    # Initialize ModelPoints objects
    self._path = ModelPoints()
    self._lane_lines = [ModelPoints() for _ in range(4)]
@@ -99,6 +104,10 @@ class ModelRenderer(Widget):
    live_calib = sm['liveCalibration']
    self._path_offset_z = live_calib.height[0] if live_calib.height else HEIGHT_INIT[0]

+    if self._counter % 60 == 0:
+      self._camera_offset = ui_state.params.get("CameraOffset", return_default=True) if ui_state.active_bundle else 0.0
+    self._counter += 1
+
    if sm.updated['carParams']:
      self._longitudinal_control = sm['carParams'].openpilotLongitudinalControl

@@ -128,16 +137,17 @@ class ModelRenderer(Widget):

    if render_lead_indicator and radar_state:
      self._draw_lead_indicator()
+      self.chevron_metrics.draw_lead_status(sm, radar_state, self._rect, self._lead_vehicles)

  def _update_raw_points(self, model):
    """Update raw 3D points from model data"""
-    self._path.raw_points = np.array([model.position.x, model.position.y, model.position.z], dtype=np.float32).T
+    self._path.raw_points = np.array([model.position.x, np.array(model.position.y) + self._camera_offset, model.position.z], dtype=np.float32).T

    for i, lane_line in enumerate(model.laneLines):
-      self._lane_lines[i].raw_points = np.array([lane_line.x, lane_line.y, lane_line.z], dtype=np.float32).T
+      self._lane_lines[i].raw_points = np.array([lane_line.x, np.array(lane_line.y) + self._camera_offset, lane_line.z], dtype=np.float32).T

    for i, road_edge in enumerate(model.roadEdges):
-      self._road_edges[i].raw_points = np.array([road_edge.x, road_edge.y, road_edge.z], dtype=np.float32).T
+      self._road_edges[i].raw_points = np.array([road_edge.x, np.array(road_edge.y) + self._camera_offset, road_edge.z], dtype=np.float32).T

    self._lane_line_probs = np.array(model.laneLineProbs, dtype=np.float32)
    self._road_edge_stds = np.array(model.roadEdgeStds, dtype=np.float32)
@@ -155,7 +165,7 @@ class ModelRenderer(Widget):

        # Get z-coordinate from path at the lead vehicle position
        z = self._path.raw_points[idx, 2] if idx < len(self._path.raw_points) else 0.0
-        point = self._map_to_screen(d_rel, -y_rel, z + self._path_offset_z)
+        point = self._map_to_screen(d_rel, -y_rel + self._camera_offset, z + self._path_offset_z)
        if point:
          self._lead_vehicles[i] = self._update_lead_vehicle(d_rel, v_rel, point, self._rect)

@@ -281,6 +291,10 @@ class ModelRenderer(Widget):
    allow_throttle = sm['longitudinalPlan'].allowThrottle or not self._longitudinal_control
    self._blend_filter.update(int(allow_throttle))

+    if ui_state.rainbow_path:
+      self.rainbow_path.draw_rainbow_path(self._rect, self._path)
+      return
+
    if self._experimental_mode:
      # Draw with acceleration coloring
      if len(self._exp_gradient.colors) > 1:
--- a/selfdrive/ui/onroad/speed_limit_ui.py
+++ b/selfdrive/ui/onroad/speed_limit_ui.py
@@ -0,0 +1,231 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+
+import pyray as rl
+from dataclasses import dataclass
+from openpilot.common.constants import CV
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.widgets import Widget
+
+METER_TO_KM = 0.001
+METER_TO_MILE = 0.000621371
+
+
+@dataclass(frozen=True)
+class SpeedLimitColors:
+  white: rl.Color = rl.WHITE
+  black: rl.Color = rl.BLACK
+  red: rl.Color = rl.Color(255, 0, 0, 255)
+  green: rl.Color = rl.Color(0, 255, 0, 255)
+  grey: rl.Color = rl.Color(145, 155, 149, 241)
+  light_grey: rl.Color = rl.Color(200, 200, 200, 255)
+  dark_grey: rl.Color = rl.Color(100, 100, 100, 255)
+  bg_dark: rl.Color = rl.Color(30, 30, 30, 200)
+  card_bg: rl.Color = rl.Color(50, 50, 50, 200)
+
+
+COLORS = SpeedLimitColors()
+
+
+class SpeedLimitRenderer(Widget):
+  def __init__(self):
+    super().__init__()
+    self.speed_limit: float = 0.0
+    self.speed_limit_valid: bool = False
+    self.next_speed_limit: float = 0.0
+    self.next_speed_limit_distance: float = 0.0
+    self.road_name: str = ""
+    self.current_speed: float = 0.0
+    self.lanes: int = 0
+    self.road_context: str = ""
+    self.hazard: str = ""
+    self.vision_curve_speed: float = 0.0
+    self.map_curve_speed: float = 0.0
+    self.tile_loaded: bool = False
+
+    self._font_bold: rl.Font = gui_app.font(FontWeight.BOLD)
+    self._font_semi_bold: rl.Font = gui_app.font(FontWeight.SEMI_BOLD)
+    self._font_medium: rl.Font = gui_app.font(FontWeight.MEDIUM)
+
+  def _update_state(self) -> None:
+    sm = ui_state.sm
+    if sm.recv_frame["carState"] < ui_state.started_frame:
+      return
+
+    speed_conv = CV.MS_TO_KPH if ui_state.is_metric else CV.MS_TO_MPH
+    if sm.valid["mapdOut"]:
+      mapd = sm["mapdOut"]
+      self.speed_limit = mapd.speedLimit * speed_conv
+      self.speed_limit_valid = mapd.speedLimit > 0
+      self.next_speed_limit = mapd.nextSpeedLimit * speed_conv
+      self.next_speed_limit_distance = mapd.nextSpeedLimitDistance
+      self.road_name = mapd.roadName
+      self.lanes = mapd.lanes
+      self.hazard = mapd.hazard
+      self.vision_curve_speed = mapd.visionCurveSpeed * speed_conv
+      self.map_curve_speed = mapd.mapCurveSpeed * speed_conv
+      self.tile_loaded = mapd.tileLoaded
+
+      road_ctx = mapd.roadContext
+      if hasattr(road_ctx, 'raw'):
+        ctx_val = road_ctx.raw
+      else:
+        ctx_val = int(road_ctx)
+      self.road_context = ["Freeway", "City", "Unknown"][ctx_val] if ctx_val < 3 else "Unknown"
+    else:
+      self.speed_limit_valid = False
+      self.tile_loaded = False
+
+    if sm.updated["carState"]:
+      self.current_speed = sm["carState"].vEgo * speed_conv
+
+  def _render(self, rect: rl.Rectangle) -> None:
+    self._update_state()
+
+    panel_width = 320
+    panel_height = 340
+    panel_x = rect.x + 12
+    panel_y = rect.y + rect.height / 2 - panel_height / 2
+    panel_rect = rl.Rectangle(panel_x, panel_y, panel_width, panel_height)
+    rl.draw_rectangle_rounded(panel_rect, 0.1, 10, COLORS.bg_dark)
+
+    margin = 15
+    sign_width = 110 if ui_state.is_metric else 100
+    sign_height = 120 if ui_state.is_metric else 110
+    sign_x = panel_x + margin
+    sign_y = panel_y + margin
+
+    self._draw_speed_limit_sign(sign_x, sign_y, sign_width, sign_height)
+    info_x = sign_x + sign_width + 15
+    info_width = panel_width - sign_width - margin * 2 - 15
+    info_y = panel_y + 20
+
+    # Road name
+    self._draw_road_name(info_x, info_y, info_width)
+    info_y += 40
+
+    # Road context and lanes
+    self._draw_road_details(info_x, info_y, info_width)
+    info_y += 35
+
+    # Next speed limit
+    self._draw_next_speed_limit(info_x, info_y, info_width)
+
+    info_y = panel_y + sign_height + margin + 25
+
+    # Curve speeds
+    self._draw_curve_speeds(panel_x + margin, info_y, panel_width - margin * 2)
+    info_y += 35
+
+    # Hazard warning beta
+    if self.hazard:
+      self._draw_hazard(panel_x + margin, info_y, panel_width - margin * 2)
+      info_y += 35
+
+    status_text = tr("Map Loaded") if self.tile_loaded else tr("No Map Data")
+    status_color = COLORS.green if self.tile_loaded else COLORS.red
+    status_size = measure_text_cached(self._font_medium, status_text, 18)
+    status_pos = rl.Vector2(panel_x + (panel_width - status_size.x) / 2, panel_y + panel_height - 28)
+    rl.draw_text_ex(self._font_medium, status_text, status_pos, 18, 0, status_color)
+
+  def _draw_speed_limit_sign(self, x: float, y: float, width: float, height: float) -> None:
+    speed_str = str(round(self.speed_limit)) if self.speed_limit_valid else "--"
+    speed_color = COLORS.black if not self.speed_limit_valid or self.current_speed <= self.speed_limit else COLORS.red
+
+    if ui_state.is_metric:
+      self._draw_vienna_sign(x, y, width, height, speed_str, speed_color)
+    else:
+      self._draw_mutcd_sign(x, y, width, height, speed_str, speed_color)
+
+  def _draw_vienna_sign(self, x: float, y: float, width: float, height: float, speed_str: str, speed_color: rl.Color) -> None:
+    center = rl.Vector2(x + width / 2, y + height / 2)
+    outer_radius = min(width, height) / 2
+
+    rl.draw_circle_v(center, outer_radius, COLORS.white)
+    ring_width = outer_radius * 0.18
+    rl.draw_ring(center, outer_radius - ring_width, outer_radius, 0, 360, 36, COLORS.red)
+
+    font_size = outer_radius * (0.7 if len(speed_str) >= 3 else 0.9)
+    text_size = measure_text_cached(self._font_bold, speed_str, int(font_size))
+    text_pos = rl.Vector2(center.x - text_size.x / 2, center.y - text_size.y / 2)
+    rl.draw_text_ex(self._font_bold, speed_str, text_pos, font_size, 0, speed_color)
+
+  def _draw_mutcd_sign(self, x: float, y: float, width: float, height: float, speed_str: str, speed_color: rl.Color) -> None:
+    sign_rect = rl.Rectangle(x, y, width, height)
+    rl.draw_rectangle_rounded(sign_rect, 0.2, 10, COLORS.white)
+    rl.draw_rectangle_rounded_lines_ex(sign_rect, 0.2, 10, 3, COLORS.black)
+
+    speed_label = tr("SPEED")
+    limit_label = tr("LIMIT")
+    label_size = 16
+
+    speed_text_size = measure_text_cached(self._font_semi_bold, speed_label, label_size)
+    speed_pos = rl.Vector2(x + (width - speed_text_size.x) / 2, y + 8)
+    rl.draw_text_ex(self._font_semi_bold, speed_label, speed_pos, label_size, 0, COLORS.black)
+
+    limit_text_size = measure_text_cached(self._font_semi_bold, limit_label, label_size)
+    limit_pos = rl.Vector2(x + (width - limit_text_size.x) / 2, y + 26)
+    rl.draw_text_ex(self._font_semi_bold, limit_label, limit_pos, label_size, 0, COLORS.black)
+
+    font_size = 40 if len(speed_str) >= 3 else 50
+    num_size = measure_text_cached(self._font_bold, speed_str, font_size)
+    num_pos = rl.Vector2(x + (width - num_size.x) / 2, y + 45)
+    rl.draw_text_ex(self._font_bold, speed_str, num_pos, font_size, 0, speed_color)
+
+  def _draw_road_name(self, x: float, y: float, width: float) -> None:
+    road_display = self.road_name if self.road_name else "--"
+    road_size = measure_text_cached(self._font_semi_bold, road_display, 26)
+    if road_size.x > width:
+      road_display = road_display[:15] + "..."
+    rl.draw_text_ex(self._font_semi_bold, road_display, rl.Vector2(x, y), 26, 0, COLORS.white)
+
+  def _draw_road_details(self, x: float, y: float, width: float) -> None:
+    details = []
+    if self.road_context and self.road_context != "Unknown":
+      details.append(self.road_context)
+    if self.lanes > 0:
+      details.append(f"{self.lanes} {tr('lanes')}")
+    details_text = " • ".join(details) if details else "--"
+    rl.draw_text_ex(self._font_medium, details_text, rl.Vector2(x, y), 20, 0, COLORS.light_grey)
+
+  def _draw_next_speed_limit(self, x: float, y: float, width: float) -> None:
+    if self.next_speed_limit > 0 and self.next_speed_limit != self.speed_limit:
+      next_text = f"{tr('Next')}: {round(self.next_speed_limit)} ({self._format_distance(self.next_speed_limit_distance)})"
+    else:
+      next_text = f"{tr('Next')}: --"
+    rl.draw_text_ex(self._font_medium, next_text, rl.Vector2(x, y), 20, 0, COLORS.light_grey)
+
+  def _draw_curve_speeds(self, x: float, y: float, width: float) -> None:
+    unit = tr("km/h") if ui_state.is_metric else tr("mph")
+    vision_val = str(round(self.vision_curve_speed)) if self.vision_curve_speed > 0 else "--"
+    map_val = str(round(self.map_curve_speed)) if self.map_curve_speed > 0 else "--"
+    curve_text = f"{tr('Curve')}: V:{vision_val} M:{map_val} {unit}"
+    rl.draw_text_ex(self._font_medium, curve_text, rl.Vector2(x, y), 20, 0, COLORS.light_grey)
+
+  def _draw_hazard(self, x: float, y: float, width: float) -> None:
+    hazard_text = f"⚠ {self.hazard}"
+    rl.draw_text_ex(self._font_semi_bold, hazard_text, rl.Vector2(x, y), 22, 0, COLORS.red)
+
+  def _format_distance(self, distance: float) -> str:
+    if ui_state.is_metric:
+      if distance < 50:
+        return tr("Near")
+      if distance >= 1000:
+        return f"{distance * METER_TO_KM:.1f}" + tr("km")
+      if distance < 200:
+        rounded = max(10, int(distance / 10) * 10)
+      else:
+        rounded = int(distance / 100) * 100
+      return str(rounded) + tr("m")
+    else:
+      distance_mi = distance * METER_TO_MILE
+      if distance_mi < 0.1:
+        return tr("Near")
+      return f"{distance_mi:.1f}" + tr("mi")
--- a/selfdrive/ui/soundd.py
+++ b/selfdrive/ui/soundd.py
@@ -27,7 +27,7 @@ AMBIENT_DB = 30 # DB where MIN_VOLUME is applied
 DB_SCALE = 30 # AMBIENT_DB + DB_SCALE is where MAX_VOLUME is applied

 VOLUME_BASE = 20
-if HARDWARE.get_device_type() in ("tizi", "tici"):
+if HARDWARE.get_device_type() == "tizi":
  VOLUME_BASE = 10

 AudibleAlert = car.CarControl.HUDControl.AudibleAlert
@@ -55,7 +55,7 @@ sound_list: dict[int, tuple[str, int | None, float]] = {

  **sound_list_sp,
 }
-if HARDWARE.get_device_type() in ("tizi", "tici"):
+if HARDWARE.get_device_type() == "tizi":
  sound_list.update({
    AudibleAlert.engage: ("engage_tizi.wav", 1, MAX_VOLUME),
    AudibleAlert.disengage: ("disengage_tizi.wav", 1, MAX_VOLUME),
--- a/selfdrive/ui/sunnypilot/layouts/onboarding.py
+++ b/selfdrive/ui/sunnypilot/layouts/onboarding.py
@@ -0,0 +1,116 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import pyray as rl
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.system.ui.lib.application import FontWeight
+from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.widgets import Widget
+from openpilot.system.ui.widgets.button import Button, ButtonStyle
+from openpilot.system.ui.widgets.label import Label
+from openpilot.system.version import sunnylink_consent_version, sunnylink_consent_declined
+
+
+class SunnylinkConsentPage(Widget):
+  def __init__(self, done_callback=None):
+    super().__init__()
+    self._done_callback = done_callback
+    self._step = 0
+
+    self._title = Label(tr("sunnylink"), font_size=90, font_weight=FontWeight.BOLD, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_LEFT)
+
+    self._content = [
+      {
+        "text": tr("sunnylink enables secured remote access to your comma device from anywhere, " +
+                   "including settings management, remote monitoring, real-time dashboard, etc."),
+        "primary_btn": tr("Enable"),
+        "secondary_btn": tr("Disable"),
+        "highlight_primary": True
+      },
+      {
+        "text": tr("sunnylink is designed to be enabled as part of sunnypilot's core functionality. " +
+                   "If sunnylink is disabled, features such as settings management, remote monitoring, " +
+                   "real-time dashboards will be unavailable."),
+        "secondary_btn": tr("Back"),
+        "danger_btn": tr("Disable"),
+        "highlight_primary": True
+      }
+    ]
+
+    self._primary_btn = Button("", button_style=ButtonStyle.PRIMARY, click_callback=lambda: self._handle_choice("enable"))
+    self._secondary_btn = Button("", button_style=ButtonStyle.NORMAL, click_callback=lambda: self._handle_choice("secondary"))
+    self._danger_btn = Button("", button_style=ButtonStyle.DANGER, click_callback=lambda: self._handle_choice("disable"))
+
+  def _handle_choice(self, choice):
+    if choice == "enable":
+      ui_state.params.put_bool("SunnylinkEnabled", True)
+      ui_state.params.put("CompletedSunnylinkConsentVersion", sunnylink_consent_version)
+      if self._done_callback:
+        self._done_callback()
+    elif choice == "secondary":
+      if self._step == 0:
+        self._step = 1
+      elif self._step == 1:
+        self._step = 0
+    elif choice == "disable":
+      ui_state.params.put_bool("SunnylinkEnabled", False)
+      ui_state.params.put("CompletedSunnylinkConsentVersion", sunnylink_consent_declined)
+      if self._done_callback:
+        self._done_callback()
+
+  def _render(self, _):
+    step_data = self._content[self._step]
+
+    welcome_x = self._rect.x + 95
+    welcome_y = self._rect.y + 165
+    welcome_rect = rl.Rectangle(welcome_x, welcome_y, self._rect.width - welcome_x, 90)
+    self._title.render(welcome_rect)
+
+    desc_x = welcome_x
+    desc_y = welcome_y + 120
+    desc_rect = rl.Rectangle(desc_x, desc_y, self._rect.width - desc_x, self._rect.height - desc_y - 250)
+
+    desc_label = Label(step_data["text"], font_size=90, font_weight=FontWeight.MEDIUM, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_LEFT)
+    desc_label.render(desc_rect)
+
+    btn_y = self._rect.y + self._rect.height - 160 - 45
+
+    if "danger_btn" in step_data:
+      btn_width = (self._rect.width - 45 * 3) / 2
+
+      self._secondary_btn.set_text(step_data["secondary_btn"])
+      self._secondary_btn.render(rl.Rectangle(self._rect.x + 45, btn_y, btn_width, 160))
+
+      self._danger_btn.set_text(step_data["danger_btn"])
+      self._danger_btn.render(rl.Rectangle(self._rect.x + 45 * 2 + btn_width, btn_y, btn_width, 160))
+
+    else:
+      btn_width = (self._rect.width - 45 * 3) / 2
+
+      self._secondary_btn.set_text(step_data["secondary_btn"])
+      self._secondary_btn.render(rl.Rectangle(self._rect.x + 45, btn_y, btn_width, 160))
+
+      self._primary_btn.set_text(step_data["primary_btn"])
+      self._primary_btn.render(rl.Rectangle(self._rect.x + 45 * 2 + btn_width, btn_y, btn_width, 160))
+
+    return -1
+
+
+class SunnylinkOnboarding:
+  def __init__(self):
+    self.consent_page = SunnylinkConsentPage(done_callback=self._on_done)
+    self.consent_done: bool = ui_state.params.get("CompletedSunnylinkConsentVersion") in {sunnylink_consent_version, sunnylink_consent_declined}
+
+  @property
+  def completed(self) -> bool:
+    return self.consent_done
+
+  def _on_done(self):
+    self.consent_done = True
+
+  def render(self, rect):
+    if not self.consent_done:
+      self.consent_page.render(rect)
--- a/selfdrive/ui/sunnypilot/layouts/settings/device.py
+++ b/selfdrive/ui/sunnypilot/layouts/settings/device.py
@@ -5,8 +5,216 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 from openpilot.selfdrive.ui.layouts.settings.device import DeviceLayout
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.system.hardware import HARDWARE
+from openpilot.system.ui.lib.application import gui_app
+from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.sunnypilot.widgets.list_view import option_item_sp, multiple_button_item_sp, button_item_sp, \
+  dual_button_item_sp, Spacer
+from openpilot.system.ui.widgets import DialogResult
+from openpilot.system.ui.widgets.button import ButtonStyle
+from openpilot.system.ui.widgets.confirm_dialog import alert_dialog, ConfirmDialog
+from openpilot.system.ui.widgets.list_view import text_item
+from openpilot.system.ui.widgets.scroller_tici import LineSeparator
+
+offroad_time_options = {
+  0: 0,
+  1: 5,
+  2: 10,
+  3: 15,
+  4: 30,
+  5: 60,
+  6: 120,
+  7: 180,
+  8: 300,
+  9: 600,
+  10: 1440,
+  11: 1800,
+}


 class DeviceLayoutSP(DeviceLayout):
  def __init__(self):
    DeviceLayout.__init__(self)
+    self._scroller._line_separator = None
+
+  def _initialize_items(self):
+    DeviceLayout._initialize_items(self)
+
+    # Using dual button with no right button for better alignment
+    self._always_offroad_btn = dual_button_item_sp(
+      left_text=lambda: tr("Enable Always Offroad"),
+      left_callback=self._handle_always_offroad,
+      right_text="",
+      right_callback=None,
+    )
+    self._always_offroad_btn.action_item.right_button.set_visible(False)
+
+    self._max_time_offroad = option_item_sp(
+      title=lambda: tr("Max Time Offroad"),
+      description=lambda: tr("Device will automatically shutdown after set time once the engine is turned off.\n(30h is the default)"),
+      param="MaxTimeOffroad",
+      min_value=0,
+      max_value=11,
+      value_change_step=1,
+      on_value_changed=None,
+      enabled=True,
+      icon="",
+      value_map=offroad_time_options,
+      label_width=360,
+      use_float_scaling=False,
+      inline=True,
+      label_callback=self._update_max_time_offroad_label
+    )
+
+    self._device_wake_mode = multiple_button_item_sp(
+      title=lambda: tr("Wake Up Behavior"),
+      description=self.wake_mode_description,
+      param="DeviceBootMode",
+      buttons=[lambda: tr("Default"), lambda: tr("Offroad")],
+      button_width=364,
+      callback=None,
+      inline=True,
+    )
+
+    self._quiet_mode_and_dcam = dual_button_item_sp(
+      left_text=lambda: tr("Quiet Mode"),
+      right_text=lambda: tr("Driver Camera Preview"),
+      left_callback=lambda: ui_state.params.put_bool("QuietMode", not ui_state.params.get_bool("QuietMode")),
+      right_callback=self._show_driver_camera
+    )
+    self._quiet_mode_and_dcam.action_item.right_button.set_button_style(ButtonStyle.NORMAL)
+
+    self._reg_and_training = dual_button_item_sp(
+      left_text=lambda: tr("Regulatory"),
+      left_callback=self._on_regulatory,
+      right_text=lambda: tr("Training Guide"),
+      right_callback=self._on_review_training_guide
+    )
+    self._reg_and_training.action_item.right_button.set_button_style(ButtonStyle.NORMAL)
+
+    self._onroad_uploads_and_reset_settings = dual_button_item_sp(
+      left_text=lambda: tr("Onroad Uploads"),
+      left_callback=lambda: ui_state.params.put_bool("OnroadUploads", not ui_state.params.get_bool("OnroadUploads")),
+      right_text=lambda: tr("Reset Settings"),
+      right_callback=self._reset_settings
+    )
+
+    self._power_buttons = dual_button_item_sp(
+      left_text=lambda: tr("Reboot"),
+      right_text=lambda: tr("Power Off"),
+      left_callback=self._reboot_prompt,
+      right_callback=self._power_off_prompt
+    )
+
+    items = [
+      text_item(lambda: tr("Dongle ID"), self._params.get("DongleId") or (lambda: tr("N/A"))),
+      LineSeparator(),
+      text_item(lambda: tr("Serial"), self._params.get("HardwareSerial") or (lambda: tr("N/A"))),
+      LineSeparator(),
+      self._pair_device_btn,
+      LineSeparator(),
+      self._reset_calib_btn,
+      LineSeparator(),
+      button_item_sp(lambda: tr("Change Language"), lambda: tr("CHANGE"), callback=self._show_language_dialog),
+      LineSeparator(),
+      self._device_wake_mode,
+      LineSeparator(),
+      self._max_time_offroad,
+      LineSeparator(height=10),
+      self._quiet_mode_and_dcam,
+      self._reg_and_training,
+      self._onroad_uploads_and_reset_settings,
+      Spacer(10),
+      LineSeparator(height=10),
+      self._power_buttons,
+    ]
+
+    return items
+
+  def _offroad_transition(self):
+    self._power_buttons.action_item.right_button.set_visible(ui_state.is_offroad())
+
+  @staticmethod
+  def wake_mode_description() -> str:
+    def_str = tr("Default: Device will boot/wake-up normally & will be ready to engage.")
+    offrd_str = tr("Offroad: Device will be in Always Offroad mode after boot/wake-up.")
+    header = tr("Controls state of the device after boot/sleep.")
+
+    return f"{header}\n\n{def_str}\n{offrd_str}"
+
+  @staticmethod
+  def _reset_settings():
+    def _do_reset(result: int):
+      if result == DialogResult.CONFIRM:
+        for _key in ui_state.params.all_keys():
+          ui_state.params.remove(_key)
+        HARDWARE.reboot()
+
+    def _second_confirm(result: int):
+      if result == DialogResult.CONFIRM:
+        gui_app.set_modal_overlay(ConfirmDialog(
+          text=tr("The reset cannot be undone. You have been warned."),
+          confirm_text=tr("Confirm")
+        ), callback=_do_reset)
+
+    gui_app.set_modal_overlay(ConfirmDialog(
+      text=tr("Are you sure you want to reset all sunnypilot settings to default? Once the settings are reset, there is no going back."),
+      confirm_text=tr("Reset")
+    ), callback=_second_confirm)
+
+  @staticmethod
+  def _handle_always_offroad():
+    if ui_state.engaged:
+      gui_app.set_modal_overlay(alert_dialog(tr("Disengage to Enter Always Offroad Mode")))
+      return
+
+    _offroad_mode_state = ui_state.params.get_bool("OffroadMode")
+    _offroad_mode_str = tr("Are you sure you want to exit Always Offroad mode?") if _offroad_mode_state else \
+                        tr("Are you sure you want to enter Always Offroad mode?")
+
+    def _set_always_offroad(result: int):
+      if result == DialogResult.CONFIRM and not ui_state.engaged:
+        ui_state.params.put_bool("OffroadMode", not _offroad_mode_state)
+
+    gui_app.set_modal_overlay(ConfirmDialog(_offroad_mode_str, tr("Confirm")), callback=lambda result: _set_always_offroad(result))
+
+  @staticmethod
+  def _update_max_time_offroad_label(value: int) -> str:
+    label = tr("Always On") if value == 0 else f"{value}" + tr("m") if value < 60 else f"{value // 60}" + tr("h")
+    label += tr(" (Default)") if value == 1800 else ""
+    return label
+
+  def _update_state(self):
+    super()._update_state()
+
+    # Handle Always Offroad button
+    always_offroad = ui_state.params.get_bool("OffroadMode")
+
+    # Text & Color
+    offroad_mode_btn_text = tr("Exit Always Offroad") if always_offroad else tr("Enable Always Offroad")
+    offroad_mode_btn_style = ButtonStyle.NORMAL if always_offroad else ButtonStyle.DANGER
+    self._always_offroad_btn.action_item.left_button.set_text(offroad_mode_btn_text)
+    self._always_offroad_btn.action_item.left_button.set_button_style(offroad_mode_btn_style)
+
+    # Position
+    if self._scroller._items.__contains__(self._always_offroad_btn):
+      self._scroller._items.remove(self._always_offroad_btn)
+    if ui_state.is_offroad() and not always_offroad:
+      self._scroller._items.insert(len(self._scroller._items) - 1, self._always_offroad_btn)
+    else:
+      self._scroller._items.insert(0, self._always_offroad_btn)
+
+    # Quiet Mode button
+    self._quiet_mode_and_dcam.action_item.left_button.set_button_style(ButtonStyle.PRIMARY if ui_state.params.get_bool("QuietMode") else ButtonStyle.NORMAL)
+
+    # Onroad Uploads
+    self._onroad_uploads_and_reset_settings.action_item.left_button.set_button_style(
+      ButtonStyle.PRIMARY if ui_state.params.get_bool("OnroadUploads") else ButtonStyle.NORMAL
+    )
+
+    # Offroad only buttons
+    self._quiet_mode_and_dcam.action_item.right_button.set_enabled(ui_state.is_offroad())
+    self._reg_and_training.action_item.left_button.set_enabled(ui_state.is_offroad())
+    self._reg_and_training.action_item.right_button.set_enabled(ui_state.is_offroad())
+    self._onroad_uploads_and_reset_settings.action_item.right_button.set_enabled(ui_state.is_offroad())
--- a/selfdrive/ui/sunnypilot/layouts/settings/osm.py
+++ b/selfdrive/ui/sunnypilot/layouts/settings/osm.py
@@ -1,232 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import datetime
-import os
-import platform
-import requests
-import shutil
-import threading
-from pathlib import Path
-from time import monotonic
-
-from openpilot.common.params import Params
-from openpilot.selfdrive.ui.ui_state import device, ui_state
-from openpilot.selfdrive.ui.layouts.settings.software import time_ago
-from openpilot.system.hardware.hw import Paths
-from openpilot.system.ui.lib.application import gui_app
-from openpilot.system.ui.lib.multilang import tr
-from openpilot.system.ui.widgets import DialogResult, Widget
-from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
-from openpilot.system.ui.widgets.list_view import text_item
-from openpilot.system.ui.widgets.scroller_tici import Scroller
-
-from openpilot.system.ui.sunnypilot.lib.utils import NoElideButtonAction
-from openpilot.system.ui.sunnypilot.widgets.list_view import ListItemSP
-from openpilot.system.ui.sunnypilot.widgets.tree_dialog import TreeFolder, TreeNode, TreeOptionDialog
-from openpilot.system.ui.sunnypilot.widgets.progress_bar import progress_item
-
-MAP_PATH = Path(Paths.mapd_root()) / "offline"
-
-
-class OSMLayout(Widget):
-  def __init__(self):
-    super().__init__()
-    self._current_percent = 0
-    self._last_map_size_update = 0
-    self._mem_params = Params("/dev/shm/params") if platform.system() != "Darwin" else ui_state.params
-    self._initialize_items()
-    self._update_map_size()
-    self._progress.set_visible(False)
-    self._state_btn.set_visible(False)
-    self._mapd_version.action_item.set_text(ui_state.params.get("MapdVersion") or "Loading...")
-    self._scroller = Scroller(self.items, line_separator=True, spacing=0)
-
-  def _initialize_items(self):
-    self._mapd_version = text_item(tr("Mapd Version"), lambda: ui_state.params.get("MapdVersion") or "Loading...")
-    self._delete_maps_btn = ListItemSP(tr("Downloaded Maps"), action_item=NoElideButtonAction(tr("DELETE"), enabled=True), callback=self._delete_maps)
-    self._progress = progress_item(tr("Downloading Map"))
-    self._update_btn = ListItemSP(tr("Database Update"), action_item=NoElideButtonAction(tr("CHECK"), enabled=True), callback=self._update_db)
-    self._country_btn = ListItemSP(tr("Country"), action_item=NoElideButtonAction(tr("SELECT"), enabled=True), callback=lambda: self._select_region("Country"))
-    self._state_btn = ListItemSP(tr("State"), action_item=NoElideButtonAction(tr("SELECT"), enabled=True), callback=lambda: self._select_region("State"))
-
-    self.items = [self._mapd_version, self._delete_maps_btn, self._progress, self._update_btn, self._country_btn, self._state_btn]
-
-  def _show_confirm(self, msg, confirm_text, func):
-    gui_app.set_modal_overlay(ConfirmDialog(msg, confirm_text), lambda res: func() if res == DialogResult.CONFIRM else None)
-
-  def calculate_size(self):
-    total_size = 0
-    directories_to_scan = [MAP_PATH] if MAP_PATH.exists() else []
-    while directories_to_scan:
-      try:
-        for entry in os.scandir(directories_to_scan.pop()):
-          if entry.is_file():
-            total_size += entry.stat().st_size
-          elif entry.is_dir():
-            directories_to_scan.append(entry.path)
-      except OSError:
-        pass
-    self._delete_maps_btn.action_item.set_value(f"{total_size / 1024 ** 2:.2f} MB" if total_size < 1024 ** 3 else f"{total_size / 1024 ** 3:.2f} GB")
-
-  def _update_map_size(self):
-    threading.Thread(target=self.calculate_size, daemon=True).start()
-
-  def _do_delete_maps(self):
-    if MAP_PATH.exists():
-      shutil.rmtree(MAP_PATH)
-
-    for param in ("OsmDownloadedDate", "OsmLocal", "OsmLocationName", "OsmLocationTitle", "OsmStateName", "OsmStateTitle"):
-      ui_state.params.remove(param)
-
-    self._delete_maps_btn.action_item.set_enabled(True)
-    self._delete_maps_btn.action_item.set_text(tr("DELETE"))
-    self._update_map_size()
-
-  def _on_confirm_delete_maps(self):
-    self._delete_maps_btn.action_item.set_enabled(False)
-    self._delete_maps_btn.action_item.set_text("DELETING...")
-    threading.Thread(target=self._do_delete_maps).start()
-
-  def _delete_maps(self):
-    self._show_confirm(tr("This will delete ALL downloaded maps\n\nAre you sure you want to delete all maps?"),
-                       tr("Yes, delete all maps"), self._on_confirm_delete_maps)
-
-  def _update_db(self):
-    self._show_confirm(tr("This will start the download process and it might take a while to complete."), tr("Start Download"),
-                       lambda: ui_state.params.put_bool("OsmDbUpdatesCheck", True))
-
-  def _select_region(self, region_type):
-    is_country = region_type == "Country"
-    btn = self._country_btn if is_country else self._state_btn
-    btn.action_item.set_enabled(False)
-    btn.action_item.set_text(tr("FETCHING..."))
-    threading.Thread(target=self._do_select_region, args=(region_type, btn)).start()
-
-  def _handle_region_selection(self, region_type, locations, key, res, ref):
-    if res != DialogResult.CONFIRM or not ref:
-      if region_type == "State" and res == DialogResult.CANCEL:
-        if ui_state.params.get("OsmLocationName") == "US" and not ui_state.params.get("OsmStateName"):
-          ui_state.params.remove("OsmLocationName")
-          ui_state.params.remove("OsmLocationTitle")
-          ui_state.params.remove("OsmLocal")
-          self._update_labels()
-      return
-
-    if region_type == "Country":
-      ui_state.params.put_bool("OsmLocal", True)
-      ui_state.params.remove("OsmStateName")
-      ui_state.params.remove("OsmStateTitle")
-
-    ui_state.params.put(f"{key}Name", ref)
-    name = next((n.data['display_name'] for n in locations if n.ref == ref), ref)
-    ui_state.params.put(f"{key}Title", name)
-
-    if ref == "US" and region_type == "Country":
-      self._select_region("State")
-    else:
-      self._update_db()
-
-  def _do_select_region(self, region_type, btn):
-    base_url = "https://raw.githubusercontent.com/pfeiferj/openpilot-mapd/main/"
-    url = base_url + ("nation_bounding_boxes.json" if region_type == "Country" else "us_states_bounding_boxes.json")
-    try:
-      data = requests.get(url, timeout=10).json()
-      locations = sorted([TreeNode(ref=k, data={'display_name': v['full_name']}) for k, v in data.items()], key=lambda n: n.data['display_name'])
-    except Exception:
-      locations = []
-
-    if region_type == "State":
-      locations.insert(0, TreeNode(ref="All", data={'display_name': tr("All states (~6.0 GB)")}))
-
-    btn.action_item.set_enabled(True)
-    btn.action_item.set_text(tr("SELECT"))
-
-    key = "OsmLocation" if region_type == "Country" else "OsmState"
-    current = ui_state.params.get(f"{key}Name") or ""
-
-    dialog = TreeOptionDialog(tr(f"Select {region_type}"), [TreeFolder(folder="", nodes=locations)], current_ref=current, search_prompt="Perform a search")
-    dialog.on_exit = lambda res: self._handle_region_selection(region_type, locations, key, res, dialog.selection_ref)
-    gui_app.set_modal_overlay(dialog, callback=lambda res: self._handle_region_selection(region_type, locations, key, res, dialog.selection_ref))
-
-  def _update_labels(self):
-    downloading = bool(self._mem_params.get("OSMDownloadLocations"))
-    self._country_btn.set_enabled(not downloading)
-    self._state_btn.set_enabled(not downloading)
-    self._state_btn.set_visible(ui_state.params.get("OsmLocationName") == "US")
-    self._update_btn.set_visible(bool(ui_state.params.get("OsmLocationName")))
-
-    self._country_btn.action_item.set_value(ui_state.params.get("OsmLocationTitle") or "")
-    self._state_btn.action_item.set_value(ui_state.params.get("OsmStateTitle") or "")
-
-    pending = ui_state.params.get_bool("OsmDbUpdatesCheck")
-    if downloading or pending:
-      if downloading:
-        device._reset_interactive_timeout()
-        self._update_map_size()
-      self._progress.set_visible(True)
-      progress = ui_state.params.get("OSMDownloadProgress")
-      total = progress.get('total_files', 0) if progress else 0
-      done = progress.get('downloaded_files', 0) if progress else 0
-      failed = total > 0 and not downloading and done < total
-
-      if total > 0:
-        progress_perc = max(0.0, min(100.0, (done / total) * 100.0))
-      else:
-        progress_perc = 0.0
-
-      if failed:
-        text = "0% - Downloading Maps"
-        btn_text = tr("Error: Invalid download. Retry.")
-        self._current_percent = 0.0
-      elif total > 0 and downloading:
-        self._current_percent = progress_perc
-        perc_int = int(progress_perc)
-        text = f"{perc_int}% - Downloading Maps"
-        btn_text = f"{done}/{total} ({perc_int}%)"
-      else:
-        self._current_percent = 0.0
-        text = "0% - Downloading Maps"
-        btn_text = tr("Downloading Maps...")
-
-      self._progress.action_item.update(self._current_percent, text, show_progress=total > 0 and downloading and not failed)
-      self._update_btn.action_item.set_enabled(not downloading)  # TODO-SP: introduce CANCEL database download with mapd
-      self._update_btn.action_item.set_value(btn_text)
-      self._country_btn.action_item.set_enabled(not downloading)
-      self._state_btn.action_item.set_enabled(not downloading)
-      self._delete_maps_btn.action_item.set_enabled(not downloading)
-    else:
-      self._progress.set_visible(False)
-      self._update_btn.action_item.set_enabled(True)
-      self._country_btn.action_item.set_enabled(True)
-      self._state_btn.action_item.set_enabled(True)
-      self._delete_maps_btn.action_item.set_enabled(True)
-
-      ts = ui_state.params.get("OsmDownloadedDate")
-      dt: datetime.datetime | None = None
-
-      if ts:
-        try:
-          ts_f = float(ts)
-          if ts_f > 0:
-            dt = datetime.datetime.fromtimestamp(ts_f, tz=datetime.UTC)
-        except (ValueError, TypeError):
-          dt = None
-
-      formatted = time_ago(dt)
-      self._update_btn.action_item.set_value(tr("Last checked {}").format(formatted))
-
-  def show_event(self):
-    self._scroller.show_event()
-
-  def _update_state(self):
-    now = monotonic()
-    if now - self._last_map_size_update >= 1.0:
-      self._last_map_size_update = now
-      self._update_labels()
-
-  def _render(self, rect):
-    self._scroller.render(rect)
--- a/selfdrive/ui/sunnypilot/layouts/settings/settings.py
+++ b/selfdrive/ui/sunnypilot/layouts/settings/settings.py
@@ -4,33 +4,33 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
+
 from dataclasses import dataclass
 from enum import IntEnum

 import pyray as rl
 from openpilot.selfdrive.ui.layouts.settings import settings as OP
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.device import DeviceLayoutSP
 from openpilot.selfdrive.ui.layouts.settings.firehose import FirehoseLayout
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.software import SoftwareLayoutSP
 from openpilot.selfdrive.ui.layouts.settings.toggles import TogglesLayout
-from openpilot.system.ui.lib.application import gui_app, MousePos
-from openpilot.system.ui.lib.multilang import tr_noop
-from openpilot.system.ui.sunnypilot.lib.styles import style
-from openpilot.system.ui.widgets.scroller_tici import Scroller
-from openpilot.system.ui.lib.text_measure import measure_text_cached
-from openpilot.system.ui.lib.wifi_manager import WifiManager
-from openpilot.system.ui.widgets import Widget
+from openpilot.selfdrive.ui.sunnypilot.layouts.settings.cruise import CruiseLayout
+from openpilot.selfdrive.ui.sunnypilot.layouts.settings.developer import DeveloperLayoutSP
+from openpilot.selfdrive.ui.sunnypilot.layouts.settings.device import DeviceLayoutSP
+from openpilot.selfdrive.ui.sunnypilot.layouts.settings.display import DisplayLayout
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.models import ModelsLayout
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.network import NetworkUISP
+from openpilot.selfdrive.ui.sunnypilot.layouts.settings.software import SoftwareLayoutSP
+from openpilot.selfdrive.ui.sunnypilot.layouts.settings.steering import SteeringLayout
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.sunnylink import SunnylinkLayout
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.osm import OSMLayout
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.trips import TripsLayout
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.vehicle import VehicleLayout
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.steering import SteeringLayout
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.cruise import CruiseLayout
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.visuals import VisualsLayout
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.display import DisplayLayout
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.developer import DeveloperLayoutSP
+from openpilot.system.ui.lib.application import gui_app, MousePos
+from openpilot.system.ui.lib.multilang import tr_noop
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.lib.wifi_manager import WifiManager
+from openpilot.system.ui.sunnypilot.lib.styles import style
+from openpilot.system.ui.widgets import Widget
+from openpilot.system.ui.widgets.scroller_tici import Scroller

 # from openpilot.selfdrive.ui.sunnypilot.layouts.settings.navigation import NavigationLayout

@@ -39,14 +39,14 @@ ICON_SIZE = 70

 OP.PanelType = IntEnum(  # type: ignore
  "PanelType",
-  [es.name for es in OP.PanelType] + [
+  [es.name for es in OP.PanelType]
+  + [
    "SUNNYLINK",
    "MODELS",
    "STEERING",
    "CRUISE",
    "VISUALS",
    "DISPLAY",
-    "OSM",
    "NAVIGATION",
    "TRIPS",
    "VEHICLE",
@@ -75,22 +75,16 @@ class NavButton(Widget):

    # Draw background if selected
    if is_selected:
-      self.container_rect = rl.Rectangle(
-        content_x - 50, rect.y, OP.SIDEBAR_WIDTH - 50, OP.NAV_BTN_HEIGHT
-      )
+      self.container_rect = rl.Rectangle(content_x - 50, rect.y, OP.SIDEBAR_WIDTH - 50, OP.NAV_BTN_HEIGHT)
      rl.draw_rectangle_rounded(self.container_rect, 0.2, 5, OP.CLOSE_BTN_COLOR)

    if self.panel_info.icon:
      icon_texture = gui_app.texture(self.panel_info.icon, ICON_SIZE, ICON_SIZE, keep_aspect_ratio=True)
-      rl.draw_texture(icon_texture, int(content_x), int(rect.y + (OP.NAV_BTN_HEIGHT - icon_texture.height) / 2),
-                      rl.WHITE)
+      rl.draw_texture(icon_texture, int(content_x), int(rect.y + (OP.NAV_BTN_HEIGHT - icon_texture.height) / 2), rl.WHITE)
      content_x += ICON_SIZE + 20

    # Draw button text (right-aligned)
-    text_pos = rl.Vector2(
-      content_x,
-      rect.y + (OP.NAV_BTN_HEIGHT - text_size.y) / 2
-    )
+    text_pos = rl.Vector2(content_x, rect.y + (OP.NAV_BTN_HEIGHT - text_size.y) / 2)
    rl.draw_text_ex(self.parent._font_medium, self.panel_info.name, text_pos, 55, 0, text_color)

    # Store button rect for click detection
@@ -120,7 +114,6 @@ class SettingsLayoutSP(OP.SettingsLayout):
      OP.PanelType.CRUISE: PanelInfo(tr_noop("Cruise"), CruiseLayout(), icon="icons/speed_limit.png"),
      OP.PanelType.VISUALS: PanelInfo(tr_noop("Visuals"), VisualsLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_visuals.png"),
      OP.PanelType.DISPLAY: PanelInfo(tr_noop("Display"), DisplayLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_display.png"),
-      OP.PanelType.OSM: PanelInfo(tr_noop("OSM"), OSMLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_map.png"),
      # OP.PanelType.NAVIGATION: PanelInfo(tr_noop("Navigation"), NavigationLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_map.png"),
      OP.PanelType.TRIPS: PanelInfo(tr_noop("Trips"), TripsLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_trips.png"),
      OP.PanelType.VEHICLE: PanelInfo(tr_noop("Vehicle"), VehicleLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_vehicle.png"),
@@ -132,12 +125,9 @@ class SettingsLayoutSP(OP.SettingsLayout):
    rl.draw_rectangle_rec(rect, OP.SIDEBAR_COLOR)

    # Close button
-    close_btn_rect = rl.Rectangle(
-      rect.x + style.ITEM_PADDING * 3, rect.y + style.ITEM_PADDING * 2, style.CLOSE_BTN_SIZE, style.CLOSE_BTN_SIZE
-    )
+    close_btn_rect = rl.Rectangle(rect.x + style.ITEM_PADDING * 3, rect.y + style.ITEM_PADDING * 2, style.CLOSE_BTN_SIZE, style.CLOSE_BTN_SIZE)

-    pressed = (rl.is_mouse_button_down(rl.MouseButton.MOUSE_BUTTON_LEFT) and
-               rl.check_collision_point_rec(rl.get_mouse_position(), close_btn_rect))
+    pressed = rl.is_mouse_button_down(rl.MouseButton.MOUSE_BUTTON_LEFT) and rl.check_collision_point_rec(rl.get_mouse_position(), close_btn_rect)
    close_color = OP.CLOSE_BTN_PRESSED if pressed else OP.CLOSE_BTN_COLOR
    rl.draw_rectangle_rounded(close_btn_rect, 1.0, 20, close_color)

@@ -174,7 +164,7 @@ class SettingsLayoutSP(OP.SettingsLayout):
      rect.x,
      self._close_btn_rect.height + style.ITEM_PADDING * 4,  # Starting Y position for nav items
      rect.width,
-      rect.height - 300  # Remaining height after close button
+      rect.height - 300,  # Remaining height after close button
    )

    if self._nav_items:
--- a/selfdrive/ui/sunnypilot/layouts/settings/sunnylink.py
+++ b/selfdrive/ui/sunnypilot/layouts/settings/sunnylink.py
@@ -4,23 +4,23 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
+import pyray as rl
 from cereal import custom
+from openpilot.selfdrive.ui.sunnypilot.layouts.onboarding import SunnylinkConsentPage
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
 from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.sunnypilot.widgets.list_view import button_item_sp
+from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp
 from openpilot.system.ui.sunnypilot.widgets.sunnylink_pairing_dialog import SunnylinkPairingDialog
+from openpilot.system.ui.widgets import Widget, DialogResult
 from openpilot.system.ui.widgets.button import ButtonStyle, Button
 from openpilot.system.ui.widgets.confirm_dialog import alert_dialog, ConfirmDialog
 from openpilot.system.ui.widgets.label import UnifiedLabel
-from openpilot.system.ui.widgets.list_view import button_item, dual_button_item
+from openpilot.system.ui.widgets.list_view import dual_button_item
 from openpilot.system.ui.widgets.scroller_tici import Scroller, LineSeparator
-from openpilot.system.ui.widgets import Widget, DialogResult
-from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp
-import pyray as rl
-
-if gui_app.sunnypilot_ui():
-  from openpilot.system.ui.sunnypilot.widgets.list_view import button_item_sp as button_item
+from openpilot.system.version import sunnylink_consent_version


 class SunnylinkHeader(Widget):
@@ -160,14 +160,14 @@ class SunnylinkLayout(Widget):
    self._sunnylink_description = SunnylinkDescriptionItem()
    self._sunnylink_description.set_visible(False)

-    self._sponsor_btn = button_item(
+    self._sponsor_btn = button_item_sp(
      title=tr("Sponsor Status"),
      button_text=tr("SPONSOR"),
      description=tr(
        "Become a sponsor of sunnypilot to get early access to sunnylink features when they become available."),
      callback=lambda: self._handle_pair_btn(False)
    )
-    self._pair_btn = button_item(
+    self._pair_btn = button_item_sp(
      title=tr("Pair GitHub Account"),
      button_text=tr("Not Paired"),
      description=tr(
@@ -209,8 +209,8 @@ class SunnylinkLayout(Widget):
    return items

  @staticmethod
-  def _get_sunnylink_dongle_id() -> str | None:
-    return str(ui_state.params.get("SunnylinkDongleId") or (lambda: tr("N/A")))
+  def _get_sunnylink_dongle_id() -> str:
+    return ui_state.params.get("SunnylinkDongleId") or tr("N/A")

  def _handle_pair_btn(self, sponsor_pairing: bool = False):
    sunnylink_dongle_id = self._get_sunnylink_dongle_id()
@@ -302,6 +302,22 @@ class SunnylinkLayout(Widget):
      self._restore_btn.set_text(tr("Restore Settings"))

  def _sunnylink_toggle_callback(self, state: bool):
+    sl_consent: bool = ui_state.params.get("CompletedSunnylinkConsentVersion") == sunnylink_consent_version
+    sl_enabled: bool = ui_state.params.get_bool("SunnylinkEnabled")
+
+    if state and not sl_consent and not sl_enabled:
+      def on_consent_done():
+        enabled = ui_state.params.get_bool("SunnylinkEnabled")
+        self._update_description(enabled)
+        gui_app.set_modal_overlay(None)
+
+      sl_terms_dlg = SunnylinkConsentPage(done_callback=on_consent_done)
+      gui_app.set_modal_overlay(sl_terms_dlg)
+    else:
+      ui_state.params.put_bool("SunnylinkEnabled", state)
+      self._update_description(state)
+
+  def _update_description(self, state: bool):
    if state:
      description = tr(
        "Welcome back!! We're excited to see you've enabled sunnylink again!")
--- a/selfdrive/ui/sunnypilot/layouts/settings/vehicle/init.py
+++ b/selfdrive/ui/sunnypilot/layouts/settings/vehicle/init.py
@@ -23,7 +23,7 @@ class VehicleLayout(Widget):
    self._current_brand = None
    self._platform_selector = PlatformSelector(self._update_brand_settings)

-    self._vehicle_item = ListItemSP(title=self._platform_selector.text, action_item=ButtonAction(text=tr("Select")),
+    self._vehicle_item = ListItemSP(title=self._platform_selector.text, action_item=ButtonAction(text=tr("SELECT")),
                                    callback=self._platform_selector._on_clicked)
    self._vehicle_item.title_color = self._platform_selector.color
    self._legend_widget = LegendWidget(self._platform_selector)
@@ -42,7 +42,7 @@ class VehicleLayout(Widget):
  def _update_brand_settings(self):
    self._vehicle_item._title = self._platform_selector.text
    self._vehicle_item.title_color = self._platform_selector.color
-    vehicle_text = tr("Remove") if ui_state.params.get("CarPlatformBundle") else tr("Select")
+    vehicle_text = tr("REMOVE") if ui_state.params.get("CarPlatformBundle") else tr("SELECT")
    self._vehicle_item.action_item.set_text(vehicle_text)

    brand = self.get_brand()
--- a/selfdrive/ui/sunnypilot/layouts/settings/vehicle/brands/toyota.py
+++ b/selfdrive/ui/sunnypilot/layouts/settings/vehicle/brands/toyota.py
@@ -5,11 +5,55 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.vehicle.brands.base import BrandSettings
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.system.ui.lib.application import gui_app
+from openpilot.system.ui.lib.multilang import tr, tr_noop
+from openpilot.system.ui.widgets import DialogResult
+from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
+from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp
+
+
+DESCRIPTIONS = {
+  'enforce_stock_longitudinal': tr_noop(
+    'sunnypilot will not take over control of gas and brakes. Factory Toyota longitudinal control will be used.'
+  ),
+}


 class ToyotaSettings(BrandSettings):
  def __init__(self):
    super().__init__()

+    self.enforce_stock_longitudinal = toggle_item_sp(
+      lambda: tr("Enforce Factory Longitudinal Control"),
+      description=lambda: tr(DESCRIPTIONS["enforce_stock_longitudinal"]),
+      initial_state=ui_state.params.get_bool("ToyotaEnforceStockLongitudinal"),
+      callback=self._on_enable_enforce_stock_longitudinal,
+      enabled=lambda: not ui_state.engaged,
+    )
+
+    self.items = [self.enforce_stock_longitudinal, ]
+
+  def _on_enable_enforce_stock_longitudinal(self, state: bool):
+    if state:
+      def confirm_callback(result: int):
+        if result == DialogResult.CONFIRM:
+          ui_state.params.put_bool("ToyotaEnforceStockLongitudinal", True)
+          if ui_state.params.get_bool("AlphaLongitudinalEnabled"):
+            ui_state.params.put_bool("AlphaLongitudinalEnabled", False)
+          ui_state.params.put_bool("OnroadCycleRequested", True)
+        else:
+          self.enforce_stock_longitudinal.action_item.set_state(False)
+
+      content = (f"<h1>{self.enforce_stock_longitudinal.title}</h1><br>" +
+                 f"<p>{self.enforce_stock_longitudinal.description}</p>")
+
+      dlg = ConfirmDialog(content, tr("Enable"), rich=True)
+      gui_app.set_modal_overlay(dlg, callback=confirm_callback)
+
+    else:
+      ui_state.params.put_bool("ToyotaEnforceStockLongitudinal", False)
+      ui_state.params.put_bool("OnroadCycleRequested", True)
+
  def update_settings(self):
    pass
--- a/selfdrive/ui/sunnypilot/layouts/sidebar.py
+++ b/selfdrive/ui/sunnypilot/layouts/sidebar.py
@@ -0,0 +1,87 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import pyray as rl
+import time
+from dataclasses import dataclass
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
+from openpilot.system.ui.lib.multilang import tr_noop
+
+
+PING_TIMEOUT_NS = 80_000_000_000  # 80 seconds in nanoseconds
+METRIC_HEIGHT = 126
+METRIC_MARGIN = 30
+METRIC_START_Y = 300
+HOME_BTN = rl.Rectangle(60, 860, 180, 180)
+
+
+# Color scheme
+class Colors:
+  WHITE = rl.WHITE
+  WHITE_DIM = rl.Color(255, 255, 255, 85)
+  GRAY = rl.Color(84, 84, 84, 255)
+
+  # Status colors
+  GOOD = rl.WHITE
+  WARNING = rl.Color(218, 202, 37, 255)
+  DANGER = rl.Color(201, 34, 49, 255)
+  PROGRESS = rl.Color(0, 134, 233, 255)
+  DISABLED = rl.Color(128, 128, 128, 255)
+
+  # UI elements
+  METRIC_BORDER = rl.Color(255, 255, 255, 85)
+  BUTTON_NORMAL = rl.WHITE
+  BUTTON_PRESSED = rl.Color(255, 255, 255, 166)
+
+
+@dataclass(slots=True)
+class MetricData:
+  label: str
+  value: str
+  color: rl.Color
+
+  def update(self, label: str, value: str, color: rl.Color):
+    self.label = label
+    self.value = value
+    self.color = color
+
+
+class SidebarSP:
+  def __init__(self):
+    self._sunnylink_status = MetricData(tr_noop("SUNNYLINK"), tr_noop("OFFLINE"), Colors.WARNING)
+
+  def _update_sunnylink_status(self):
+    if not ui_state.params.get_bool("SunnylinkEnabled"):
+      self._sunnylink_status.update(tr_noop("SUNNYLINK"), tr_noop("DISABLED"), Colors.DISABLED)
+      return
+
+    last_ping = ui_state.params.get("LastSunnylinkPingTime") or 0
+    dongle_id = ui_state.params.get("SunnylinkDongleId")
+
+    is_online = last_ping and (time.monotonic_ns() - last_ping) < PING_TIMEOUT_NS
+    is_temp_fault = ui_state.params.get_bool("SunnylinkTempFault")
+    is_registering = not is_temp_fault and dongle_id in (None, "", UNREGISTERED_SUNNYLINK_DONGLE_ID)
+
+    # Determine status/color pair based on priority
+    if last_ping:
+      status, color = (tr_noop("ONLINE"), Colors.GOOD) if is_online else (tr_noop("ERROR"), Colors.DANGER)
+    elif is_temp_fault:
+      status, color = (tr_noop("FAULT"), Colors.WARNING)
+    elif is_registering:
+      status, color = (tr_noop("REGIST..."), Colors.PROGRESS)
+    else:
+      status, color = (tr_noop("OFFLINE"), Colors.DANGER)
+
+    self._sunnylink_status.update(tr_noop("SUNNYLINK"), status, color)
+
+  def _draw_metrics_w_sunnylink(self, rect: rl.Rectangle, _temp, _panda, _connect):
+    metrics = [_temp, _panda, _connect, self._sunnylink_status]
+    start_y = int(rect.y) + METRIC_START_Y
+    available_height = max(0, int(HOME_BTN.y) - METRIC_MARGIN - METRIC_HEIGHT - start_y)
+    spacing = available_height / max(1, len(metrics) - 1)
+
+    return metrics, start_y, spacing
--- a/selfdrive/ui/sunnypilot/mici/init.py
+++ b/selfdrive/ui/sunnypilot/mici/init.py
--- a/sunnypilot/selfdrive/controls/lib/speed_limit/tests/init.py
+++ b/sunnypilot/selfdrive/controls/lib/speed_limit/tests/init.py
--- a/selfdrive/ui/sunnypilot/mici/layouts/onboarding.py
+++ b/selfdrive/ui/sunnypilot/mici/layouts/onboarding.py
@@ -0,0 +1,97 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import pyray as rl
+from openpilot.system.ui.lib.application import FontWeight, gui_app
+from openpilot.system.ui.widgets.label import UnifiedLabel
+from openpilot.system.ui.widgets.slider import SmallSlider
+from openpilot.system.ui.mici_setup import TermsHeader, TermsPage as SetupTermsPage
+from openpilot.system.version import sunnylink_consent_version, sunnylink_consent_declined
+from openpilot.selfdrive.ui.ui_state import ui_state
+
+
+class SunnylinkConsentPage(SetupTermsPage):
+  def __init__(self, on_accept=None, on_decline=None, left_text: str = "disable", right_text: str = "enable"):
+    super().__init__(on_accept, on_decline, left_text, continue_text=right_text)
+
+    self._title_header = TermsHeader("sunnylink",
+                                     gui_app.texture("../../sunnypilot/selfdrive/assets/logo.png", 66, 60))
+
+    self._terms_label = UnifiedLabel("sunnylink enables secured remote access to your comma device from anywhere, " +
+                                     "including settings management, remote monitoring, real-time dashboard, etc.",
+                                     36, FontWeight.ROMAN)
+
+  @property
+  def _content_height(self):
+    return self._terms_label.rect.y + self._terms_label.rect.height - self._scroll_panel.get_offset()
+
+  def _render(self, _):
+    super()._render(_)
+    return -1
+
+  def _render_content(self, scroll_offset):
+    self._title_header.set_position(self._rect.x + 16, self._rect.y + 12 + scroll_offset)
+    self._title_header.render()
+
+    self._terms_label.render(rl.Rectangle(
+      self._rect.x + 16,
+      self._title_header.rect.y + self._title_header.rect.height + self.ITEM_SPACING,
+      self._rect.width - 100,
+      self._terms_label.get_content_height(int(self._rect.width - 100)),
+    ))
+
+
+class SunnylinkConsentDisableConfirmPage(SunnylinkConsentPage):
+  def __init__(self, on_accept=None, on_decline=None):
+    super().__init__(on_accept=on_decline, on_decline=on_accept, left_text="enable", right_text="disable")
+
+    # we flip the continue & disable buttons to use slider for disable
+    self._continue_slider = True
+    self._continue_button = SmallSlider("disable", confirm_callback=on_decline)
+    self._scroll_panel.set_enabled(lambda: not self._continue_button.is_pressed)
+
+    self._title_header = TermsHeader("disable sunnylink?",
+                                     gui_app.texture("icons_mici/setup/red_warning.png", 66, 60))
+
+    self._terms_label = UnifiedLabel("sunnylink is designed to be enabled as part of sunnypilot's core functionality. " +
+                                     "If sunnylink is disabled, features such as settings management, " +
+                                     "remote monitoring, real-time dashboards will be unavailable.",
+                                     36, FontWeight.ROMAN)
+
+
+class SunnylinkOnboarding:
+  def __init__(self):
+    self.consent_done: bool = ui_state.params.get("CompletedSunnylinkConsentVersion") in {sunnylink_consent_version, sunnylink_consent_declined}
+    self.disable_confirm = False
+
+    self.consent_page = SunnylinkConsentPage(on_decline=self._on_decline, on_accept=self._on_accept)
+    self.confirm_page = SunnylinkConsentDisableConfirmPage(on_decline=self._on_confirm_decline, on_accept=self._on_accept)
+
+  @property
+  def completed(self) -> bool:
+    return self.consent_done
+
+  def _on_accept(self):
+    ui_state.params.put("CompletedSunnylinkConsentVersion", sunnylink_consent_version)
+    ui_state.params.put_bool("SunnylinkEnabled", True)
+    self.consent_done = True
+
+  def _on_decline(self):
+    self.disable_confirm = True
+
+  def _on_confirm_decline(self):
+    ui_state.params.put_bool("SunnylinkEnabled", False)
+    ui_state.params.put("CompletedSunnylinkConsentVersion", sunnylink_consent_declined)
+    self.consent_done = True
+
+  def render(self, rect):
+    if self.consent_done:
+      return
+
+    if self.disable_confirm:
+      self.confirm_page.render(rect)
+    else:
+      self.consent_page.render(rect)
--- a/selfdrive/ui/sunnypilot/mici/layouts/settings.py
+++ b/selfdrive/ui/sunnypilot/mici/layouts/settings.py
@@ -0,0 +1,39 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from enum import IntEnum
+
+from openpilot.selfdrive.ui.mici.layouts.settings import settings as OP
+from openpilot.selfdrive.ui.mici.widgets.button import BigButton
+from openpilot.selfdrive.ui.sunnypilot.mici.layouts.sunnylink import SunnylinkLayoutMici
+
+ICON_SIZE = 70
+
+OP.PanelType = IntEnum(  # type: ignore
+  "PanelType",
+  [es.name for es in OP.PanelType] + [
+    "SUNNYLINK",
+  ],
+  start=0,
+)
+
+
+class SettingsLayoutSP(OP.SettingsLayout):
+  def __init__(self):
+    OP.SettingsLayout.__init__(self)
+
+    sunnylink_btn = BigButton("sunnylink", "", "icons_mici/settings/developer/ssh.png")
+    sunnylink_btn.set_click_callback(lambda: self._set_current_panel(OP.PanelType.SUNNYLINK))
+    self._panels.update({
+      OP.PanelType.SUNNYLINK: OP.PanelInfo("sunnylink", SunnylinkLayoutMici(back_callback=lambda: self._set_current_panel(None))),
+    })
+
+    items = self._scroller._items.copy()
+
+    items.insert(1, sunnylink_btn)
+    self._scroller._items.clear()
+    for item in items:
+      self._scroller.add_widget(item)
--- a/selfdrive/ui/sunnypilot/mici/layouts/sunnylink.py
+++ b/selfdrive/ui/sunnypilot/mici/layouts/sunnylink.py
@@ -0,0 +1,211 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from collections.abc import Callable
+
+import pyray as rl
+from cereal import custom
+from openpilot.selfdrive.ui.mici.widgets.button import BigButton, BigToggle
+from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog, BigConfirmationDialogV2
+from openpilot.selfdrive.ui.sunnypilot.mici.layouts.onboarding import SunnylinkConsentPage
+from openpilot.selfdrive.ui.sunnypilot.mici.widgets.sunnylink_pairing_dialog import SunnylinkPairingDialog
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
+from openpilot.system.ui.lib.application import gui_app, MousePos
+from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.widgets import NavWidget
+from openpilot.system.ui.widgets.scroller import Scroller
+from openpilot.system.version import sunnylink_consent_version, sunnylink_consent_declined
+
+
+class SunnylinkLayoutMici(NavWidget):
+  def __init__(self, back_callback: Callable):
+    super().__init__()
+    self.set_back_callback(back_callback)
+    self._restore_in_progress = False
+    self._backup_in_progress = False
+    self._sunnylink_enabled = ui_state.params.get("SunnylinkEnabled")
+
+    self._sunnylink_toggle = BigToggle(text=tr("enable sunnylink"),
+                                       initial_state=self._sunnylink_enabled,
+                                       toggle_callback=self._sunnylink_toggle_callback)
+    self._sunnylink_sponsor_button = SunnylinkPairBigButton(sponsor_pairing=False)
+    self._sunnylink_pair_button = SunnylinkPairBigButton(sponsor_pairing=True)
+    self._backup_btn = BigButton(tr("backup settings"), "", "")
+    self._backup_btn.set_click_callback(lambda: self._handle_backup_restore_btn(restore=False))
+    self._restore_btn = BigButton(tr("restore settings"), "", "")
+    self._restore_btn.set_click_callback(lambda: self._handle_backup_restore_btn(restore=True))
+    self._sunnylink_uploader_toggle = BigToggle(text=tr("sunnylink uploader"), initial_state=False,
+                                                toggle_callback=self._sunnylink_uploader_callback)
+
+    self._scroller = Scroller([
+      self._sunnylink_toggle,
+      self._sunnylink_sponsor_button,
+      self._sunnylink_pair_button,
+      self._backup_btn,
+      self._restore_btn,
+      self._sunnylink_uploader_toggle
+    ], snap_items=False)
+
+  def _update_state(self):
+    super()._update_state()
+    self._sunnylink_enabled = ui_state.params.get("SunnylinkEnabled")
+    self._sunnylink_toggle.set_checked(self._sunnylink_enabled)
+    self._sunnylink_pair_button.set_visible(self._sunnylink_enabled)
+    self._sunnylink_sponsor_button.set_visible(self._sunnylink_enabled)
+    self._backup_btn.set_visible(self._sunnylink_enabled)
+    self._restore_btn.set_visible(self._sunnylink_enabled)
+    self._sunnylink_uploader_toggle.set_visible(self._sunnylink_enabled)
+    self.handle_backup_restore_progress()
+
+    if ui_state.sunnylink_state.is_sponsor():
+      self._sunnylink_sponsor_button.set_text(tr("thanks"))
+      self._sunnylink_sponsor_button.set_value(ui_state.sunnylink_state.get_sponsor_tier().name.lower())
+      self._sunnylink_sponsor_button.set_enabled(False)
+    else:
+      self._sunnylink_sponsor_button.set_text(tr("sponsor"))
+      self._sunnylink_sponsor_button.set_value("")
+
+    if ui_state.sunnylink_state.is_paired():
+      self._sunnylink_pair_button.set_text(tr("paired"))
+    else:
+      self._sunnylink_pair_button.set_text(tr("pair"))
+
+  def show_event(self):
+    super().show_event()
+    self._scroller.show_event()
+    ui_state.update_params()
+
+  def _render(self, rect: rl.Rectangle):
+    self._scroller.render(rect)
+
+  @staticmethod
+  def _sunnylink_toggle_callback(state: bool):
+    sl_consent: bool = ui_state.params.get("CompletedSunnylinkConsentVersion") == sunnylink_consent_version
+    sl_enabled: bool = ui_state.params.get("SunnylinkEnabled")
+
+    def sl_terms_accepted():
+      ui_state.params.put("CompletedSunnylinkConsentVersion", sunnylink_consent_version)
+      ui_state.params.put_bool("SunnylinkEnabled", True)
+      gui_app.set_modal_overlay(None)
+
+    def sl_terms_declined():
+      ui_state.params.put("CompletedSunnylinkConsentVersion", sunnylink_consent_declined)
+      ui_state.params.put_bool("SunnylinkEnabled", False)
+      gui_app.set_modal_overlay(None)
+
+    if state and not sl_consent and not sl_enabled:
+      sl_terms_dlg = SunnylinkConsentPage(on_accept=sl_terms_accepted, on_decline=sl_terms_declined)
+      gui_app.set_modal_overlay(sl_terms_dlg)
+    else:
+      ui_state.params.put_bool("SunnylinkEnabled", state)
+
+    ui_state.update_params()
+
+  @staticmethod
+  def _sunnylink_uploader_callback(state: bool):
+    ui_state.params.put_bool("EnableSunnylinkUploader", state)
+
+  def _handle_backup_restore_btn(self, restore: bool = False):
+    lbl = tr("slide to restore") if restore else tr("slide to backup")
+    icon = "icons_mici/settings/device/update.png"
+    dlg = BigConfirmationDialogV2(lbl, icon, confirm_callback=self._restore_handler if restore else self._backup_handler)
+    gui_app.set_modal_overlay(dlg)
+
+  def _backup_handler(self):
+    self._backup_in_progress = True
+    self._backup_btn.set_enabled(False)
+    ui_state.params.put_bool("BackupManager_CreateBackup", True)
+
+  def _restore_handler(self):
+    self._restore_in_progress = True
+    self._restore_btn.set_enabled(False)
+    ui_state.params.put("BackupManager_RestoreVersion", "latest")
+
+  def handle_backup_restore_progress(self):
+    sunnylink_backup_manager = ui_state.sm["backupManagerSP"]
+
+    backup_status = sunnylink_backup_manager.backupStatus
+    restore_status = sunnylink_backup_manager.restoreStatus
+    backup_progress = sunnylink_backup_manager.backupProgress
+    restore_progress = sunnylink_backup_manager.restoreProgress
+
+    if self._backup_in_progress:
+      self._restore_btn.set_enabled(False)
+      self._backup_btn.set_enabled(False)
+
+      if backup_status == custom.BackupManagerSP.Status.inProgress:
+        self._backup_in_progress = True
+        self._backup_btn.set_text(tr("backing up"))
+        text = tr(f"{backup_progress}%")
+        self._backup_btn.set_value(text)
+
+      elif backup_status == custom.BackupManagerSP.Status.failed:
+        self._backup_in_progress = False
+        self._backup_btn.set_enabled(not ui_state.is_onroad())
+        self._backup_btn.set_text(tr("backup"))
+        self._backup_btn.set_value(tr("failed"))
+
+      elif (backup_status == custom.BackupManagerSP.Status.completed or
+            (backup_status == custom.BackupManagerSP.Status.idle and backup_progress == 100.0)):
+        self._backup_in_progress = False
+        gui_app.set_modal_overlay(BigDialog(title=tr("settings backed up"), description=""))
+        self._backup_btn.set_enabled(not ui_state.is_onroad())
+
+    elif self._restore_in_progress:
+      self._restore_btn.set_enabled(False)
+      self._backup_btn.set_enabled(False)
+
+      if restore_status == custom.BackupManagerSP.Status.inProgress:
+        self._restore_in_progress = True
+        self._restore_btn.set_text(tr("restoring"))
+        text = tr(f"{restore_progress}%")
+        self._restore_btn.set_value(text)
+
+      elif restore_status == custom.BackupManagerSP.Status.failed:
+        self._restore_in_progress = False
+        self._restore_btn.set_enabled(not ui_state.is_onroad())
+        self._restore_btn.set_text(tr("restore"))
+        self._restore_btn.set_value(tr("failed"))
+        gui_app.set_modal_overlay(BigDialog(title=tr("unable to restore"), description="try again later."))
+
+      elif (restore_status == custom.BackupManagerSP.Status.completed or
+            (restore_status == custom.BackupManagerSP.Status.idle and restore_progress == 100.0)):
+        self._restore_in_progress = False
+        gui_app.set_modal_overlay(BigConfirmationDialogV2(
+          title="slide to restart", icon="icons_mici/settings/device/reboot.png",
+          confirm_callback=lambda: gui_app.request_close()))
+
+    else:
+      can_enable = self._sunnylink_enabled and not ui_state.is_onroad()
+      self._backup_btn.set_enabled(can_enable)
+      self._backup_btn.set_text(tr("backup settings"))
+      self._backup_btn.set_value("")
+      self._restore_btn.set_enabled(can_enable)
+      self._restore_btn.set_text(tr("restore settings"))
+      self._restore_btn.set_value("")
+
+
+class SunnylinkPairBigButton(BigButton):
+  def __init__(self, sponsor_pairing: bool = False):
+    self.sponsor_pairing = sponsor_pairing
+    super().__init__("", "", "")
+
+  def _update_state(self):
+    super()._update_state()
+
+  def _handle_mouse_release(self, mouse_pos: MousePos):
+    super()._handle_mouse_release(mouse_pos)
+
+    dlg: BigDialog | SunnylinkPairingDialog | None = None
+    if UNREGISTERED_SUNNYLINK_DONGLE_ID == (ui_state.params.get("SunnylinkDongleId") or UNREGISTERED_SUNNYLINK_DONGLE_ID):
+      dlg = BigDialog(tr("sunnylink Dongle ID not found. Please reboot & try again."), "")
+    elif self.sponsor_pairing:
+      dlg = SunnylinkPairingDialog(sponsor_pairing=True)
+    elif not self.sponsor_pairing:
+      dlg = SunnylinkPairingDialog(sponsor_pairing=False)
+    if dlg:
+      gui_app.set_modal_overlay(dlg)
--- a/selfdrive/ui/sunnypilot/mici/onroad/init.py
+++ b/selfdrive/ui/sunnypilot/mici/onroad/init.py
--- a/selfdrive/ui/sunnypilot/mici/onroad/confidence_ball.py
+++ b/selfdrive/ui/sunnypilot/mici/onroad/confidence_ball.py
@@ -0,0 +1,26 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from openpilot.selfdrive.ui.onroad.augmented_road_view import BORDER_COLORS
+from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus
+
+
+class ConfidenceBallSP:
+  @staticmethod
+  def get_animate_status_probs():
+    if ui_state.status == UIStatus.LAT_ONLY:
+      return ui_state.sm['modelV2'].meta.disengagePredictions.steerOverrideProbs
+
+    # UIStatus.LONG_ONLY
+    return ui_state.sm['modelV2'].meta.disengagePredictions.brakeDisengageProbs
+
+  @staticmethod
+  def get_lat_long_dot_color():
+    if ui_state.status == UIStatus.LAT_ONLY:
+      return BORDER_COLORS[UIStatus.LAT_ONLY]
+
+    # UIStatus.LONG_ONLY
+    return BORDER_COLORS[UIStatus.LONG_ONLY]
--- a/sunnypilot/selfdrive/controls/lib/smart_cruise_control/init.py
+++ b/sunnypilot/selfdrive/controls/lib/smart_cruise_control/init.py
@@ -4,6 +4,10 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
-from openpilot.common.constants import CV
+import pyray as rl
+from openpilot.selfdrive.ui.ui_state import UIStatus

-MIN_V = 20 * CV.KPH_TO_MS  # Do not operate under 20 km/h
+LANE_LINE_COLORS_SP = {
+  UIStatus.LAT_ONLY: rl.Color(0, 255, 64, 255),
+  UIStatus.LONG_ONLY: rl.Color(0, 255, 64, 255),
+}
--- a/selfdrive/ui/sunnypilot/mici/widgets/init.py
+++ b/selfdrive/ui/sunnypilot/mici/widgets/init.py
--- a/selfdrive/ui/sunnypilot/mici/widgets/sunnylink_pairing_dialog.py
+++ b/selfdrive/ui/sunnypilot/mici/widgets/sunnylink_pairing_dialog.py
@@ -0,0 +1,57 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import base64
+
+import pyray as rl
+from openpilot.common.swaglog import cloudlog
+from openpilot.selfdrive.ui.mici.widgets.pairing_dialog import PairingDialog
+from openpilot.sunnypilot.sunnylink.api import SunnylinkApi, UNREGISTERED_SUNNYLINK_DONGLE_ID, API_HOST
+from openpilot.system.ui.lib.application import FontWeight, gui_app
+from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.widgets import NavWidget
+from openpilot.system.ui.widgets.label import MiciLabel
+
+
+class SunnylinkPairingDialog(PairingDialog):
+  """Dialog for device pairing with QR code."""
+
+  def __init__(self, sponsor_pairing: bool = False):
+    PairingDialog.__init__(self)
+    self._sponsor_pairing = sponsor_pairing
+    label_text = tr("pair with sunnylink") if sponsor_pairing else tr("become a sunnypilot sponsor")
+    self._pair_label = MiciLabel(label_text, 48, font_weight=FontWeight.BOLD,
+                                 color=rl.Color(255, 255, 255, int(255 * 0.9)), line_height=40, wrap_text=True)
+
+  def _get_pairing_url(self) -> str:
+    qr_string = "https://github.com/sponsors/sunnyhaibin"
+
+    if self._sponsor_pairing:
+      try:
+        sl_dongle_id = self._params.get("SunnylinkDongleId") or UNREGISTERED_SUNNYLINK_DONGLE_ID
+        token = SunnylinkApi(sl_dongle_id).get_token()
+        inner_string = f"1|{sl_dongle_id}|{token}"
+        payload_bytes = base64.b64encode(inner_string.encode('utf-8')).decode('utf-8')
+        qr_string = f"{API_HOST}/sso?state={payload_bytes}"
+      except Exception:
+        cloudlog.exception("Failed to get pairing token")
+
+    return qr_string
+
+  def _update_state(self):
+    NavWidget._update_state(self)
+
+
+if __name__ == "__main__":
+  gui_app.init_window("pairing device")
+  pairing = SunnylinkPairingDialog(sponsor_pairing=True)
+  try:
+    for _ in gui_app.render():
+      result = pairing.render(rl.Rectangle(0, 0, gui_app.width, gui_app.height))
+      if result != -1:
+        break
+  finally:
+    del pairing
--- a/selfdrive/ui/sunnypilot/onroad/augmented_road_view.py
+++ b/selfdrive/ui/sunnypilot/onroad/augmented_road_view.py
@@ -0,0 +1,13 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import pyray as rl
+from openpilot.selfdrive.ui.ui_state import UIStatus
+
+BORDER_COLORS_SP = {
+  UIStatus.LAT_ONLY: rl.Color(0x00, 0xC8, 0xC8, 0xFF),  # Cyan for lateral-only state
+  UIStatus.LONG_ONLY: rl.Color(0x96, 0x1C, 0xA8, 0xFF),  # Purple for longitudinal-only state
+}
--- a/selfdrive/ui/sunnypilot/onroad/chevron_metrics.py
+++ b/selfdrive/ui/sunnypilot/onroad/chevron_metrics.py
@@ -0,0 +1,147 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import numpy as np
+
+import pyray as rl
+from openpilot.common.constants import CV
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+
+
+class ChevronOptions:
+  OFF = 0
+  DISTANCE_ONLY = 1
+  SPEED_ONLY = 2
+  TTC_ONLY = 3
+  ALL = 4
+
+
+class ChevronMetrics:
+  def __init__(self):
+    self._lead_status_alpha: float = 0.0
+    self._font = gui_app.font(FontWeight.SEMI_BOLD)
+
+  def update_alpha(self, has_lead: bool):
+    """Update the alpha value for fade in/out animation"""
+    if not has_lead:
+      self._lead_status_alpha = max(0.0, self._lead_status_alpha - 0.05)
+    else:
+      self._lead_status_alpha = min(1.0, self._lead_status_alpha + 0.1)
+
+  def should_render(self) -> bool:
+    """Check if dev UI should be rendered"""
+    return ui_state.chevron_metrics != ChevronOptions.OFF and self._lead_status_alpha > 0.0
+
+  def _draw_lead(self, lead_data, lead_vehicle, v_ego: float, rect: rl.Rectangle):
+    """Draw lead vehicle status information (distance, speed, TTC)"""
+    if not self.should_render():
+      return
+
+    d_rel = lead_data.dRel
+    v_rel = lead_data.vRel
+
+    if not lead_vehicle.chevron or len(lead_vehicle.chevron) < 2:
+      return
+
+    chevron_x = lead_vehicle.chevron[1][0]
+    chevron_y = lead_vehicle.chevron[1][1]
+    sz = np.clip((25 * 30) / (d_rel / 3 + 30), 15.0, 30.0) * 2.35
+
+    text_lines = self._build_text_lines(d_rel, v_rel, v_ego)
+    if not text_lines:
+      return
+
+    self._render_text_lines(text_lines, chevron_x, chevron_y, sz, rect)
+
+  @staticmethod
+  def _build_text_lines(d_rel: float, v_rel: float, v_ego: float) -> list[str]:
+    """Build text lines based on chevron info setting"""
+    text_lines = []
+
+    # Distance
+    if ui_state.chevron_metrics == ChevronOptions.DISTANCE_ONLY or ui_state.chevron_metrics == ChevronOptions.ALL:
+      val = max(0.0, d_rel)
+      unit = "m" if ui_state.is_metric else "ft"
+      if not ui_state.is_metric:
+        val *= 3.28084
+      text_lines.append(f"{val:.0f} {unit}")
+
+    # Speed
+    if ui_state.chevron_metrics == ChevronOptions.SPEED_ONLY or ui_state.chevron_metrics == ChevronOptions.ALL:
+      multiplier = CV.MS_TO_KPH if ui_state.is_metric else CV.MS_TO_MPH
+      val = max(0.0, (v_rel + v_ego) * multiplier)
+      unit = "km/h" if ui_state.is_metric else "mph"
+      text_lines.append(f"{val:.0f} {unit}")
+
+    # Time to collision
+    if ui_state.chevron_metrics == ChevronOptions.TTC_ONLY or ui_state.chevron_metrics == ChevronOptions.ALL:
+      val = (d_rel / v_ego) if (d_rel > 0 and v_ego > 0) else 0.0
+      ttc_text = f"{val:.1f} s" if (0 < val < 200) else "---"
+      text_lines.append(ttc_text)
+
+    return text_lines
+
+  def _render_text_lines(self, text_lines: list[str], chevron_x: float, chevron_y: float,
+                         sz: float, rect: rl.Rectangle):
+    """Render text lines with proper centering and positioning"""
+    font_size = 40
+    line_height = 50
+    margin = 20
+
+    text_y = chevron_y + sz + 15
+    total_height = len(text_lines) * line_height
+
+    # Adjust Y position if text would go off screen
+    if text_y + total_height > rect.height - margin:
+      y_max = min(chevron_y, rect.height - margin)
+      text_y = y_max - 15 - total_height
+      text_y = max(margin, text_y)
+
+    alpha = int(255 * self._lead_status_alpha)
+    text_color = rl.Color(255, 255, 255, alpha)
+    shadow_color = rl.Color(0, 0, 0, int(200 * self._lead_status_alpha))
+
+    for i, line in enumerate(text_lines):
+      y = int(text_y + (i * line_height))
+      if y + line_height > rect.height - margin:
+        break
+
+      # Measure actual text width for proper centering
+      text_size = measure_text_cached(self._font, line, font_size, 0)
+      text_width = text_size.x
+
+      # Center the text horizontally on the chevron
+      x = int(chevron_x - text_width / 2)
+      x = int(np.clip(x, margin, rect.width - text_width - margin))
+
+      # Draw shadow
+      rl.draw_text_ex(self._font, line, rl.Vector2(x + 2, y + 2), font_size, 0, shadow_color)
+      # Draw text
+      rl.draw_text_ex(self._font, line, rl.Vector2(x, y), font_size, 0, text_color)
+
+  def draw_lead_status(self, sm, radar_state, rect, lead_vehicles):
+    lead_one = radar_state.leadOne
+    lead_two = radar_state.leadTwo
+
+    has_lead_one = lead_one.status if lead_one else False
+    has_lead_two = lead_two.status if lead_two else False
+
+    self.update_alpha(has_lead_one or has_lead_two)
+
+    if not self.should_render():
+      return
+
+    v_ego = sm['carState'].vEgo
+
+    if has_lead_one and lead_vehicles[0].chevron:
+      self._draw_lead(lead_one, lead_vehicles[0], v_ego, rect)
+
+    if has_lead_two and lead_vehicles[1].chevron:
+      d_rel_diff = abs(lead_one.dRel - lead_two.dRel) if has_lead_one else float('inf')
+      if d_rel_diff > 3.0:
+        self._draw_lead(lead_two, lead_vehicles[1], v_ego, rect)
--- a/selfdrive/ui/sunnypilot/onroad/developer_ui/init.py
+++ b/selfdrive/ui/sunnypilot/onroad/developer_ui/init.py
@@ -22,6 +22,7 @@ class DeveloperUiRenderer(Widget):
  DEV_UI_RIGHT = 1
  DEV_UI_BOTTOM = 2
  DEV_UI_BOTH = 3
+  BOTTOM_BAR_HEIGHT = 61

  def __init__(self):
    super().__init__()
@@ -43,6 +44,12 @@ class DeveloperUiRenderer(Widget):
    self.bearing_elem = BearingDegElement()
    self.altitude_elem = AltitudeElement()

+  @staticmethod
+  def get_bottom_dev_ui_offset():
+    if ui_state.developer_ui in (DeveloperUiRenderer.DEV_UI_BOTTOM, DeveloperUiRenderer.DEV_UI_BOTH):
+      return DeveloperUiRenderer.BOTTOM_BAR_HEIGHT
+    return 0
+
  def _update_state(self) -> None:
    self.dev_ui_mode = ui_state.developer_ui

@@ -78,10 +85,11 @@ class DeveloperUiRenderer(Widget):
    ]
    if controls_state.lateralControlState.which() == 'torqueState':
      elements.append(self.desired_lat_accel_elem.update(sm, ui_state.is_metric))
-      elements.append(self.actual_lat_accel_elem.update(sm, ui_state.is_metric))
    else:
      elements.append(self.desired_steer_elem.update(sm, ui_state.is_metric))

+    elements.append(self.actual_lat_accel_elem.update(sm, ui_state.is_metric))
+
    current_y = y
    for element in elements:
      current_y += self._draw_right_dev_ui_element(x, current_y, element)
@@ -105,7 +113,7 @@ class DeveloperUiRenderer(Widget):
    if element.unit:
      units_height = measure_text_cached(self._font_bold, element.unit, unit_size, 0).x

-      units_x = x + container_width - 10
+      units_x = x + container_width
      units_y = y + (value_size / 2) + (units_height / 2)

      rl.draw_text_pro(self._font_bold, element.unit, rl.Vector2(units_x, units_y), rl.Vector2(0, 0), -90.0, unit_size, 0, rl.WHITE)
@@ -143,22 +151,35 @@ class DeveloperUiRenderer(Widget):
    if sm.valid['gpsLocationExternal'] or sm.valid['gpsLocation']:
      elements.append(self.altitude_elem.update(sm, ui_state.is_metric))

-    current_x = int(rect.x + 90)
-    center_y = y + bar_height // 2
-    for element in elements:
-      current_x += self._draw_bottom_dev_ui_element(current_x, center_y, element)
+    if not elements:
+      return

-  def _draw_bottom_dev_ui_element(self, x: int, y: int, element: UiElement) -> int:
    font_size = 38
+    element_widths = []
+    for element in elements:
+      element.measure(self._font_bold, font_size)
+      element_widths.append(element.total_width)

-    label_text = f"{element.label} "
-    label_width = measure_text_cached(self._font_bold, label_text, font_size, 0).x
-    rl.draw_text_ex(self._font_bold, label_text, rl.Vector2(x, y - font_size // 2), font_size, 0, rl.WHITE)
+    total_element_width = sum(element_widths)
+    num_gaps = len(elements) + 1
+    available_width = rect.width
+    gap_width = (available_width - total_element_width) / num_gaps

-    value_width = measure_text_cached(self._font_bold, element.value, font_size, 0).x
-    rl.draw_text_ex(self._font_bold, element.value, rl.Vector2(x + label_width + 10, y - font_size // 2), font_size, 0, element.color)
+    center_y = y + bar_height // 2
+    current_x = rect.x + gap_width
+
+    for i, element in enumerate(elements):
+      element_center_x = int(current_x + element_widths[i] / 2)
+      self._draw_bottom_dev_ui_element(element_center_x, center_y, element)
+      current_x += element_widths[i] + gap_width
+
+  def _draw_bottom_dev_ui_element(self, center_x: int, y: int, element: UiElement) -> None:
+    font_size = 38
+    start_x = center_x - element.total_width / 2
+
+    rl.draw_text_ex(self._font_bold, element.label_text, rl.Vector2(start_x, y - font_size // 2), font_size, 0, rl.WHITE)
+    rl.draw_text_ex(self._font_bold, element.val_text, rl.Vector2(start_x + element.label_width, y - font_size // 2), font_size, 0, element.color)

    if element.unit:
-      rl.draw_text_ex(self._font_bold, element.unit, rl.Vector2(x + label_width + value_width + 20, y - font_size // 2), font_size, 0, rl.WHITE)
-
-    return 400
+      rl.draw_text_ex(self._font_bold, element.unit_text, rl.Vector2(start_x + element.label_width + element.val_width, y - font_size // 2),
+                      font_size, 0, rl.WHITE)
--- a/selfdrive/ui/sunnypilot/onroad/developer_ui/elements.py
+++ b/selfdrive/ui/sunnypilot/onroad/developer_ui/elements.py
@@ -10,12 +10,33 @@ from dataclasses import dataclass
 from openpilot.common.constants import CV


+from openpilot.system.ui.lib.text_measure import measure_text_cached
+
+
@dataclass
 class UiElement:
  value: str
  label: str
  unit: str
  color: rl.Color
+  val_text: str = ""
+  label_text: str = ""
+  unit_text: str = ""
+  val_width: float = 0.0
+  label_width: float = 0.0
+  unit_width: float = 0.0
+  total_width: float = 0.0
+
+  def measure(self, font, font_size: int):
+    self.label_text = f"{self.label} "
+    self.val_text = self.value
+    self.unit_text = f" {self.unit}" if self.unit else ""
+
+    self.label_width = measure_text_cached(font, self.label_text, font_size, 0).x
+    self.val_width = measure_text_cached(font, self.val_text, font_size, 0).x
+    self.unit_width = measure_text_cached(font, self.unit_text, font_size, 0).x if self.unit else 0
+
+    self.total_width = self.label_width + self.val_width + self.unit_width


 class LeadInfoElement:
--- a/selfdrive/ui/sunnypilot/onroad/driver_state.py
+++ b/selfdrive/ui/sunnypilot/onroad/driver_state.py
@@ -0,0 +1,49 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import numpy as np
+
+from openpilot.selfdrive.ui import UI_BORDER_SIZE
+from openpilot.selfdrive.ui.onroad.driver_state import DriverStateRenderer, BTN_SIZE, ARC_LENGTH
+from openpilot.selfdrive.ui.sunnypilot.onroad.developer_ui import DeveloperUiRenderer
+
+
+class DriverStateRendererSP(DriverStateRenderer):
+  def __init__(self):
+    super().__init__()
+    self.dev_ui_offset = DeveloperUiRenderer.get_bottom_dev_ui_offset()
+
+  def _pre_calculate_drawing_elements(self):
+    """Pre-calculate all drawing elements based on the current rectangle"""
+    # Calculate icon position (bottom-left or bottom-right)
+    width, height = self._rect.width, self._rect.height
+    offset = UI_BORDER_SIZE + BTN_SIZE // 2
+    self.position_x = self._rect.x + (width - offset if self.is_rhd else offset)
+    self.position_y = self._rect.y + height - offset - self.dev_ui_offset
+
+    # Pre-calculate the face lines positions
+    positioned_keypoints = self.face_keypoints_transformed + np.array([self.position_x, self.position_y])
+    for i in range(len(positioned_keypoints)):
+      self.face_lines[i].x = positioned_keypoints[i][0]
+      self.face_lines[i].y = positioned_keypoints[i][1]
+
+    # Calculate arc dimensions based on head rotation
+    delta_x = -self.driver_pose_sins[1] * ARC_LENGTH / 2.0  # Horizontal movement
+    delta_y = -self.driver_pose_sins[0] * ARC_LENGTH / 2.0  # Vertical movement
+
+    # Horizontal arc
+    h_width = abs(delta_x)
+    self.h_arc_data = self._calculate_arc_data(
+      delta_x, h_width, self.position_x, self.position_y - ARC_LENGTH / 2,
+      self.driver_pose_sins[1], self.driver_pose_diff[1], is_horizontal=True
+    )
+
+    # Vertical arc
+    v_height = abs(delta_y)
+    self.v_arc_data = self._calculate_arc_data(
+      delta_y, v_height, self.position_x - ARC_LENGTH / 2, self.position_y,
+      self.driver_pose_sins[0], self.driver_pose_diff[0], is_horizontal=False
+    )
--- a/selfdrive/ui/sunnypilot/onroad/model_renderer.py
+++ b/selfdrive/ui/sunnypilot/onroad/model_renderer.py
@@ -0,0 +1,14 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from openpilot.selfdrive.ui.sunnypilot.onroad.chevron_metrics import ChevronMetrics
+from openpilot.selfdrive.ui.sunnypilot.onroad.rainbow_path import RainbowPath
+
+
+class ModelRendererSP:
+  def __init__(self):
+    self.rainbow_path = RainbowPath()
+    self.chevron_metrics = ChevronMetrics()
--- a/selfdrive/ui/sunnypilot/onroad/rainbow_path.py
+++ b/selfdrive/ui/sunnypilot/onroad/rainbow_path.py
@@ -0,0 +1,78 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import time
+import colorsys
+import pyray as rl
+from openpilot.system.ui.lib.shader_polygon import draw_polygon, Gradient
+
+
+class RainbowPath:
+  DEFAULT_NUM_SEGMENTS = 8
+  DEFAULT_SPEED = 50.0  # degrees per second
+  DEFAULT_SATURATION = 0.9
+  DEFAULT_LIGHTNESS = 0.6
+  BASE_ALPHA = 0.8
+  ALPHA_FADE = 0.3  # Alpha reduction from bottom to top
+
+  def __init__(self, num_segments: int = None, speed: float = None, saturation: float = None, lightness: float = None):
+    self.num_segments = num_segments if num_segments is not None else self.DEFAULT_NUM_SEGMENTS
+    self.speed = speed if speed is not None else self.DEFAULT_SPEED
+    self.saturation = saturation if saturation is not None else self.DEFAULT_SATURATION
+    self.lightness = lightness if lightness is not None else self.DEFAULT_LIGHTNESS
+
+  def set_speed(self, speed: float):
+    self.speed = speed
+
+  def set_num_segments(self, num_segments: int):
+    self.num_segments = num_segments
+
+  def set_saturation(self, saturation: float):
+    self.saturation = max(0.0, min(1.0, saturation))
+
+  def set_lightness(self, lightness: float):
+    self.lightness = max(0.0, min(1.0, lightness))
+
+  def get_gradient(self) -> Gradient:
+    time_offset = time.monotonic()
+    hue_offset = (time_offset * self.speed) % 360.0
+
+    segment_colors = []
+    gradient_stops = []
+
+    for i in range(self.num_segments):
+      position = i / (self.num_segments - 1)
+      hue = (hue_offset + position * 360.0) % 360.0
+      alpha = self.BASE_ALPHA * (1.0 - position * self.ALPHA_FADE)
+      color = self._hsla_to_color(
+        hue / 360.0,
+        self.saturation,
+        self.lightness,
+        alpha
+      )
+      gradient_stops.append(position)
+      segment_colors.append(color)
+
+    return Gradient(
+      start=(0.0, 1.0),  # Bottom of path
+      end=(0.0, 0.0),  # Top of path
+      colors=segment_colors,
+      stops=gradient_stops,
+    )
+
+  @staticmethod
+  def _hsla_to_color(h: float, s: float, l: float, a: float) -> rl.Color:
+    rgb = colorsys.hls_to_rgb(h, l, s)
+    return rl.Color(
+      int(rgb[0] * 255),
+      int(rgb[1] * 255),
+      int(rgb[2] * 255),
+      int(a * 255)
+    )
+
+  def draw_rainbow_path(self, rect, path):
+    gradient = self.get_gradient()
+    draw_polygon(rect, path.projected_points, gradient=gradient)
--- a/selfdrive/ui/sunnypilot/ui_state.py
+++ b/selfdrive/ui/sunnypilot/ui_state.py
@@ -4,23 +4,69 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
-from cereal import messaging, custom
+from cereal import messaging, log, custom
 from openpilot.common.params import Params
 from openpilot.sunnypilot.sunnylink.sunnylink_state import SunnylinkState

+OpenpilotState = log.SelfdriveState.OpenpilotState
+MADSState = custom.ModularAssistiveDrivingSystem.ModularAssistiveDrivingSystemState
+

 class UIStateSP:
  def __init__(self):
    self.params = Params()
    self.sm_services_ext = [
      "modelManagerSP", "selfdriveStateSP", "longitudinalPlanSP", "backupManagerSP",
-      "gpsLocation", "liveTorqueParameters", "carStateSP", "liveMapDataSP", "carParamsSP", "liveDelay"
+      "gpsLocation", "liveTorqueParameters", "carStateSP", "carParamsSP", "liveDelay",
+      "mapdOut"
    ]

    self.sunnylink_state = SunnylinkState()

+    self.custom_interactive_timeout: int = self.params.get("InteractivityTimeout", return_default=True)
+
  def update(self) -> None:
-    self.sunnylink_state.start()
+    if self.sunnylink_enabled:
+      self.sunnylink_state.start()
+    else:
+      self.sunnylink_state.stop()
+
+  @staticmethod
+  def update_status(ss, ss_sp, onroad_evt) -> str:
+    state = ss.state
+    mads = ss_sp.mads
+    mads_state = mads.state
+
+    if state == OpenpilotState.preEnabled:
+      return "override"
+
+    if state == OpenpilotState.overriding:
+      if not mads.available:
+        return "override"
+
+      if any(e.overrideLongitudinal for e in onroad_evt):
+        return "override"
+
+    if mads_state in (MADSState.paused, MADSState.overriding):
+      return "override"
+
+    # MADS specific statuses
+    if not mads.available:
+      return "engaged" if ss.enabled else "disengaged"
+
+    if not mads.enabled and not ss.enabled:
+      return "disengaged"
+
+    if mads.enabled and ss.enabled:
+      return "engaged"
+
+    if mads.enabled:
+      return "lat_only"
+
+    if ss.enabled:
+      return "long_only"
+
+    return "disengaged"

  def update_params(self) -> None:
    CP_SP_bytes = self.params.get("CarParamsSPPersistent")
@@ -28,3 +74,16 @@ class UIStateSP:
      self.CP_SP = messaging.log_from_bytes(CP_SP_bytes, custom.CarParamsSP)
    self.sunnylink_enabled = self.params.get_bool("SunnylinkEnabled")
    self.developer_ui = self.params.get("DevUIInfo")
+    self.rainbow_path = self.params.get_bool("RainbowMode")
+    self.chevron_metrics = self.params.get("ChevronInfo")
+    self.active_bundle = self.params.get("ModelManager_ActiveBundle")
+    self.custom_interactive_timeout = self.params.get("InteractivityTimeout", return_default=True)
+
+
+class DeviceSP:
+  def __init__(self):
+    self._params = Params()
+
+  def _set_awake(self, on: bool):
+    if on and self._params.get("DeviceBootMode", return_default=True) == 1:
+      self._params.put_bool("OffroadMode", True)
--- a/selfdrive/ui/tests/diff/replay.py
+++ b/selfdrive/ui/tests/diff/replay.py
@@ -13,7 +13,7 @@ if "RECORD_OUTPUT" not in os.environ:
 os.environ["RECORD_OUTPUT"] = os.path.join(DIFF_OUT_DIR, os.environ["RECORD_OUTPUT"])

 from openpilot.common.params import Params
-from openpilot.system.version import terms_version, training_version
+from openpilot.system.version import terms_version, training_version, terms_version_sp, sunnylink_consent_version
 from openpilot.system.ui.lib.application import gui_app, MousePos, MouseEvent
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.selfdrive.ui.mici.layouts.main import MiciMainLayout
@@ -45,6 +45,8 @@ def setup_state():
  params.put("CompletedTrainingVersion", training_version)
  params.put("DongleId", "test123456789")
  params.put("UpdaterCurrentDescription", "0.10.1 / test-branch / abc1234 / Nov 30")
+  params.put("HasAcceptedTermsSP", terms_version_sp)
+  params.put("CompletedSunnylinkConsentVersion", sunnylink_consent_version)
  return None


--- a/selfdrive/ui/tests/test_ui/raylib_screenshots.py
+++ b/selfdrive/ui/tests/test_ui/raylib_screenshots.py
@@ -18,7 +18,7 @@ from openpilot.common.prefix import OpenpilotPrefix
 from openpilot.selfdrive.test.helpers import with_processes
 from openpilot.selfdrive.selfdrived.alertmanager import set_offroad_alert
 from openpilot.system.updated.updated import parse_release_notes
-from openpilot.system.version import terms_version, training_version
+from openpilot.system.version import terms_version, training_version, terms_version_sp, sunnylink_consent_version

 AlertSize = log.SelfdriveState.AlertSize
 AlertStatus = log.SelfdriveState.AlertStatus
@@ -378,6 +378,8 @@ def create_screenshots():
      # Set terms and training version (to skip onboarding)
      params.put("HasAcceptedTerms", terms_version)
      params.put("CompletedTrainingVersion", training_version)
+      params.put("HasAcceptedTermsSP", terms_version_sp)
+      params.put("CompletedSunnylinkConsentVersion", sunnylink_consent_version)

      if name == "homescreen_paired":
        params.put("PrimeType", 0)  # NONE
--- a/selfdrive/ui/tests/test_ui/run.py
+++ b/selfdrive/ui/tests/test_ui/run.py
@@ -1,310 +0,0 @@
-#!/usr/bin/env python3
-import capnp
-import pathlib
-import shutil
-import sys
-import os
-import pywinctl
-import pyautogui
-import pickle
-import time
-from collections import namedtuple
-
-from cereal import car, log
-from msgq.visionipc import VisionIpcServer, VisionStreamType
-from cereal.messaging import PubMaster, log_from_bytes, sub_sock
-from openpilot.common.basedir import BASEDIR
-from openpilot.common.params import Params
-from openpilot.common.prefix import OpenpilotPrefix
-from openpilot.common.transformations.camera import CameraConfig, DEVICE_CAMERAS
-from openpilot.selfdrive.selfdrived.alertmanager import set_offroad_alert
-from openpilot.selfdrive.test.helpers import with_processes
-from openpilot.selfdrive.test.process_replay.migration import migrate, migrate_controlsState, migrate_carState
-from openpilot.tools.lib.logreader import LogReader
-from openpilot.tools.lib.framereader import FrameReader
-from openpilot.tools.lib.route import Route
-from openpilot.tools.lib.cache import DEFAULT_CACHE_DIR
-
-UI_DELAY = 0.1 # may be slower on CI?
-TEST_ROUTE = "a2a0ccea32023010|2023-07-27--13-01-19"
-
-STREAMS: list[tuple[VisionStreamType, CameraConfig, bytes]] = []
-OFFROAD_ALERTS = ['Offroad_StorageMissing', 'Offroad_IsTakingSnapshot']
-DATA: dict[str, capnp.lib.capnp._DynamicStructBuilder] = dict.fromkeys(
-  ["carParams", "deviceState", "pandaStates", "controlsState", "selfdriveState",
-  "liveCalibration", "modelV2", "radarState", "driverMonitoringState", "carState",
-  "driverStateV2", "roadCameraState", "wideRoadCameraState", "driverCameraState"], None)
-
-def setup_homescreen(click, pm: PubMaster):
-  pass
-
-def setup_settings_device(click, pm: PubMaster):
-  click(100, 100)
-
-def setup_settings_toggles(click, pm: PubMaster):
-  setup_settings_device(click, pm)
-  click(278, 600)
-  time.sleep(UI_DELAY)
-
-def setup_settings_software(click, pm: PubMaster):
-  setup_settings_device(click, pm)
-  click(278, 720)
-  time.sleep(UI_DELAY)
-
-def setup_settings_firehose(click, pm: PubMaster):
-  click(1780, 730)
-
-def setup_settings_developer(click, pm: PubMaster):
-  CP = car.CarParams()
-  CP.alphaLongitudinalAvailable = True
-  Params().put("CarParamsPersistent", CP.to_bytes())
-
-  setup_settings_device(click, pm)
-  click(278, 970)
-  time.sleep(UI_DELAY)
-
-def setup_onroad(click, pm: PubMaster):
-  vipc_server = VisionIpcServer("camerad")
-  for stream_type, cam, _ in STREAMS:
-    vipc_server.create_buffers(stream_type, 5, cam.width, cam.height)
-  vipc_server.start_listener()
-
-  uidebug_received_cnt = 0
-  packet_id = 0
-  uidebug_sock = sub_sock('uiDebug')
-
-  # Condition check for uiDebug processing
-  check_uidebug = DATA['deviceState'].deviceState.started and not DATA['carParams'].carParams.notCar
-
-  # Loop until 20 'uiDebug' messages are received
-  while uidebug_received_cnt <= 20:
-    for service, data in DATA.items():
-      if data:
-        data.clear_write_flag()
-        pm.send(service, data)
-
-    for stream_type, _, image in STREAMS:
-      vipc_server.send(stream_type, image, packet_id, packet_id, packet_id)
-
-    if check_uidebug:
-      while uidebug_sock.receive(non_blocking=True):
-        uidebug_received_cnt += 1
-    else:
-      uidebug_received_cnt += 1
-
-    packet_id += 1
-    time.sleep(0.05)
-
-def setup_onroad_disengaged(click, pm: PubMaster):
-  DATA['selfdriveState'].selfdriveState.enabled = False
-  setup_onroad(click, pm)
-  DATA['selfdriveState'].selfdriveState.enabled = True
-
-def setup_onroad_override(click, pm: PubMaster):
-  DATA['selfdriveState'].selfdriveState.state = log.SelfdriveState.OpenpilotState.overriding
-  setup_onroad(click, pm)
-  DATA['selfdriveState'].selfdriveState.state = log.SelfdriveState.OpenpilotState.enabled
-
-
-def setup_onroad_wide(click, pm: PubMaster):
-  DATA['selfdriveState'].selfdriveState.experimentalMode = True
-  DATA["carState"].carState.vEgo = 1
-  setup_onroad(click, pm)
-
-def setup_onroad_sidebar(click, pm: PubMaster):
-  setup_onroad(click, pm)
-  click(500, 500)
-  setup_onroad(click, pm)
-
-def setup_onroad_wide_sidebar(click, pm: PubMaster):
-  setup_onroad_wide(click, pm)
-  click(500, 500)
-  setup_onroad_wide(click, pm)
-
-def setup_body(click, pm: PubMaster):
-  DATA['carParams'].carParams.brand = "body"
-  DATA['carParams'].carParams.notCar = True
-  DATA['carState'].carState.charging = True
-  DATA['carState'].carState.fuelGauge = 50.0
-  setup_onroad(click, pm)
-
-def setup_keyboard(click, pm: PubMaster):
-  setup_settings_device(click, pm)
-  click(250, 965)
-  click(1930, 420)
-
-def setup_keyboard_uppercase(click, pm: PubMaster):
-  setup_keyboard(click, pm)
-  click(200, 800)
-
-def setup_driver_camera(click, pm: PubMaster):
-  setup_settings_device(click, pm)
-  click(1950, 435)
-  DATA['deviceState'].deviceState.started = False
-  setup_onroad(click, pm)
-  DATA['deviceState'].deviceState.started = True
-
-def setup_onroad_alert(click, pm: PubMaster, text1, text2, size, status=log.SelfdriveState.AlertStatus.normal):
-  print(f'setup onroad alert, size: {size}')
-  state = DATA['selfdriveState']
-  origin_state_bytes = state.to_bytes()
-  cs = state.selfdriveState
-  cs.alertText1 = text1
-  cs.alertText2 = text2
-  cs.alertSize = size
-  cs.alertStatus = status
-  cs.alertType = "test_onroad_alert"
-  setup_onroad(click, pm)
-  DATA['selfdriveState'] = log_from_bytes(origin_state_bytes).as_builder()
-
-def setup_onroad_alert_small(click, pm: PubMaster):
-  setup_onroad_alert(click, pm, 'This is a small alert message', '', log.SelfdriveState.AlertSize.small)
-
-def setup_onroad_alert_mid(click, pm: PubMaster):
-  setup_onroad_alert(click, pm, 'Medium Alert', 'This is a medium alert message', log.SelfdriveState.AlertSize.mid)
-
-def setup_onroad_alert_full(click, pm: PubMaster):
-  setup_onroad_alert(click, pm, 'Full Alert', 'This is a full alert message', log.SelfdriveState.AlertSize.full)
-
-def setup_offroad_alert(click, pm: PubMaster):
-  for alert in OFFROAD_ALERTS:
-    set_offroad_alert(alert, True)
-
-  # Toggle between settings and home to refresh the offroad alert widget
-  setup_settings_device(click, pm)
-  click(240, 216)
-
-def setup_update_available(click, pm: PubMaster):
-  Params().put_bool("UpdateAvailable", True)
-  release_notes_path = os.path.join(BASEDIR, "RELEASES.md")
-  with open(release_notes_path) as file:
-    release_notes = file.read().split('\n\n', 1)[0]
-  Params().put("UpdaterNewReleaseNotes", release_notes + "\n")
-
-  setup_settings_device(click, pm)
-  click(240, 216)
-
-def setup_pair_device(click, pm: PubMaster):
-  click(1950, 435)
-  click(1800, 900)
-
-CASES = {
-  "homescreen": setup_homescreen,
-  "prime": setup_homescreen,
-  "pair_device": setup_pair_device,
-  "settings_device": setup_settings_device,
-  "settings_toggles": setup_settings_toggles,
-  "settings_software": setup_settings_software,
-  "settings_firehose": setup_settings_firehose,
-  "settings_developer": setup_settings_developer,
-  "onroad": setup_onroad,
-  "onroad_disengaged": setup_onroad_disengaged,
-  "onroad_override": setup_onroad_override,
-  "onroad_sidebar": setup_onroad_sidebar,
-  "onroad_alert_small": setup_onroad_alert_small,
-  "onroad_alert_mid": setup_onroad_alert_mid,
-  "onroad_alert_full": setup_onroad_alert_full,
-  "onroad_wide": setup_onroad_wide,
-  "onroad_wide_sidebar": setup_onroad_wide_sidebar,
-  "driver_camera": setup_driver_camera,
-  "body": setup_body,
-  "offroad_alert": setup_offroad_alert,
-  "update_available": setup_update_available,
-  "keyboard": setup_keyboard,
-  "keyboard_uppercase": setup_keyboard_uppercase
-}
-
-TEST_DIR = pathlib.Path(__file__).parent
-
-TEST_OUTPUT_DIR = TEST_DIR / "report_1"
-SCREENSHOTS_DIR = TEST_OUTPUT_DIR / "screenshots"
-
-
-class TestUI:
-  def __init__(self):
-    os.environ["SCALE"] = "1"
-    sys.modules["mouseinfo"] = False
-
-  def setup(self):
-    self.pm = PubMaster(list(DATA.keys()))
-    DATA['deviceState'].deviceState.networkType = log.DeviceState.NetworkType.wifi
-    DATA['deviceState'].deviceState.lastAthenaPingTime = 0
-    for _ in range(10):
-      self.pm.send('deviceState', DATA['deviceState'])
-      DATA['deviceState'].clear_write_flag()
-      time.sleep(0.05)
-    try:
-      self.ui = pywinctl.getWindowsWithTitle("ui")[0]
-    except Exception as e:
-      print(f"failed to find ui window, assuming that it's in the top left (for Xvfb) {e}")
-      self.ui = namedtuple("bb", ["left", "top", "width", "height"])(0,0,2160,1080)
-
-  def screenshot(self, name):
-    im = pyautogui.screenshot(SCREENSHOTS_DIR / f"{name}.png", region=(self.ui.left, self.ui.top, self.ui.width, self.ui.height))
-    assert im.width == 2160
-    assert im.height == 1080
-
-  def click(self, x, y, *args, **kwargs):
-    pyautogui.click(self.ui.left + x, self.ui.top + y, *args, **kwargs)
-    time.sleep(UI_DELAY) # give enough time for the UI to react
-
-  @with_processes(["ui"])
-  def test_ui(self, name, setup_case):
-    self.setup()
-    setup_case(self.click, self.pm)
-    self.screenshot(name)
-
-def create_screenshots():
-  if TEST_OUTPUT_DIR.exists():
-    shutil.rmtree(TEST_OUTPUT_DIR)
-
-  SCREENSHOTS_DIR.mkdir(parents=True)
-
-  route = Route(TEST_ROUTE)
-
-  segnum = 2
-  lr = LogReader(route.qlog_paths()[segnum])
-  DATA['carParams'] = next((event.as_builder() for event in lr if event.which() == 'carParams'), None)
-  for event in migrate(lr, [migrate_controlsState, migrate_carState]):
-    if event.which() in DATA:
-      DATA[event.which()] = event.as_builder()
-
-    if all(DATA.values()):
-      break
-
-  cam = DEVICE_CAMERAS[("tici", "ar0231")]
-
-  frames_cache = f'{DEFAULT_CACHE_DIR}/ui_frames'
-  if os.path.isfile(frames_cache):
-    with open(frames_cache, 'rb') as f:
-      frames = pickle.load(f)
-      road_img = frames[0]
-      wide_road_img = frames[1]
-      driver_img = frames[2]
-  else:
-    with open(frames_cache, 'wb') as f:
-      road_img = FrameReader(route.camera_paths()[segnum], pix_fmt="nv12").get(0)
-      wide_road_img = FrameReader(route.ecamera_paths()[segnum], pix_fmt="nv12").get(0)
-      driver_img = FrameReader(route.dcamera_paths()[segnum], pix_fmt="nv12").get(0)
-      pickle.dump([road_img, wide_road_img, driver_img], f)
-
-  STREAMS.append((VisionStreamType.VISION_STREAM_ROAD, cam.fcam, road_img.flatten().tobytes()))
-  STREAMS.append((VisionStreamType.VISION_STREAM_WIDE_ROAD, cam.ecam, wide_road_img.flatten().tobytes()))
-  STREAMS.append((VisionStreamType.VISION_STREAM_DRIVER, cam.dcam, driver_img.flatten().tobytes()))
-
-  t = TestUI()
-
-  for name, setup in CASES.items():
-    with OpenpilotPrefix():
-      params = Params()
-      params.put("DongleId", "123456789012345")
-      if name == 'prime':
-        params.put('PrimeType', 1)
-      elif name == 'pair_device':
-        params.put('ApiCache_Device', {"is_paired":0, "prime_type":-1})
-
-      t.test_ui(name, setup)
-
-if __name__ == "__main__":
-  print("creating test screenshots")
-  create_screenshots()
--- a/selfdrive/ui/ui_state.py
+++ b/selfdrive/ui/ui_state.py
@@ -12,7 +12,7 @@ from openpilot.selfdrive.ui.lib.prime_state import PrimeState
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.hardware import HARDWARE, PC

-from openpilot.selfdrive.ui.sunnypilot.ui_state import UIStateSP
+from openpilot.selfdrive.ui.sunnypilot.ui_state import UIStateSP, DeviceSP

 BACKLIGHT_OFFROAD = 65 if HARDWARE.get_device_type() == "mici" else 50

@@ -21,6 +21,8 @@ class UIStatus(Enum):
  DISENGAGED = "disengaged"
  ENGAGED = "engaged"
  OVERRIDE = "override"
+  LAT_ONLY = "lat_only"
+  LONG_ONLY = "long_only"


 class UIState(UIStateSP):
@@ -98,7 +100,7 @@ class UIState(UIStateSP):

  @property
  def engaged(self) -> bool:
-    return self.started and self.sm["selfdriveState"].enabled
+    return self.started and (self.sm["selfdriveState"].enabled or self.sm["selfdriveStateSP"].mads.enabled)

  def is_onroad(self) -> bool:
    return self.started
@@ -133,10 +135,7 @@ class UIState(UIStateSP):
    # Handle wide road camera state updates
    if self.sm.updated["wideRoadCameraState"]:
      cam_state = self.sm["wideRoadCameraState"]
-
-      # Scale factor based on sensor type
-      scale = 6.0 if cam_state.sensor == 'ar0231' else 1.0
-      self.light_sensor = max(100.0 - scale * cam_state.exposureValPercent, 0.0)
+      self.light_sensor = max(100.0 - cam_state.exposureValPercent, 0.0)
    elif not self.sm.alive["wideRoadCameraState"] or not self.sm.valid["wideRoadCameraState"]:
      self.light_sensor = -1

@@ -159,6 +158,8 @@ class UIState(UIStateSP):
      else:
        self.status = UIStatus.ENGAGED if ss.enabled else UIStatus.DISENGAGED

+      self.status = UIStatus(UIStateSP.update_status(ss, self.sm["selfdriveStateSP"], self.sm["onroadEvents"]))
+
    # Check for engagement state changes
    if self.engaged != self._engaged_prev:
      for callback in self._engaged_transition_callbacks:
@@ -191,8 +192,9 @@ class UIState(UIStateSP):
    self._param_update_time = time.monotonic()


-class Device:
+class Device(DeviceSP):
  def __init__(self):
+    DeviceSP.__init__(self)
    self._ignition = False
    self._interaction_time: float = -1
    self._override_interactive_timeout: int | None = None
@@ -219,6 +221,9 @@ class Device:
    if self._override_interactive_timeout is not None:
      return self._override_interactive_timeout

+    if gui_app.sunnypilot_ui() and ui_state.custom_interactive_timeout != 0:
+      return ui_state.custom_interactive_timeout
+
    ignition_timeout = 10 if gui_app.big_ui() else 5
    return ignition_timeout if ui_state.ignition else 30

@@ -283,6 +288,7 @@ class Device:

  def _set_awake(self, on: bool):
    if on != self._awake:
+      DeviceSP._set_awake(self, on)
      self._awake = on
      cloudlog.debug(f"setting display power {int(on)}")
      HARDWARE.set_display_power(on)
--- a/sunnypilot/mapd/init.py
+++ b/sunnypilot/mapd/init.py
@@ -1,5 +0,0 @@
-import os
-from openpilot.common.basedir import BASEDIR
-
-MAPD_BIN_DIR = os.path.join(BASEDIR, 'third_party/mapd_pfeiferj')
-MAPD_PATH = os.path.join(MAPD_BIN_DIR, 'mapd')
--- a/sunnypilot/mapd/live_map_data/init.py
+++ b/sunnypilot/mapd/live_map_data/init.py
@@ -1,22 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.common.swaglog import cloudlog
-
-LOOK_AHEAD_HORIZON_TIME = 15.  # s. Time horizon for look ahead of turn speed sections to provide on liveMapDataSP msg.
-_DEBUG = False
-_CLOUDLOG_DEBUG = False
-ROAD_NAME_TIMEOUT = 30  # secs
-R = 6373000.0  # approximate radius of earth in mts
-QUERY_RADIUS = 3000  # mts. Radius to use on OSM data queries.
-QUERY_RADIUS_OFFLINE = 2250  # mts. Radius to use on offline OSM data queries.
-
-
-def get_debug(msg, log_to_cloud=True):
-  if _CLOUDLOG_DEBUG and log_to_cloud:
-    cloudlog.debug(msg)
-  if _DEBUG:
-    print(msg)
--- a/sunnypilot/mapd/live_map_data/base_map_data.py
+++ b/sunnypilot/mapd/live_map_data/base_map_data.py
@@ -1,65 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from abc import abstractmethod, ABC
-
-import cereal.messaging as messaging
-from openpilot.common.params import Params
-from openpilot.common.constants import CV
-from openpilot.selfdrive.car.cruise import V_CRUISE_UNSET
-from openpilot.sunnypilot.navd.helpers import coordinate_from_param
-
-MAX_SPEED_LIMIT = V_CRUISE_UNSET * CV.KPH_TO_MS
-
-
-class BaseMapData(ABC):
-  def __init__(self):
-    self.params = Params()
-
-    self.sm = messaging.SubMaster(['liveLocationKalman'])
-    self.pm = messaging.PubMaster(['liveMapDataSP'])
-
-    self.localizer_valid = False
-    self.last_bearing = None
-    self.last_position = coordinate_from_param("LastGPSPositionLLK", self.params)
-
-  @abstractmethod
-  def update_location(self) -> None:
-    pass
-
-  @abstractmethod
-  def get_current_speed_limit(self) -> float:
-    pass
-
-  @abstractmethod
-  def get_next_speed_limit_and_distance(self) -> tuple[float, float]:
-    pass
-
-  @abstractmethod
-  def get_current_road_name(self) -> str:
-    pass
-
-  def publish(self) -> None:
-    speed_limit = self.get_current_speed_limit()
-    next_speed_limit, next_speed_limit_distance = self.get_next_speed_limit_and_distance()
-
-    mapd_sp_send = messaging.new_message('liveMapDataSP')
-    mapd_sp_send.valid = self.sm['liveLocationKalman'].gpsOK
-    live_map_data = mapd_sp_send.liveMapDataSP
-
-    live_map_data.speedLimitValid = bool(MAX_SPEED_LIMIT > speed_limit > 0)
-    live_map_data.speedLimit = speed_limit
-    live_map_data.speedLimitAheadValid = bool(MAX_SPEED_LIMIT > next_speed_limit > 0)
-    live_map_data.speedLimitAhead = next_speed_limit
-    live_map_data.speedLimitAheadDistance = next_speed_limit_distance
-    live_map_data.roadName = self.get_current_road_name()
-
-    self.pm.send('liveMapDataSP', mapd_sp_send)
-
-  def tick(self) -> None:
-    self.sm.update(0)
-    self.update_location()
-    self.publish()
--- a/sunnypilot/mapd/live_map_data/debug.py
+++ b/sunnypilot/mapd/live_map_data/debug.py
@@ -1,56 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-# DISCLAIMER: This code is intended principally for development and debugging purposes.
-# Although it provides a standalone entry point to the program, users should refer
-# to the actual implementations for consumption. Usage outside of development scenarios
-# is not advised and could lead to unpredictable results.
-
-import threading
-import traceback
-
-from cereal import messaging
-from openpilot.common.gps import get_gps_location_service
-from openpilot.common.params import Params
-from openpilot.common.realtime import config_realtime_process
-from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit_controller.common import Policy
-from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit_controller.speed_limit_resolver import SpeedLimitResolver
-from openpilot.sunnypilot.mapd.live_map_data import get_debug
-
-
-def excepthook(args):
-  get_debug(f'MapD: Threading exception:\n{args}')
-  traceback.print_exception(args.exc_type, args.exc_value, args.exc_traceback)
-
-
-def live_map_data_sp_thread():
-  config_realtime_process([0, 1, 2, 3], 5)
-
-  params = Params()
-  gps_location_service = get_gps_location_service(params)
-
-  while True:
-    live_map_data_sp_thread_debug(gps_location_service)
-
-
-def live_map_data_sp_thread_debug(gps_location_service):
-  _sub_master = messaging.SubMaster(['carState', 'livePose', 'liveMapDataSP', 'longitudinalPlanSP', 'carStateSP', gps_location_service])
-  _sub_master.update()
-
-  v_ego = _sub_master['carState'].vEgo
-  _resolver = SpeedLimitResolver()
-  _resolver.policy = Policy.car_state_priority
-  _resolver.update(v_ego, _sub_master)
-  print(_resolver.speed_limit, _resolver.distance, _resolver.source)
-
-
-def main():
-  threading.excepthook = excepthook
-  live_map_data_sp_thread()
-
-
-if __name__ == "__main__":
-  main()
--- a/sunnypilot/mapd/live_map_data/osm_map_data.py
+++ b/sunnypilot/mapd/live_map_data/osm_map_data.py
@@ -1,61 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import json
-import math
-import platform
-
-from cereal import log
-from openpilot.common.params import Params
-from openpilot.sunnypilot.mapd.live_map_data.base_map_data import BaseMapData
-from openpilot.sunnypilot.navd.helpers import Coordinate
-
-
-class OsmMapData(BaseMapData):
-  def __init__(self):
-    super().__init__()
-    self.mem_params = Params("/dev/shm/params") if platform.system() != "Darwin" else self.params
-
-  def update_location(self) -> None:
-    location = self.sm['liveLocationKalman']
-    self.localizer_valid = (location.status == log.LiveLocationKalman.Status.valid) and location.positionGeodetic.valid
-
-    if self.localizer_valid:
-      self.last_bearing = math.degrees(location.calibratedOrientationNED.value[2])
-      self.last_position = Coordinate(location.positionGeodetic.value[0], location.positionGeodetic.value[1])
-
-    if self.last_position is None:
-      return
-
-    params = {
-      "latitude": self.last_position.latitude,
-      "longitude": self.last_position.longitude,
-    }
-
-    if self.last_bearing is not None:
-      params['bearing'] = self.last_bearing
-
-    self.mem_params.put("LastGPSPosition", json.dumps(params))
-
-  def get_current_speed_limit(self) -> float:
-    return float(self.mem_params.get("MapSpeedLimit") or 0.0)
-
-  def get_current_road_name(self) -> str:
-    return str(self.mem_params.get("RoadName") or "")
-
-  def get_next_speed_limit_and_distance(self) -> tuple[float, float]:
-    next_speed_limit_section_str = self.mem_params.get("NextMapSpeedLimit")
-    next_speed_limit_section = next_speed_limit_section_str if next_speed_limit_section_str else {}
-    next_speed_limit = next_speed_limit_section.get('speedlimit', 0.0)
-    next_speed_limit_latitude = next_speed_limit_section.get('latitude')
-    next_speed_limit_longitude = next_speed_limit_section.get('longitude')
-    next_speed_limit_distance = 0.0
-
-    if next_speed_limit_latitude and next_speed_limit_longitude:
-      next_speed_limit_coordinates = Coordinate(next_speed_limit_latitude, next_speed_limit_longitude)
-      next_speed_limit_distance = (self.last_position or Coordinate(0, 0)).distance_to(next_speed_limit_coordinates)
-
-    return next_speed_limit, next_speed_limit_distance
--- a/sunnypilot/mapd/live_map_data/standalone.py
+++ b/sunnypilot/mapd/live_map_data/standalone.py
@@ -1,42 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-# DISCLAIMER: This code is intended principally for development and debugging purposes.
-# Although it provides a standalone entry point to the program, users should refer
-# to the actual implementations for consumption. Usage outside of development scenarios
-# is not advised and could lead to unpredictable results.
-
-import threading
-import traceback
-
-from openpilot.common.realtime import Ratekeeper, config_realtime_process
-from openpilot.sunnypilot.mapd.live_map_data import get_debug
-from openpilot.sunnypilot.mapd.live_map_data.osm_map_data import OsmMapData
-
-
-def excepthook(args):
-  get_debug(f'MapD: Threading exception:\n{args}')
-  traceback.print_exception(args.exc_type, args.exc_value, args.exc_traceback)
-
-
-def live_map_data_sp_thread():
-  config_realtime_process([0, 1, 2, 3], 5)
-
-  live_map_sp = OsmMapData()
-  rk = Ratekeeper(1, print_delay_threshold=None)
-
-  while True:
-    live_map_sp.tick()
-    rk.keep_time()
-
-
-def main():
-  threading.excepthook = excepthook
-  live_map_data_sp_thread()
-
-
-if __name__ == "__main__":
-  main()
--- a/sunnypilot/mapd/mapd_installer.py
+++ b/sunnypilot/mapd/mapd_installer.py
@@ -1,154 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import logging
-import os
-import stat
-import time
-import traceback
-import requests
-from pathlib import Path
-from urllib.request import urlopen
-
-from cereal import messaging
-from openpilot.common.params import Params
-from openpilot.system.hardware.hw import Paths
-from openpilot.common.spinner import Spinner
-from openpilot.system.version import is_prebuilt
-from openpilot.sunnypilot.mapd import MAPD_PATH, MAPD_BIN_DIR
-import openpilot.system.sentry as sentry
-
-VERSION = "v1.12.0"
-URL = f"https://github.com/pfeiferj/openpilot-mapd/releases/download/{VERSION}/mapd"
-
-
-def update_installed_version(version: str, params: Params = None) -> None:
-  if params is None:
-    params = Params()
-
-  params.put("MapdVersion", version)
-
-
-class MapdInstallManager:
-  def __init__(self, spinner_ref: Spinner):
-    self._spinner = spinner_ref
-    self._params = Params()
-
-  def download(self) -> None:
-    self.ensure_directories_exist()
-    self._download_file()
-    update_installed_version(VERSION, self._params)
-
-  def check_and_download(self) -> None:
-    if self.download_needed():
-      self.download()
-
-  def download_needed(self) -> bool:
-    return not os.path.exists(MAPD_PATH) or self.get_installed_version() != VERSION
-
-  @staticmethod
-  def ensure_directories_exist() -> None:
-    if not os.path.exists(Paths.mapd_root()):
-      os.makedirs(Paths.mapd_root())
-    if not os.path.exists(MAPD_BIN_DIR):
-      os.makedirs(MAPD_BIN_DIR)
-
-  @staticmethod
-  def _safe_write_and_set_executable(file_path: Path, content: bytes) -> None:
-    with open(file_path, 'wb') as output:
-      output.write(content)
-      output.flush()
-      os.fsync(output.fileno())
-    current_permissions = stat.S_IMODE(os.lstat(file_path).st_mode)
-    os.chmod(file_path, current_permissions | stat.S_IEXEC)
-
-  def _download_file(self, num_retries=5) -> None:
-    temp_file = Path(MAPD_PATH + ".tmp")
-    download_timeout = 60
-    for cnt in range(num_retries):
-      try:
-        response = requests.get(URL, stream=True, timeout=download_timeout)
-        response.raise_for_status()
-        self._safe_write_and_set_executable(temp_file, response.content)
-        # No exceptions encountered. Safe to replace original file.
-        temp_file.replace(MAPD_PATH)
-        return
-      except requests.exceptions.ReadTimeout:
-        self._spinner.update(f"ReadTimeout caught. Timeout is [{download_timeout}]. Retrying download... [{cnt}]")
-        time.sleep(0.5)
-      except requests.exceptions.RequestException as e:
-        self._spinner.update(f"RequestException caught: {e}. Retrying download... [{cnt}]")
-        time.sleep(0.5)
-
-    # Delete temp file if the process was not successful.
-    if temp_file.exists():
-      temp_file.unlink()
-    logging.error("Failed to download file after all retries")
-
-  def get_installed_version(self) -> str:
-    return str(self._params.get("MapdVersion") or "")
-
-  def wait_for_internet_connection(self, return_on_failure: bool = False) -> bool:
-    max_retries = 10
-    for retries in range(max_retries + 1):
-      self._spinner.update(f"Waiting for internet connection... [{retries}/{max_retries}]")
-      time.sleep(2)
-      try:
-        _ = urlopen('https://sentry.io', timeout=10)
-        return True
-      except Exception as e:
-        print(f'Wait for internet failed: {e}')
-        if return_on_failure and retries == max_retries:
-          return False
-
-    return False
-
-  def non_prebuilt_install(self) -> None:
-    sm = messaging.SubMaster(['deviceState'])
-    metered = sm['deviceState'].networkMetered
-
-    if metered:
-      self._spinner.update("Can't proceed with mapd install since network is metered!")
-      time.sleep(5)
-      return
-
-    try:
-      self.ensure_directories_exist()
-      if not self.download_needed():
-        self._spinner.update("Mapd is good!")
-        time.sleep(0.1)
-        return
-
-      if self.wait_for_internet_connection(return_on_failure=True):
-        self._spinner.update(f"Downloading pfeiferj's mapd [{self.get_installed_version()}] => [{VERSION}].")
-        time.sleep(0.1)
-        self.check_and_download()
-      self._spinner.close()
-
-    except Exception:
-      for i in range(6):
-        self._spinner.update("Failed to download OSM maps won't work until properly downloaded!" +
-                             "Try again manually rebooting. " +
-                             f"Boot will continue in {5 - i}s...")
-        time.sleep(1)
-
-      sentry.init(sentry.SentryProject.SELFDRIVE)
-      traceback.print_exc()
-      sentry.capture_exception()
-
-
-if __name__ == "__main__":
-  spinner = Spinner()
-  install_manager = MapdInstallManager(spinner)
-  install_manager.ensure_directories_exist()
-  if is_prebuilt():
-    debug_msg = f"[DEBUG] This is prebuilt, no mapd install required. VERSION: [{VERSION}], Param [{install_manager.get_installed_version()}]"
-    spinner.update(debug_msg)
-    update_installed_version(VERSION)
-  else:
-    spinner.update(f"Checking if mapd is installed and valid. Prebuilt [{is_prebuilt()}]")
-    install_manager.non_prebuilt_install()
--- a/sunnypilot/mapd/mapd_manager.py
+++ b/sunnypilot/mapd/mapd_manager.py
@@ -1,144 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import json
-import platform
-import os
-import glob
-import shutil
-from datetime import datetime
-
-from openpilot.common.params import Params
-from openpilot.common.realtime import Ratekeeper, config_realtime_process
-from openpilot.common.swaglog import cloudlog
-from openpilot.selfdrive.selfdrived.alertmanager import set_offroad_alert
-from openpilot.sunnypilot.mapd.live_map_data.osm_map_data import OsmMapData
-from openpilot.system.hardware.hw import Paths
-from openpilot.sunnypilot.mapd import MAPD_PATH
-from openpilot.sunnypilot.mapd.mapd_installer import VERSION, update_installed_version
-
-# PFEIFER - MAPD {{
-params = Params()
-mem_params = Params("/dev/shm/params") if platform.system() != "Darwin" else params
-# }} PFEIFER - MAPD
-
-
-def get_files_for_cleanup() -> list[str]:
-  paths = [
-    f"{Paths.mapd_root()}/db",
-    f"{Paths.mapd_root()}/v*"
-  ]
-  files_to_remove = []
-  for path in paths:
-    if os.path.exists(path):
-      files = glob.glob(path + '/**', recursive=True)
-      files_to_remove.extend(files)
-  # check for version and mapd files
-  if not os.path.isfile(MAPD_PATH):
-    files_to_remove.append(MAPD_PATH)
-  return files_to_remove
-
-
-def cleanup_old_osm_data(files_to_remove: list[str]) -> None:
-  for file in files_to_remove:
-    # Remove trailing slash if path is file
-    if file.endswith('/') and os.path.isfile(file[:-1]):
-      file = file[:-1]
-    # Try to remove as file or symbolic link first
-    if os.path.islink(file) or os.path.isfile(file):
-      os.remove(file)
-    elif os.path.isdir(file):  # If it's a directory
-      shutil.rmtree(file, ignore_errors=False)
-
-
-def request_refresh_osm_location_data(nations: list[str], states: list[str] = None) -> None:
-  params.put("OsmDownloadedDate", str(datetime.now().timestamp()))
-  params.put_bool("OsmDbUpdatesCheck", False)
-
-  osm_download_locations = {
-    "nations": nations,
-    "states": states or []
-  }
-
-  print(f"Downloading maps for {json.dumps(osm_download_locations)}")
-  mem_params.put("OSMDownloadLocations", osm_download_locations)
-
-
-def filter_nations_and_states(nations: list[str], states: list[str] = None) -> tuple[list[str], list[str]]:
-  """Filters and prepares nation and state data for OSM map download.
-
-  If the nation is 'US' and a specific state is provided, the nation 'US' is removed from the list.
-  If the nation is 'US' and the state is 'All', the 'All' is removed from the list.
-  The idea behind these filters is that if a specific state in the US is provided,
-  there's no need to download map data for the entire US. Conversely,
-  if the state is unspecified (i.e., 'All'), we intend to download map data for the whole US,
-  and 'All' isn't a valid state name, so it's removed.
-
-  Parameters:
-  nations (list): A list of nations for which the map data is to be downloaded.
-  states (list, optional): A list of states for which the map data is to be downloaded. Defaults to None.
-
-  Returns:
-  tuple: Two lists. The first list is filtered nations and the second list is filtered states.
-  """
-
-  if "US" in nations and states and not any(x.lower() == "all" for x in states):
-    # If a specific state in the US is provided, remove 'US' from nations
-    nations.remove("US")
-  elif "US" in nations and states and any(x.lower() == "all" for x in states):
-    # If 'All' is provided as a state (case invariant), remove those instances from states
-    states = [x for x in states if x.lower() != "all"]
-  elif "US" not in nations and states and any(x.lower() == "all" for x in states):
-    states.remove("All")
-  return nations, states or []
-
-
-def update_osm_db() -> None:
-  if params.get_bool("OsmDbUpdatesCheck"):
-    cleanup_old_osm_data(get_files_for_cleanup())
-    country = params.get("OsmLocationName", return_default=True)
-    state = params.get("OsmStateName", return_default=True)
-    filtered_nations, filtered_states = filter_nations_and_states([country], [state])
-    request_refresh_osm_location_data(filtered_nations, filtered_states)
-
-  if not mem_params.get("OSMDownloadBounds"):
-    mem_params.put("OSMDownloadBounds", "")
-
-  if not mem_params.get("LastGPSPosition"):
-    mem_params.put("LastGPSPosition", "{}")
-
-
-def main_thread():
-  update_installed_version(VERSION, params)
-  config_realtime_process([0, 1, 2, 3], 5)
-
-  rk = Ratekeeper(1, print_delay_threshold=None)
-  live_map_sp = OsmMapData()
-
-  # Create folder needed for OSM
-  try:
-    os.mkdir(Paths.mapd_root())
-  except FileExistsError:
-    pass
-  except PermissionError:
-    cloudlog.exception(f"mapd: failed to make {Paths.mapd_root()}")
-
-  while True:
-    show_alert = get_files_for_cleanup() and params.get_bool("OsmLocal")
-    set_offroad_alert("Offroad_OSMUpdateRequired", show_alert, "This alert will be cleared when new maps are downloaded.")
-
-    update_osm_db()
-    live_map_sp.tick()
-    rk.keep_time()
-
-
-def main():
-  main_thread()
-
-
-if __name__ == "__main__":
-  main()
--- a/sunnypilot/mapd/tests/mapd_hash
+++ b/sunnypilot/mapd/tests/mapd_hash
@@ -1 +0,0 @@
-fdb3b49ee19956e6ce09fdc3373cbba557f1263b2180e9f344c1d4053852284b
--- a/sunnypilot/mapd/tests/test_mapd_version.py
+++ b/sunnypilot/mapd/tests/test_mapd_version.py
@@ -1,19 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.sunnypilot import get_file_hash
-from openpilot.sunnypilot.mapd import MAPD_PATH
-from openpilot.sunnypilot.mapd.update_version import MAPD_HASH_PATH
-
-
-class TestMapdVersion:
-  def test_compare_versions(self):
-    mapd_hash = get_file_hash(MAPD_PATH)
-
-    with open(MAPD_HASH_PATH) as f:
-      current_hash = f.read().strip()
-
-    assert current_hash == mapd_hash, "Run sunnypilot/mapd/update_version.py to update the current mapd version and hash"
--- a/sunnypilot/mapd/update_version.py
+++ b/sunnypilot/mapd/update_version.py
@@ -1,97 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import argparse
-import os
-import re
-
-from openpilot.sunnypilot import get_file_hash
-from openpilot.common.basedir import BASEDIR
-from openpilot.sunnypilot.mapd import MAPD_PATH
-
-MAPD_HASH_PATH = os.path.join(BASEDIR, "sunnypilot", "mapd", "tests", "mapd_hash")
-MAPD_VERSION_PATH = os.path.join(BASEDIR, "sunnypilot", "mapd", "mapd_installer.py")
-
-
-def update_mapd_hash():
-  mapd_hash = get_file_hash(MAPD_PATH)
-
-  with open(MAPD_HASH_PATH, "w") as f:
-    f.write(mapd_hash)
-
-  print(f"Generated and updated new mapd hash to {MAPD_HASH_PATH}")
-
-
-def get_current_mapd_version(path: str) -> str:
-  print("[GET CURRENT MAPD VERSION]")
-  with open(path) as f:
-    for line in f:
-      if line.strip().startswith("VERSION"):
-        # Match VERSION = 'v1.11.0' or VERSION="v1.11.0" (with optional spaces)
-        match = re.search(r'VERSION\s*=\s*[\'"]([^\'"]+)[\'"]', line)
-        if match:
-          ver = match.group(1)
-          print(f'Current mapd version: "{ver}"')
-          return ver
-        else:
-          print("[ERROR] VERSION line found but no quoted value detected.")
-          return ""
-  print("[ERROR] VERSION not found in file!")
-  return ""
-
-
-def update_mapd_version(ver: str, path: str):
-  print("[CHANGE CURRENT MAPD VERSION]")
-
-  with open(path) as f:
-    lines = f.readlines()
-
-  found = False
-  new_lines = []
-  for line in lines:
-    if not found and line.startswith("VERSION ="):
-      new_lines.append(f'VERSION = "{ver}"\n')
-      found = True
-      new_lines.extend(lines[lines.index(line) + 1:])
-      break
-    else:
-      new_lines.append(line)
-
-  if not found:
-    print("[ERROR] VERSION line not found! Aborting without writing.")
-    return
-
-  with open(path, "w") as f:
-    f.writelines(new_lines)
-
-  print(f'New mapd version: "{ver}"')
-  print("[DONE]")
-
-
-if __name__ == "__main__":
-  parser = argparse.ArgumentParser(description="Update mapd version and hash")
-  parser.add_argument("--new_ver", type=str, help="New mapd version")
-  args = parser.parse_args()
-
-  if not args.new_ver:
-    print("Warning: No new mapd version provided. Use --new_ver to specify")
-    print("Example:")
-    print("  python sunnypilot/mapd/update_version.py --new_ver \"v1.12.0\"")
-    print("Current mapd version and hash will not be updated! (aborted)")
-    exit(0)
-
-  current_ver = get_current_mapd_version(MAPD_VERSION_PATH)
-  new_ver = f"{args.new_ver}"
-  if current_ver == new_ver:
-    print(f'Proposed mapd version: "{new_ver}"')
-    confirm = input("Proposed mapd version is the same as the current mapd version. Confirm? (y/n): ").upper().strip()
-    if confirm != "Y":
-      print("Current mapd version and hash will not be updated! (aborted)")
-      exit(0)
-
-  update_mapd_version(new_ver, MAPD_VERSION_PATH)
-  update_mapd_hash()
--- a/sunnypilot/modeld/modeld.py
+++ b/sunnypilot/modeld/modeld.py
@@ -24,6 +24,7 @@ from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld.runners import ModelRunner, Runtime
 from openpilot.sunnypilot.modeld.parse_model_outputs import Parser
 from openpilot.sunnypilot.modeld.fill_model_msg import fill_model_msg, fill_pose_msg, PublishState
+from openpilot.sunnypilot.modeld_v2.camera_offset_helper import CameraOffsetHelper
 from openpilot.sunnypilot.modeld.constants import ModelConstants, Plan
 from openpilot.sunnypilot.models.helpers import get_active_bundle, get_model_path, load_metadata, prepare_inputs, load_meta_constants
 from openpilot.sunnypilot.modeld.models.commonmodel_pyx import ModelFrame, CLContext
@@ -195,6 +196,7 @@ def main(demo=False):
  buf_main, buf_extra = None, None
  meta_main = FrameMeta()
  meta_extra = FrameMeta()
+  camera_offset_helper = CameraOffsetHelper()


  if demo:
@@ -250,12 +252,14 @@ def main(demo=False):
    frame_id = sm["roadCameraState"].frameId
    if sm.frame % 60 == 0:
      model.lat_delay = get_lat_delay(params, sm["liveDelay"].lateralDelay)
+      camera_offset_helper.set_offset(params.get("CameraOffset", return_default=True))
    lat_delay = model.lat_delay + model.LAT_SMOOTH_SECONDS
    if sm.updated["liveCalibration"] and sm.seen['roadCameraState'] and sm.seen['deviceState']:
      device_from_calib_euler = np.array(sm["liveCalibration"].rpyCalib, dtype=np.float32)
      dc = DEVICE_CAMERAS[(str(sm['deviceState'].deviceType), str(sm['roadCameraState'].sensor))]
      model_transform_main = get_warp_matrix(device_from_calib_euler, dc.ecam.intrinsics if main_wide_camera else dc.fcam.intrinsics, False).astype(np.float32)
      model_transform_extra = get_warp_matrix(device_from_calib_euler, dc.ecam.intrinsics, True).astype(np.float32)
+      model_transform_main, model_transform_extra = camera_offset_helper.update(model_transform_main, model_transform_extra, sm, main_wide_camera)
      live_calib_seen = True

    traffic_convention = np.zeros(2)
--- a/sunnypilot/modeld_v2/SConscript
+++ b/sunnypilot/modeld_v2/SConscript
@@ -1,3 +1,4 @@
+import os
 import glob

 Import('env', 'envCython', 'arch', 'cereal', 'messaging', 'common', 'visionipc', 'transformations')
@@ -28,3 +29,38 @@ for pathdef, fn in {'TRANSFORM': 'transforms/transform.cl', 'LOADYUV': 'transfor
 cython_libs = envCython["LIBS"] + libs
 commonmodel_lib = lenv.Library('commonmodel', common_src)
 lenvCython.Program('models/commonmodel_pyx.so', 'models/commonmodel_pyx.pyx', LIBS=[commonmodel_lib, *cython_libs], FRAMEWORKS=frameworks)
+tinygrad_files = ["#"+x for x in glob.glob(env.Dir("#tinygrad_repo").relpath + "/**", recursive=True, root_dir=env.Dir("#").abspath) if 'pycache' not in x]
+
+# Get model metadata
+PC = not os.path.isfile('/TICI')
+if PC:
+  inputs = tinygrad_files + [File(Dir("#sunnypilot/modeld_v2").File("install_models_pc.py").abspath)]
+  outputs = []
+  model_dir = Dir("models").abspath
+  cmd = f'python3 {Dir("#sunnypilot/modeld_v2").abspath}/install_models_pc.py {model_dir}'
+
+  for model_name in ['supercombo', 'driving_vision', 'driving_policy']:
+    if File(f"models/{model_name}.onnx").exists():
+        inputs.append(File(f"models/{model_name}.onnx"))
+        inputs.append(File(f"models/{model_name}_tinygrad.pkl"))
+        outputs.append(File(f"models/{model_name}_metadata.pkl"))
+  if outputs:
+    lenv.Command(outputs, inputs, cmd)
+
+def tg_compile(flags, model_name):
+  pythonpath_string = 'PYTHONPATH="${PYTHONPATH}:' + env.Dir("#tinygrad_repo").abspath + '"'
+  fn = File(f"models/{model_name}").abspath
+  return lenv.Command(
+    fn + "_tinygrad.pkl",
+    [fn + ".onnx"] + tinygrad_files,
+    f'{pythonpath_string} {flags} python3 {Dir("#tinygrad_repo").abspath}/examples/openpilot/compile3.py {fn}.onnx {fn}_tinygrad.pkl'
+  )
+
+# Compile small models
+for model_name in ['supercombo', 'driving_vision', 'driving_policy']:
+  if File(f"models/{model_name}.onnx").exists():
+    flags = {
+      'larch64': 'DEV=QCOM',
+      'Darwin': f'DEV=CPU HOME={os.path.expanduser("~")} IMAGE=0', # tinygrad calls brew which needs a $HOME in the env
+    }.get(arch, 'DEV=CPU CPU_LLVM=1 IMAGE=0')
+    tg_compile(flags, model_name)
--- a/sunnypilot/modeld_v2/camera_offset_helper.py
+++ b/sunnypilot/modeld_v2/camera_offset_helper.py
@@ -0,0 +1,39 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import numpy as np
+
+from openpilot.common.transformations.camera import DEVICE_CAMERAS
+
+
+class CameraOffsetHelper:
+  def __init__(self):
+    self.camera_offset = 0.0
+    self.actual_camera_offset = 0.0
+
+  @staticmethod
+  def apply_camera_offset(model_transform, intrinsics, height, offset_param):
+    cy = intrinsics[1, 2]
+    shear = np.eye(3, dtype=np.float32)
+    shear[0, 1] = offset_param / height
+    shear[0, 2] = -offset_param / height * cy
+    model_transform = (shear @ model_transform).astype(np.float32)
+    return model_transform
+
+  def set_offset(self, offset):
+    self.camera_offset = offset
+
+  def update(self, model_transform_main, model_transform_extra, sm, main_wide_camera):
+    self.actual_camera_offset = (0.9 * self.actual_camera_offset) + (0.1 * self.camera_offset)
+    dc = DEVICE_CAMERAS[(str(sm['deviceState'].deviceType), str(sm['roadCameraState'].sensor))]
+    height = sm["liveCalibration"].height[0] if sm['liveCalibration'].height else 1.22
+
+    intrinsics_main = dc.ecam.intrinsics if main_wide_camera else dc.fcam.intrinsics
+    model_transform_main = self.apply_camera_offset(model_transform_main, intrinsics_main, height, self.actual_camera_offset)
+
+    intrinsics_extra = dc.ecam.intrinsics
+    model_transform_extra = self.apply_camera_offset(model_transform_extra, intrinsics_extra, height, self.actual_camera_offset)
+    return model_transform_main, model_transform_extra
--- a/sunnypilot/modeld_v2/install_models_pc.py
+++ b/sunnypilot/modeld_v2/install_models_pc.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+import sys
+import shutil
+import pickle
+import codecs
+import onnx
+from pathlib import Path
+
+from openpilot.system.hardware.hw import Paths
+
+
+def get_name_and_shape(value_info):
+  shape = tuple([int(dim.dim_value) for dim in value_info.type.tensor_type.shape.dim])
+  return value_info.name, shape
+
+
+def get_metadata_value_by_name(model, name):
+  for prop in model.metadata_props:
+    if prop.key == name:
+      return prop.value
+  return None
+
+
+def generate_metadata_pkl(model_path, output_path):
+  try:
+    model = onnx.load(str(model_path))
+    output_slices = get_metadata_value_by_name(model, 'output_slices')
+
+    if output_slices:
+      metadata = {
+        'model_checkpoint': get_metadata_value_by_name(model, 'model_checkpoint'),
+        'output_slices': pickle.loads(codecs.decode(output_slices.encode(), "base64")),
+        'input_shapes': dict([get_name_and_shape(x) for x in model.graph.input]),
+        'output_shapes': dict([get_name_and_shape(x) for x in model.graph.output])
+      }
+      with open(output_path, 'wb') as f:
+        pickle.dump(metadata, f)
+      return True
+    else:
+      return False
+  except Exception:
+    return False
+
+
+def install_models(model_dir):
+  model_dir = Path(model_dir)
+  models = ["driving_policy", "driving_vision"]
+  found_models = []
+
+  for model in models:
+    if (model_dir / f"{model}.onnx").exists():
+      found_models.append(model)
+
+  if not found_models:
+    return
+
+  try:
+    custom_name = input(f"Found models ({', '.join(found_models)}). Enter model short name (e.g. wmiv4): ").strip()
+  except EOFError:
+    return
+
+  if not custom_name:
+    print("No name provided, skipping installation.")
+    return
+
+  dest_dir = Path(Paths.model_root())
+  dest_dir.mkdir(parents=True, exist_ok=True)
+
+  for model in found_models:
+    onnx_path = model_dir / f"{model}.onnx"
+    tinygrad_pkl = model_dir / f"{model}_tinygrad.pkl"
+    metadata_pkl = model_dir / f"{model}_metadata.pkl"
+
+    if not metadata_pkl.exists():
+      generate_metadata_pkl(onnx_path, metadata_pkl)
+
+    dest_tinygrad = dest_dir / f"{model}_{custom_name}_tinygrad.pkl"
+    dest_metadata = dest_dir / f"{model}_{custom_name}_metadata.pkl"
+
+    if tinygrad_pkl.exists():
+      shutil.move(str(tinygrad_pkl), str(dest_tinygrad))
+    if metadata_pkl.exists():
+      shutil.move(str(metadata_pkl), str(dest_metadata))
+
+if __name__ == "__main__":
+  if len(sys.argv) < 2:
+    print("Usage: install_models_pc.py <model_dir>")
+    sys.exit(1)
+  install_models(sys.argv[1])
--- a/sunnypilot/modeld_v2/modeld.py
+++ b/sunnypilot/modeld_v2/modeld.py
@@ -21,6 +21,7 @@ from openpilot.sunnypilot.modeld_v2.fill_model_msg import fill_model_msg, fill_p
 from openpilot.sunnypilot.modeld_v2.constants import Plan
 from openpilot.sunnypilot.modeld_v2.models.commonmodel_pyx import DrivingModelFrame, CLContext
 from openpilot.sunnypilot.modeld_v2.meta_helper import load_meta_constants
+from openpilot.sunnypilot.modeld_v2.camera_offset_helper import CameraOffsetHelper

 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld.modeld_base import ModelStateBase
@@ -28,7 +29,6 @@ from openpilot.sunnypilot.models.helpers import get_active_bundle
 from openpilot.sunnypilot.models.runners.helpers import get_model_runner

 PROCESS_NAME = "selfdrive.modeld.modeld_tinygrad"
-RECOVERY_POWER = 1.0 # The higher this number the more aggressively the model will recover to lanecenter, too high and it will ping-pong


 class FrameMeta:
@@ -63,6 +63,7 @@ class ModelState(ModelStateBase):
    self.LAT_SMOOTH_SECONDS = float(overrides.get('lat', ".0"))
    self.LONG_SMOOTH_SECONDS = float(overrides.get('long', ".0"))
    self.MIN_LAT_CONTROL_SPEED = 0.3
+    self.PLANPLUS_CONTROL: float = 1.0

    buffer_length = 5 if self.model_runner.is_20hz else 2
    self.frames = {name: DrivingModelFrame(context, buffer_length) for name in self.model_runner.vision_input_names}
@@ -158,7 +159,8 @@ class ModelState(ModelStateBase):
                            lat_action_t: float, long_action_t: float, v_ego: float) -> log.ModelDataV2.Action:
    plan = model_output['plan'][0]
    if 'planplus' in model_output:
-      plan = plan + RECOVERY_POWER*model_output['planplus'][0]
+      recovery_power = self.PLANPLUS_CONTROL * (0.75 if v_ego > 20.0 else 1.0)
+      plan = plan + recovery_power * model_output['planplus'][0]
    desired_accel, should_stop = get_accel_from_plan(plan[:, Plan.VELOCITY][:, 0], plan[:, Plan.ACCELERATION][:, 0], self.constants.T_IDXS,
                                                     action_t=long_action_t)
    desired_accel = smooth_value(desired_accel, prev_action.desiredAcceleration, self.LONG_SMOOTH_SECONDS)
@@ -229,6 +231,7 @@ def main(demo=False):
  buf_main, buf_extra = None, None
  meta_main = FrameMeta()
  meta_extra = FrameMeta()
+  camera_offset_helper = CameraOffsetHelper()


  if demo:
@@ -283,13 +286,15 @@ def main(demo=False):
    v_ego = max(sm["carState"].vEgo, 0.)
    if sm.frame % 60 == 0:
      model.lat_delay = get_lat_delay(params, sm["liveDelay"].lateralDelay)
+      model.PLANPLUS_CONTROL = params.get("PlanplusControl", return_default=True)
+      camera_offset_helper.set_offset(params.get("CameraOffset", return_default=True))
    lat_delay = model.lat_delay + model.LAT_SMOOTH_SECONDS
    if sm.updated["liveCalibration"] and sm.seen['roadCameraState'] and sm.seen['deviceState']:
      device_from_calib_euler = np.array(sm["liveCalibration"].rpyCalib, dtype=np.float32)
      dc = DEVICE_CAMERAS[(str(sm['deviceState'].deviceType), str(sm['roadCameraState'].sensor))]
-      model_transform_main = get_warp_matrix(device_from_calib_euler, dc.ecam.intrinsics if main_wide_camera else dc.fcam.intrinsics,
-                                             False).astype(np.float32)
+      model_transform_main = get_warp_matrix(device_from_calib_euler, dc.ecam.intrinsics if main_wide_camera else dc.fcam.intrinsics, False).astype(np.float32)
      model_transform_extra = get_warp_matrix(device_from_calib_euler, dc.ecam.intrinsics, True).astype(np.float32)
+      model_transform_main, model_transform_extra = camera_offset_helper.update(model_transform_main, model_transform_extra, sm, main_wide_camera)
      live_calib_seen = True

    traffic_convention = np.zeros(2)
--- a/sunnypilot/modeld_v2/tests/test_camera_offset_helper.py
+++ b/sunnypilot/modeld_v2/tests/test_camera_offset_helper.py
@@ -0,0 +1,84 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import numpy as np
+
+from openpilot.common.transformations.camera import DEVICE_CAMERAS
+from openpilot.common.transformations.model import get_warp_matrix
+from openpilot.sunnypilot.modeld_v2.camera_offset_helper import CameraOffsetHelper
+
+
+class MockStruct:
+  def __init__(self, **kwargs):
+    for k, v in kwargs.items():
+      setattr(self, k, v)
+
+  def __getitem__(self, item):
+    return getattr(self, item)
+
+
+class TestCameraOffset:
+  def setup_method(self):
+    self.camera_offset = CameraOffsetHelper()
+    self.dc = DEVICE_CAMERAS[('mici', 'os04c10')]
+
+  def test_smoothing(self):
+    self.camera_offset.set_offset(0.2)
+
+    sm = MockStruct(
+      deviceState=MockStruct(deviceType='mici'),
+      roadCameraState=MockStruct(sensor='os04c10'),
+      liveCalibration=MockStruct(rpyCalib=[0.0, 0.0, 0.0], height=[1.22])
+    )
+
+    intrinsics_main = self.dc.fcam.intrinsics
+    intrinsics_extra = self.dc.ecam.intrinsics
+    device_from_calib_euler = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+    main_transform = get_warp_matrix(device_from_calib_euler, intrinsics_main, False).astype(np.float32)
+    extra_transform = get_warp_matrix(device_from_calib_euler, intrinsics_extra, True).astype(np.float32)
+
+    self.camera_offset.update(main_transform, extra_transform, sm, False)
+    np.testing.assert_almost_equal(self.camera_offset.actual_camera_offset, 0.02)
+    self.camera_offset.update(main_transform, extra_transform, sm, False)
+    np.testing.assert_almost_equal(self.camera_offset.actual_camera_offset, 0.038)
+
+  def test_camera_offset_(self):
+    intrinsics = self.dc.fcam.intrinsics
+    transform = np.eye(3, dtype=np.float32)
+    height = 1.22
+    offset = 0.1
+
+    cy = intrinsics[1, 2]
+    expected_shear = np.eye(3, dtype=np.float32)
+    expected_shear[0, 1] = offset / height
+    expected_shear[0, 2] = -offset / height * cy
+
+    result = CameraOffsetHelper.apply_camera_offset(transform, intrinsics, height, offset)
+    np.testing.assert_array_almost_equal(result, expected_shear)
+
+  def test_update(self):
+    sm = MockStruct(
+      deviceState=MockStruct(deviceType='mici'),
+      roadCameraState=MockStruct(sensor='os04c10'),
+      liveCalibration=MockStruct(rpyCalib=[0.0, 0.0, 0.0], height=[1.22])
+    )
+    intrinsics_main = self.dc.fcam.intrinsics
+    intrinsics_extra = self.dc.ecam.intrinsics
+    device_from_calib_euler = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+    main_transform = get_warp_matrix(device_from_calib_euler, intrinsics_main, False).astype(np.float32)
+    extra_transform = get_warp_matrix(device_from_calib_euler, intrinsics_extra, True).astype(np.float32)
+
+    self.camera_offset.set_offset(0.0)  # test default offset doesn't change transformation
+    main_out, extra_out = self.camera_offset.update(main_transform, extra_transform, sm, False)
+    np.testing.assert_array_equal(main_out, main_transform)
+    np.testing.assert_array_equal(extra_out, extra_transform)
+
+    self.camera_offset.set_offset(0.2)  # test valid offset changes transformation
+    main_out, extra_out = self.camera_offset.update(main_transform, extra_transform, sm, False)
+    assert not np.array_equal(main_out, main_transform)
+    assert not np.array_equal(extra_out, extra_transform)
+    assert main_out[0, 1] != 0.0
+    assert main_out[0, 2] != 0.0
--- a/sunnypilot/modeld_v2/tests/test_modeld.py
+++ b/sunnypilot/modeld_v2/tests/test_modeld.py
@@ -1,102 +0,0 @@
-import numpy as np
-import random
-
-import cereal.messaging as messaging
-from msgq.visionipc import VisionIpcServer, VisionStreamType
-from opendbc.car.car_helpers import get_demo_car_params
-from openpilot.common.params import Params
-from openpilot.common.transformations.camera import DEVICE_CAMERAS
-from openpilot.common.realtime import DT_MDL
-from openpilot.system.manager.process_config import managed_processes
-from openpilot.selfdrive.test.process_replay.vision_meta import meta_from_camera_state
-
-CAM = DEVICE_CAMERAS[("tici", "ar0231")].fcam
-IMG = np.zeros(int(CAM.width*CAM.height*(3/2)), dtype=np.uint8)
-IMG_BYTES = IMG.flatten().tobytes()
-
-
-class TestModeld:
-
-  def setup_method(self):
-    self.vipc_server = VisionIpcServer("camerad")
-    self.vipc_server.create_buffers(VisionStreamType.VISION_STREAM_ROAD, 40, CAM.width, CAM.height)
-    self.vipc_server.create_buffers(VisionStreamType.VISION_STREAM_DRIVER, 40, CAM.width, CAM.height)
-    self.vipc_server.create_buffers(VisionStreamType.VISION_STREAM_WIDE_ROAD, 40, CAM.width, CAM.height)
-    self.vipc_server.start_listener()
-    Params().put("CarParams", get_demo_car_params().to_bytes())
-
-    self.sm = messaging.SubMaster(['modelV2', 'cameraOdometry'])
-    self.pm = messaging.PubMaster(['roadCameraState', 'wideRoadCameraState', 'liveCalibration'])
-
-    managed_processes['modeld'].start()
-    self.pm.wait_for_readers_to_update("roadCameraState", 10)
-
-  def teardown_method(self):
-    managed_processes['modeld'].stop()
-    del self.vipc_server
-
-  def _send_frames(self, frame_id, cams=None):
-    if cams is None:
-      cams = ('roadCameraState', 'wideRoadCameraState')
-
-    cs = None
-    for cam in cams:
-      msg = messaging.new_message(cam)
-      cs = getattr(msg, cam)
-      cs.frameId = frame_id
-      cs.timestampSof = int((frame_id * DT_MDL) * 1e9)
-      cs.timestampEof = int(cs.timestampSof + (DT_MDL * 1e9))
-      cam_meta = meta_from_camera_state(cam)
-
-      self.pm.send(msg.which(), msg)
-      self.vipc_server.send(cam_meta.stream, IMG_BYTES, cs.frameId,
-                            cs.timestampSof, cs.timestampEof)
-    return cs
-
-  def _wait(self):
-    self.sm.update(5000)
-    if self.sm['modelV2'].frameId != self.sm['cameraOdometry'].frameId:
-      self.sm.update(1000)
-
-  def test_modeld(self):
-    for n in range(1, 500):
-      cs = self._send_frames(n)
-      self._wait()
-
-      mdl = self.sm['modelV2']
-      assert mdl.frameId == n
-      assert mdl.frameIdExtra == n
-      assert mdl.timestampEof == cs.timestampEof
-      assert mdl.frameAge == 0
-      assert mdl.frameDropPerc == 0
-
-      odo = self.sm['cameraOdometry']
-      assert odo.frameId == n
-      assert odo.timestampEof == cs.timestampEof
-
-  def test_dropped_frames(self):
-    """
-      modeld should only run on consecutive road frames
-    """
-    frame_id = -1
-    road_frames = list()
-    for n in range(1, 50):
-      if (random.random() < 0.1) and n > 3:
-        cams = random.choice([(), ('wideRoadCameraState', )])
-        self._send_frames(n, cams)
-      else:
-        self._send_frames(n)
-        road_frames.append(n)
-      self._wait()
-
-      if len(road_frames) < 3 or road_frames[-1] - road_frames[-2] == 1:
-        frame_id = road_frames[-1]
-
-      mdl = self.sm['modelV2']
-      odo = self.sm['cameraOdometry']
-      assert mdl.frameId == frame_id
-      assert mdl.frameIdExtra == frame_id
-      assert odo.frameId == frame_id
-      if n != frame_id:
-        assert not self.sm.updated['modelV2']
-        assert not self.sm.updated['cameraOdometry']
--- a/sunnypilot/modeld_v2/tests/test_recovery_power.py
+++ b/sunnypilot/modeld_v2/tests/test_recovery_power.py
@@ -0,0 +1,61 @@
+import numpy as np
+
+from cereal import log
+
+from openpilot.sunnypilot.modeld_v2.constants import Plan
+from openpilot.sunnypilot.modeld_v2.modeld import ModelState
+import openpilot.sunnypilot.modeld_v2.modeld as modeld
+
+
+class MockStruct:
+  def __init__(self, **kwargs):
+    for k, v in kwargs.items():
+      setattr(self, k, v)
+
+
+def test_recovery_power_scaling():
+  state = MockStruct(
+    PLANPLUS_CONTROL=1.0,
+    LONG_SMOOTH_SECONDS=0.3,
+    LAT_SMOOTH_SECONDS=0.1,
+    MIN_LAT_CONTROL_SPEED=0.3,
+    mlsim=True,
+    generation=12,
+    constants=MockStruct(T_IDXS=np.arange(100), DESIRE_LEN=8)
+  )
+  prev_action = log.ModelDataV2.Action()
+  recorded_vel: list = []
+
+  def mock_accel(plan_vel, plan_accel, t_idxs, action_t=0.0):
+    recorded_vel.append(plan_vel.copy())
+    return 0.0, False
+
+  modeld.get_accel_from_plan = mock_accel
+  modeld.get_curvature_from_output = lambda *args: 0.0
+  plan = np.random.rand(1, 100, 15).astype(np.float32)
+  planplus = np.random.rand(1, 100, 15).astype(np.float32)
+
+  model_output: dict = {
+    'plan': plan.copy(),
+    'planplus': planplus.copy()
+  }
+
+  test_cases: list = [
+    # (control, v_ego, expected_factor)
+    (0.55, 20.0, 1.0),
+    (1.0, 25.0, .75),
+    (1.5, 25.1, 0.75),
+    (2.0, 20.0, 1.0),
+    (0.75, 19.0, 1.0),
+    (0.8, 25.1, 0.75),
+  ]
+
+  for control, v_ego, factor in test_cases:
+    state.PLANPLUS_CONTROL = control
+    recorded_vel.clear()
+    ModelState.get_action_from_model(state, model_output, prev_action, 0.0, 0.0, v_ego)
+
+    expected_recovery_power = control * factor
+    expected_plan_vel = plan[0, :, Plan.VELOCITY][:, 0] + expected_recovery_power * planplus[0, :, Plan.VELOCITY][:, 0]
+
+    np.testing.assert_allclose(recorded_vel[0], expected_plan_vel, rtol=1e-5, atol=1e-6)
--- a/sunnypilot/models/runners/helpers.py
+++ b/sunnypilot/models/runners/helpers.py
@@ -2,25 +2,17 @@ from openpilot.sunnypilot.models.helpers import get_active_bundle
 from openpilot.sunnypilot.models.runners.model_runner import ModelRunner
 from openpilot.sunnypilot.models.runners.tinygrad.tinygrad_runner import TinygradRunner, TinygradSplitRunner
 from openpilot.sunnypilot.models.runners.constants import ModelType
-from openpilot.system.hardware import TICI

-if not TICI:
-  from openpilot.sunnypilot.models.runners.onnx.onnx_runner import ONNXRunner

 def get_model_runner() -> ModelRunner:
  """
  Factory function to create and return the appropriate ModelRunner instance.

-  Selects between ONNXRunner (for non-TICI platforms) and TinygradRunner
-  (for TICI platforms), choosing TinygradSplitRunner if separate vision/policy
+  Selects TinygradRunner, choosing TinygradSplitRunner if separate vision/policy
  models are detected in the active bundle.

  :return: An instance of a ModelRunner subclass (ONNXRunner, TinygradRunner, or TinygradSplitRunner).
  """
-  if not TICI:
-    return ONNXRunner()
-
-  # On TICI platforms, use Tinygrad runners
  bundle = get_active_bundle()
  if bundle and bundle.models:
    model_types = {m.type.raw for m in bundle.models}
--- a/sunnypilot/selfdrive/assets/logo.png
+++ b/sunnypilot/selfdrive/assets/logo.png
--- a/sunnypilot/selfdrive/car/cruise_ext.py
+++ b/sunnypilot/selfdrive/car/cruise_ext.py
@@ -6,16 +6,12 @@ See the LICENSE.md file in the root directory for more details.
 """
 import numpy as np

-from cereal import car, custom
+from cereal import car
 from opendbc.car import structs
-from openpilot.common.constants import CV
 from openpilot.common.params import Params
 from openpilot.sunnypilot.selfdrive.car.intelligent_cruise_button_management.helpers import get_minimum_set_speed
-from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.speed_limit_assist import ACTIVE_STATES as SLA_ACTIVE_STATES
-from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.helpers import compare_cluster_target

 ButtonType = car.CarState.ButtonEvent.Type
-SpeedLimitAssistState = custom.LongitudinalPlanSP.SpeedLimit.AssistState

 CRUISE_BUTTON_TIMER = {ButtonType.decelCruise: 0, ButtonType.accelCruise: 0,
                       ButtonType.setCruise: 0, ButtonType.resumeCruise: 0,
@@ -54,16 +50,6 @@ class VCruiseHelperSP:

    self.enable_button_timers = CRUISE_BUTTON_TIMER

-    # Speed Limit Assist
-    self.sla_state = SpeedLimitAssistState.disabled
-    self.prev_sla_state = SpeedLimitAssistState.disabled
-    self.has_speed_limit = False
-    self.speed_limit_final_last = 0.
-    self.speed_limit_final_last_kph = 0.
-    self.prev_speed_limit_final_last_kph = 0.
-    self.req_plus = False
-    self.req_minus = False
-
  def read_custom_set_speed_params(self) -> None:
    self.custom_acc_enabled = self.params.get_bool("CustomAccIncrementsEnabled")
    self.short_increment = self.params.get("CustomAccShortPressIncrement", return_default=True)
@@ -106,33 +92,3 @@ class VCruiseHelperSP:
      return enabled and self.enabled_prev

    return enabled
-
-  def update_speed_limit_assist(self, is_metric, LP_SP: custom.LongitudinalPlanSP) -> None:
-    resolver = LP_SP.speedLimit.resolver
-    self.has_speed_limit = resolver.speedLimitValid or resolver.speedLimitLastValid
-    self.speed_limit_final_last = LP_SP.speedLimit.resolver.speedLimitFinalLast
-    self.speed_limit_final_last_kph = self.speed_limit_final_last * CV.MS_TO_KPH
-    self.sla_state = LP_SP.speedLimit.assist.state
-    self.req_plus, self.req_minus = compare_cluster_target(self.v_cruise_cluster_kph * CV.KPH_TO_MS,
-                                                           self.speed_limit_final_last, is_metric)
-
-  @property
-  def update_speed_limit_final_last_changed(self) -> bool:
-    return self.has_speed_limit and bool(self.speed_limit_final_last_kph != self.prev_speed_limit_final_last_kph)
-
-  def update_speed_limit_assist_pre_active_confirmed(self, button_type: car.CarState.ButtonEvent.Type) -> bool:
-    if self.sla_state == SpeedLimitAssistState.preActive or self.prev_sla_state == SpeedLimitAssistState.preActive:
-      if button_type == ButtonType.decelCruise and self.req_minus:
-        return True
-      if button_type == ButtonType.accelCruise and self.req_plus:
-        return True
-
-    return False
-
-  def update_speed_limit_assist_v_cruise_non_pcm(self) -> None:
-    if self.sla_state in SLA_ACTIVE_STATES and (self.prev_sla_state not in SLA_ACTIVE_STATES or
-                                                self.update_speed_limit_final_last_changed):
-      self.v_cruise_kph = np.clip(round(self.speed_limit_final_last_kph, 1), self.v_cruise_min, V_CRUISE_MAX)
-
-    self.prev_sla_state = self.sla_state
-    self.prev_speed_limit_final_last_kph = self.speed_limit_final_last_kph
--- a/sunnypilot/selfdrive/car/interfaces.py
+++ b/sunnypilot/selfdrive/car/interfaces.py
@@ -11,7 +11,6 @@ from opendbc.car.interfaces import CarInterfaceBase
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.sunnypilot.selfdrive.controls.lib.nnlc.helpers import get_nn_model_path
-from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.helpers import set_speed_limit_assist_availability

 import openpilot.system.sentry as sentry

@@ -86,10 +85,6 @@ def _cleanup_unsupported_params(CP: structs.CarParams, CP_SP: structs.CarParamsS
    cloudlog.warning("openpilot Longitudinal Control and ICBM not available, cleaning up params")
    params.remove("DynamicExperimentalControl")
    params.remove("CustomAccIncrementsEnabled")
-    params.remove("SmartCruiseControlVision")
-    params.remove("SmartCruiseControlMap")
-
-  set_speed_limit_assist_availability(CP, CP_SP, params)


 def setup_interfaces(CI: CarInterfaceBase, params: Params = None) -> None:
@@ -114,7 +109,7 @@ def initialize_params(params) -> list[dict[str, Any]]:

  # hyundai
  keys.extend([
-    "HyundaiLongitudinalTuning"
+    "HyundaiLongitudinalTuning",
  ])

  # subaru
@@ -128,4 +123,9 @@ def initialize_params(params) -> list[dict[str, Any]]:
    "TeslaCoopSteering",
  ])

+  # toyota
+  keys.extend([
+    "ToyotaEnforceStockLongitudinal",
+  ])
+
  return [{k: params.get(k, return_default=True)} for k in keys]
--- a/sunnypilot/selfdrive/controls/lib/longitudinal_planner.py
+++ b/sunnypilot/selfdrive/controls/lib/longitudinal_planner.py
@@ -7,13 +7,8 @@ See the LICENSE.md file in the root directory for more details.

 from cereal import messaging, custom
 from opendbc.car import structs
-from openpilot.common.constants import CV
-from openpilot.selfdrive.car.cruise import V_CRUISE_MAX
 from openpilot.sunnypilot.selfdrive.controls.lib.dec.dec import DynamicExperimentalController
 from openpilot.sunnypilot.selfdrive.controls.lib.e2e_alerts_helper import E2EAlertsHelper
-from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.smart_cruise_control import SmartCruiseControl
-from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.speed_limit_assist import SpeedLimitAssist
-from openpilot.sunnypilot.selfdrive.controls.lib.speed_limit.speed_limit_resolver import SpeedLimitResolver
 from openpilot.sunnypilot.selfdrive.selfdrived.events import EventsSP
 from openpilot.sunnypilot.models.helpers import get_active_bundle

@@ -24,11 +19,7 @@ LongitudinalPlanSource = custom.LongitudinalPlanSP.LongitudinalPlanSource
 class LongitudinalPlannerSP:
  def __init__(self, CP: structs.CarParams, CP_SP: structs.CarParamsSP, mpc):
    self.events_sp = EventsSP()
-    self.resolver = SpeedLimitResolver()
    self.dec = DynamicExperimentalController(CP, mpc)
-    self.scc = SmartCruiseControl()
-    self.resolver = SpeedLimitResolver()
-    self.sla = SpeedLimitAssist(CP, CP_SP)
    self.generation = int(model_bundle.generation) if (model_bundle := get_active_bundle()) else None
    self.source = LongitudinalPlanSource.cruise
    self.e2e_alerts_helper = E2EAlertsHelper()
@@ -48,33 +39,16 @@ class LongitudinalPlannerSP:
    return self.dec.mode()

  def update_targets(self, sm: messaging.SubMaster, v_ego: float, a_ego: float, v_cruise: float) -> tuple[float, float]:
-    CS = sm['carState']
-    v_cruise_cluster_kph = min(CS.vCruiseCluster, V_CRUISE_MAX)
-    v_cruise_cluster = v_cruise_cluster_kph * CV.KPH_TO_MS
+    self.source = LongitudinalPlanSource.cruise
+    self.output_v_target = v_cruise
+    self.output_a_target = a_ego

-    long_enabled = sm['carControl'].enabled
-    long_override = sm['carControl'].cruiseControl.override
+    if sm.valid['mapdOut']:
+      suggested_speed = sm['mapdOut'].suggestedSpeed
+      if suggested_speed > 0 and suggested_speed < self.output_v_target:
+        self.output_v_target = suggested_speed
+        self.source = LongitudinalPlanSource.mapd

-    # Smart Cruise Control
-    self.scc.update(sm, long_enabled, long_override, v_ego, a_ego, v_cruise)
-
-    # Speed Limit Resolver
-    self.resolver.update(v_ego, sm)
-
-    # Speed Limit Assist
-    has_speed_limit = self.resolver.speed_limit_valid or self.resolver.speed_limit_last_valid
-    self.sla.update(long_enabled, long_override, v_ego, a_ego, v_cruise_cluster, self.resolver.speed_limit,
-                    self.resolver.speed_limit_final_last, has_speed_limit, self.resolver.distance, self.events_sp)
-
-    targets = {
-      LongitudinalPlanSource.cruise: (v_cruise, a_ego),
-      LongitudinalPlanSource.sccVision: (self.scc.vision.output_v_target, self.scc.vision.output_a_target),
-      LongitudinalPlanSource.sccMap: (self.scc.map.output_v_target, self.scc.map.output_a_target),
-      LongitudinalPlanSource.speedLimitAssist: (self.sla.output_v_target, self.sla.output_a_target),
-    }
-
-    self.source = min(targets, key=lambda k: targets[k][0])
-    self.output_v_target, self.output_a_target = targets[self.source]
    return self.output_v_target, self.output_a_target

  def update(self, sm: messaging.SubMaster) -> None:
@@ -99,44 +73,6 @@ class LongitudinalPlannerSP:
    dec.enabled = self.dec.enabled()
    dec.active = self.dec.active()

-    # Smart Cruise Control
-    smartCruiseControl = longitudinalPlanSP.smartCruiseControl
-    # Vision Control
-    sccVision = smartCruiseControl.vision
-    sccVision.state = self.scc.vision.state
-    sccVision.vTarget = float(self.scc.vision.output_v_target)
-    sccVision.aTarget = float(self.scc.vision.output_a_target)
-    sccVision.currentLateralAccel = float(self.scc.vision.current_lat_acc)
-    sccVision.maxPredictedLateralAccel = float(self.scc.vision.max_pred_lat_acc)
-    sccVision.enabled = self.scc.vision.is_enabled
-    sccVision.active = self.scc.vision.is_active
-    # Map Control
-    sccMap = smartCruiseControl.map
-    sccMap.state = self.scc.map.state
-    sccMap.vTarget = float(self.scc.map.output_v_target)
-    sccMap.aTarget = float(self.scc.map.output_a_target)
-    sccMap.enabled = self.scc.map.is_enabled
-    sccMap.active = self.scc.map.is_active
-
-    # Speed Limit
-    speedLimit = longitudinalPlanSP.speedLimit
-    resolver = speedLimit.resolver
-    resolver.speedLimit = float(self.resolver.speed_limit)
-    resolver.speedLimitLast = float(self.resolver.speed_limit_last)
-    resolver.speedLimitFinal = float(self.resolver.speed_limit_final)
-    resolver.speedLimitFinalLast = float(self.resolver.speed_limit_final_last)
-    resolver.speedLimitValid = self.resolver.speed_limit_valid
-    resolver.speedLimitLastValid = self.resolver.speed_limit_last_valid
-    resolver.speedLimitOffset = float(self.resolver.speed_limit_offset)
-    resolver.distToSpeedLimit = float(self.resolver.distance)
-    resolver.source = self.resolver.source
-    assist = speedLimit.assist
-    assist.state = self.sla.state
-    assist.enabled = self.sla.is_enabled
-    assist.active = self.sla.is_active
-    assist.vTarget = float(self.sla.output_v_target)
-    assist.aTarget = float(self.sla.output_a_target)
-
    # E2E Alerts
    e2eAlerts = longitudinalPlanSP.e2eAlerts
    e2eAlerts.greenLightAlert = self.e2e_alerts_helper.green_light_alert
--- a/sunnypilot/selfdrive/controls/lib/smart_cruise_control/map_controller.py
+++ b/sunnypilot/selfdrive/controls/lib/smart_cruise_control/map_controller.py
@@ -1,261 +0,0 @@
-import json
-import math
-import platform
-
-from cereal import custom
-from openpilot.common.params import Params
-from openpilot.common.realtime import DT_MDL
-from openpilot.selfdrive.car.cruise import V_CRUISE_UNSET
-from openpilot.sunnypilot import PARAMS_UPDATE_PERIOD
-from openpilot.sunnypilot.navd.helpers import coordinate_from_param, Coordinate
-from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control import MIN_V
-
-MapState = VisionState = custom.LongitudinalPlanSP.SmartCruiseControl.MapState
-
-ACTIVE_STATES = (MapState.turning, )
-ENABLED_STATES = (MapState.enabled, MapState.overriding, *ACTIVE_STATES)
-
-R = 6373000.0  # approximate radius of earth in meters
-TO_RADIANS = math.pi / 180
-TO_DEGREES = 180 / math.pi
-TARGET_JERK = -0.6  # m/s^3 There's some jounce limits that are not consistent so we're fudging this some
-TARGET_ACCEL = -1.2  # m/s^2 should match up with the long planner limit
-TARGET_OFFSET = 1.0  # seconds - This controls how soon before the curve you reach the target velocity. It also helps
-                     # reach the target velocity when inaccuracies in the distance modeling logic would cause overshoot.
-                     # The value is multiplied against the target velocity to determine the additional distance. This is
-                     # done to keep the distance calculations consistent but results in the offset actually being less
-                     # time than specified depending on how much of a speed differential there is between v_ego and the
-                     # target velocity.
-
-
-def velocities_from_param(param: str, params: Params):
-  if params is None:
-    params = Params()
-
-  json_str = params.get(param)
-  if json_str is None:
-    return None
-
-  velocities = json.loads(json_str)
-
-  return velocities
-
-
-def calculate_accel(t, target_jerk, a_ego):
-  return a_ego + target_jerk * t
-
-
-def calculate_velocity(t, target_jerk, a_ego, v_ego):
-  return v_ego + a_ego * t + target_jerk/2 * (t ** 2)
-
-
-def calculate_distance(t, target_jerk, a_ego, v_ego):
-  return t * v_ego + a_ego/2 * (t ** 2) + target_jerk/6 * (t ** 3)
-
-
-# points should be in radians
-# output is meters
-def distance_to_point(ax, ay, bx, by):
-  a = math.sin((bx-ax)/2)*math.sin((bx-ax)/2) + math.cos(ax) * math.cos(bx)*math.sin((by-ay)/2)*math.sin((by-ay)/2)
-  c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
-
-  return R * c  # in meters
-
-
-class SmartCruiseControlMap:
-  v_target: float = 0
-  a_target: float = 0.
-  v_ego: float = 0.
-  a_ego: float = 0.
-  output_v_target: float = V_CRUISE_UNSET
-  output_a_target: float = 0.
-
-  def __init__(self):
-    self.params = Params()
-    self.mem_params = Params("/dev/shm/params") if platform.system() != "Darwin" else self.params
-    self.enabled = self.params.get_bool("SmartCruiseControlMap")
-    self.long_enabled = False
-    self.long_override = False
-    self.is_enabled = False
-    self.is_active = False
-    self.state = MapState.disabled
-    self.v_cruise = 0
-    self.target_lat = 0.0
-    self.target_lon = 0.0
-    self.frame = -1
-
-    self.last_position = coordinate_from_param("LastGPSPosition", self.mem_params) or Coordinate(0.0, 0.0)
-    self.target_velocities = velocities_from_param("MapTargetVelocities", self.mem_params) or []
-
-  def get_v_target_from_control(self) -> float:
-    if self.is_active:
-      return max(self.v_target, MIN_V)
-
-    return V_CRUISE_UNSET
-
-  def get_a_target_from_control(self) -> float:
-    return self.a_ego
-
-  def update_params(self):
-    if self.frame % int(PARAMS_UPDATE_PERIOD / DT_MDL) == 0:
-      self.enabled = self.params.get_bool("SmartCruiseControlMap")
-
-  def update_calculations(self) -> None:
-    self.last_position = coordinate_from_param("LastGPSPosition", self.mem_params) or Coordinate(0.0, 0.0)
-    lat = self.last_position.latitude
-    lon = self.last_position.longitude
-
-    self.target_velocities = velocities_from_param("MapTargetVelocities", self.mem_params) or []
-
-    if self.last_position is None or self.target_velocities is None:
-      return
-
-    min_dist = 1000
-    min_idx = 0
-    distances = []
-
-    # find our location in the path
-    for i in range(len(self.target_velocities)):
-      target_velocity = self.target_velocities[i]
-      tlat = target_velocity["latitude"]
-      tlon = target_velocity["longitude"]
-      d = distance_to_point(lat * TO_RADIANS, lon * TO_RADIANS, tlat * TO_RADIANS, tlon * TO_RADIANS)
-      distances.append(d)
-      if d < min_dist:
-        min_dist = d
-        min_idx = i
-
-    # only look at values from our current position forward
-    forward_points = self.target_velocities[min_idx:]
-    forward_distances = distances[min_idx:]
-
-    # find velocities that we are within the distance we need to adjust for
-    valid_velocities = []
-    for i in range(len(forward_points)):
-      target_velocity = forward_points[i]
-      tlat = target_velocity["latitude"]
-      tlon = target_velocity["longitude"]
-      tv = target_velocity["velocity"]
-      if tv > self.v_ego:
-        continue
-
-      d = forward_distances[i]
-
-      a_diff = (self.a_ego - TARGET_ACCEL)
-      accel_t = abs(a_diff / TARGET_JERK)
-      min_accel_v = calculate_velocity(accel_t, TARGET_JERK, self.a_ego, self.v_ego)
-
-      max_d = 0
-      if tv > min_accel_v:
-        # calculate time needed based on target jerk
-        a = 0.5 * TARGET_JERK
-        b = self.a_ego
-        c = self.v_ego - tv
-        t_a = -1 * ((b**2 - 4 * a * c) ** 0.5 + b) / 2 * a
-        t_b = ((b**2 - 4 * a * c) ** 0.5 - b) / 2 * a
-        if not isinstance(t_a, complex) and t_a > 0:
-          t = t_a
-        else:
-          t = t_b
-        if isinstance(t, complex):
-          continue
-
-        max_d = max_d + calculate_distance(t, TARGET_JERK, self.a_ego, self.v_ego)
-      else:
-        t = accel_t
-        max_d = calculate_distance(t, TARGET_JERK, self.a_ego, self.v_ego)
-
-        # calculate additional time needed based on target accel
-        t = abs((min_accel_v - tv) / TARGET_ACCEL)
-        max_d += calculate_distance(t, 0, TARGET_ACCEL, min_accel_v)
-
-      if d < max_d + tv * TARGET_OFFSET:
-        valid_velocities.append((float(tv), tlat, tlon))
-
-    # Find the smallest velocity we need to adjust for
-    min_v = 100.0
-    target_lat = 0.0
-    target_lon = 0.0
-    for tv, lat, lon in valid_velocities:
-      if tv < min_v:
-        min_v = tv
-        target_lat = lat
-        target_lon = lon
-
-    if self.v_target < min_v and not (self.target_lat == 0 and self.target_lon == 0):
-      for i in range(len(forward_points)):
-        target_velocity = forward_points[i]
-        tlat = target_velocity["latitude"]
-        tlon = target_velocity["longitude"]
-        tv = target_velocity["velocity"]
-        if tv > self.v_ego:
-          continue
-
-        if tlat == self.target_lat and tlon == self.target_lon and tv == self.v_target:
-          return
-
-      # not found so let's reset
-      self.v_target = 0.0
-      self.target_lat = 0.0
-      self.target_lon = 0.0
-
-    self.v_target = min_v
-    self.target_lat = target_lat
-    self.target_lon = target_lon
-
-  def _update_state_machine(self) -> tuple[bool, bool]:
-    # ENABLED, TURNING
-    if self.state != MapState.disabled:
-      if not self.long_enabled or not self.enabled:
-        self.state = MapState.disabled
-      elif self.long_override:
-        self.state = MapState.overriding
-
-      else:
-        # ENABLED
-        if self.state == MapState.enabled:
-          if self.v_cruise > self.v_target != 0:
-            self.state = MapState.turning
-
-        # TURNING
-        elif self.state == MapState.turning:
-          if self.v_cruise <= self.v_target or self.v_target == 0:
-            self.state = MapState.enabled
-
-        # OVERRIDING
-        elif self.state == MapState.overriding:
-          if not self.long_override:
-            if self.v_cruise > self.v_target != 0:
-              self.state = MapState.turning
-            else:
-              self.state = MapState.enabled
-
-    # DISABLED
-    elif self.state == MapState.disabled:
-      if self.long_enabled and self.enabled:
-        if self.long_override:
-          self.state = MapState.overriding
-        else:
-          self.state = MapState.enabled
-
-    enabled = self.state in ENABLED_STATES
-    active = self.state in ACTIVE_STATES
-
-    return enabled, active
-
-  def update(self, long_enabled: bool, long_override: bool, v_ego, a_ego, v_cruise) -> None:
-    self.long_enabled = long_enabled
-    self.long_override = long_override
-    self.v_ego = v_ego
-    self.a_ego = a_ego
-    self.v_cruise = v_cruise
-
-    self.update_params()
-    self.update_calculations()
-
-    self.is_enabled, self.is_active = self._update_state_machine()
-
-    self.output_v_target = self.get_v_target_from_control()
-    self.output_a_target = self.get_a_target_from_control()
-
-    self.frame += 1
--- a/sunnypilot/selfdrive/controls/lib/smart_cruise_control/smart_cruise_control.py
+++ b/sunnypilot/selfdrive/controls/lib/smart_cruise_control/smart_cruise_control.py
@@ -1,19 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import cereal.messaging as messaging
-from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.vision_controller import SmartCruiseControlVision
-from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.map_controller import SmartCruiseControlMap
-
-
-class SmartCruiseControl:
-  def __init__(self):
-    self.vision = SmartCruiseControlVision()
-    self.map = SmartCruiseControlMap()
-
-  def update(self, sm: messaging.SubMaster, long_enabled: bool, long_override: bool, v_ego: float, a_ego: float, v_cruise: float) -> None:
-    self.map.update(long_enabled, long_override, v_ego, a_ego, v_cruise)
-    self.vision.update(sm, long_enabled, long_override, v_ego, a_ego, v_cruise)
--- a/sunnypilot/selfdrive/controls/lib/smart_cruise_control/tests/test_map_controller.py
+++ b/sunnypilot/selfdrive/controls/lib/smart_cruise_control/tests/test_map_controller.py
@@ -1,58 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import platform
-
-from cereal import custom
-from openpilot.common.params import Params
-from openpilot.common.realtime import DT_MDL
-from openpilot.selfdrive.car.cruise import V_CRUISE_UNSET
-from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.map_controller import SmartCruiseControlMap
-
-MapState = VisionState = custom.LongitudinalPlanSP.SmartCruiseControl.MapState
-
-
-class TestSmartCruiseControlMap:
-
-  def setup_method(self):
-    self.params = Params()
-    self.mem_params = Params("/dev/shm/params") if platform.system() != "Darwin" else self.params
-    self.reset_params()
-    self.scc_m = SmartCruiseControlMap()
-
-  def reset_params(self):
-    self.params.put_bool("SmartCruiseControlMap", True)
-
-    # TODO-SP: mock data from gpsLocation
-    self.params.put("LastGPSPosition", "{}")
-    self.params.put("MapTargetVelocities", "{}")
-
-  def test_initial_state(self):
-    assert self.scc_m.state == VisionState.disabled
-    assert not self.scc_m.is_active
-    assert self.scc_m.output_v_target == V_CRUISE_UNSET
-    assert self.scc_m.output_a_target == 0.
-
-  def test_system_disabled(self):
-    self.params.put_bool("SmartCruiseControlMap", False)
-    self.scc_m.enabled = self.params.get_bool("SmartCruiseControlMap")
-
-    for _ in range(int(10. / DT_MDL)):
-      self.scc_m.update(True, False, 0., 0., 0.)
-    assert self.scc_m.state == VisionState.disabled
-    assert not self.scc_m.is_active
-
-  def test_disabled(self):
-    for _ in range(int(10. / DT_MDL)):
-      self.scc_m.update(False, False, 0., 0., 0.)
-    assert self.scc_m.state == VisionState.disabled
-
-  def test_transition_disabled_to_enabled(self):
-    for _ in range(int(10. / DT_MDL)):
-      self.scc_m.update(True, False, 0., 0., 0.)
-    assert self.scc_m.state == VisionState.enabled
-
-  # TODO-SP: mock data from modelV2 to test other states
--- a/sunnypilot/selfdrive/controls/lib/smart_cruise_control/tests/test_vision_controller.py
+++ b/sunnypilot/selfdrive/controls/lib/smart_cruise_control/tests/test_vision_controller.py
@@ -1,104 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-import numpy as np
-
-import cereal.messaging as messaging
-from cereal import custom, log
-from openpilot.common.params import Params
-from openpilot.common.realtime import DT_MDL
-from openpilot.selfdrive.car.cruise import V_CRUISE_UNSET
-from openpilot.selfdrive.modeld.constants import ModelConstants
-from openpilot.sunnypilot.selfdrive.controls.lib.smart_cruise_control.vision_controller import SmartCruiseControlVision
-
-VisionState = custom.LongitudinalPlanSP.SmartCruiseControl.VisionState
-
-
-def generate_modelV2():
-  model = messaging.new_message('modelV2')
-  position = log.XYZTData.new_message()
-  speed = 30
-  position.x = [float(x) for x in (speed + 0.5) * np.array(ModelConstants.T_IDXS)]
-  model.modelV2.position = position
-  orientation = log.XYZTData.new_message()
-  curvature = 0.05
-  orientation.x = [float(curvature) for _ in ModelConstants.T_IDXS]
-  orientation.y = [0.0 for _ in ModelConstants.T_IDXS]
-  model.modelV2.orientation = orientation
-  orientationRate = log.XYZTData.new_message()
-  orientationRate.z = [float(z) for z in ModelConstants.T_IDXS]
-  model.modelV2.orientationRate = orientationRate
-  velocity = log.XYZTData.new_message()
-  velocity.x = [float(x) for x in (speed + 0.5) * np.ones_like(ModelConstants.T_IDXS)]
-  velocity.x[0] = float(speed)  # always start at current speed
-  model.modelV2.velocity = velocity
-  acceleration = log.XYZTData.new_message()
-  acceleration.x = [float(x) for x in np.zeros_like(ModelConstants.T_IDXS)]
-  acceleration.y = [float(y) for y in np.zeros_like(ModelConstants.T_IDXS)]
-  model.modelV2.acceleration = acceleration
-
-  return model
-
-
-def generate_carState():
-  car_state = messaging.new_message('carState')
-  speed = 30
-  v_cruise = 50
-  car_state.carState.vEgo = float(speed)
-  car_state.carState.standstill = False
-  car_state.carState.vCruise = float(v_cruise * 3.6)
-
-  return car_state
-
-
-def generate_controlsState():
-  controls_state = messaging.new_message('controlsState')
-  controls_state.controlsState.curvature = 0.05
-
-  return controls_state
-
-
-class TestSmartCruiseControlVision:
-
-  def setup_method(self):
-    self.params = Params()
-    self.reset_params()
-    self.scc_v = SmartCruiseControlVision()
-
-    mdl = generate_modelV2()
-    cs = generate_carState()
-    controls_state = generate_controlsState()
-    self.sm = {'modelV2': mdl.modelV2, 'carState': cs.carState, 'controlsState': controls_state.controlsState}
-
-  def reset_params(self):
-    self.params.put_bool("SmartCruiseControlVision", True)
-
-  def test_initial_state(self):
-    assert self.scc_v.state == VisionState.disabled
-    assert not self.scc_v.is_active
-    assert self.scc_v.output_v_target == V_CRUISE_UNSET
-    assert self.scc_v.output_a_target == 0.
-
-  def test_system_disabled(self):
-    self.params.put_bool("SmartCruiseControlVision", False)
-    self.scc_v.enabled = self.params.get_bool("SmartCruiseControlVision")
-
-    for _ in range(int(10. / DT_MDL)):
-      self.scc_v.update(self.sm, True, False, 0., 0., 0.)
-    assert self.scc_v.state == VisionState.disabled
-    assert not self.scc_v.is_active
-
-  def test_disabled(self):
-    for _ in range(int(10. / DT_MDL)):
-      self.scc_v.update(self.sm, False, False, 0., 0., 0.)
-    assert self.scc_v.state == VisionState.disabled
-
-  def test_transition_disabled_to_enabled(self):
-    for _ in range(int(10. / DT_MDL)):
-      self.scc_v.update(self.sm, True, False, 0., 0., 0.)
-    assert self.scc_v.state == VisionState.enabled
-
-  # TODO-SP: mock modelV2 data to test other states
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
rav4kumar	89a3a953b2	mapd v2	2026-01-13 20:49:08 -07:00
rav4kumar	366eecc45b	remove old mapd, sla, ssc	2026-01-13 20:25:37 -07:00
DevTekVE	a0c10be1ff	Revert "ui: Global Brightness Override (#1579 )" This reverts commit `1eb82fcc`	2026-01-10 21:24:44 +01:00
Nayan	a58db66a98	sunnylink: add units to param metadata (#1643 ) add units	2026-01-09 18:40:09 -05:00
Jason Wen	e5e56614c9	ui: Customizable Interactive Timeout (#1640 ) * ui: Custom Interactive Timeout * rename * lint	2026-01-04 00:33:32 -05:00
Nayan	1eb82fcc85	ui: Global Brightness Override (#1579 ) * global brightness * initialize * keep stock * lint --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-01-04 00:27:22 -05:00
Copilot	987f53e69a	[TIZI/TICI] ui: sunnylink status on sidebar (#1638 ) * Initial plan * feat: add sunnylink status metric Co-authored-by: devtekve <7696966+devtekve@users.noreply.github.com> * chore: extract sidebar constants Co-authored-by: devtekve <7696966+devtekve@users.noreply.github.com> * refactor: guard metric spacing Co-authored-by: devtekve <7696966+devtekve@users.noreply.github.com> * chore: clarify sunnylink helpers Co-authored-by: devtekve <7696966+devtekve@users.noreply.github.com> * refactor: guard metric spacing edge cases Co-authored-by: devtekve <7696966+devtekve@users.noreply.github.com> * chore: simplify spacing guards Co-authored-by: devtekve <7696966+devtekve@users.noreply.github.com> * chore: normalize sunnylink params Co-authored-by: devtekve <7696966+devtekve@users.noreply.github.com> * chore: harden sunnylink param parsing Co-authored-by: devtekve <7696966+devtekve@users.noreply.github.com> * chore: add param decode helper Co-authored-by: devtekve <7696966+devtekve@users.noreply.github.com> * chore: simplify sidebar metric spacing Co-authored-by: devtekve <7696966+devtekve@users.noreply.github.com> * chore: update sunnylink status color logic for improved clarity * sunnylink: update status handling to reflect offline state and improve fault indication sunnylink: enhance status handling with temporary fault indication * sunnylink: enhance status update logic for improved accuracy and clarity * make it int * Ugly with zero value, but done. Now we only need to remember to check the new sidebar if the old sidebar ever changes * Revert "Ugly with zero value, but done. Now we only need to remember to check the new sidebar if the old sidebar ever changes" This reverts commit `2d3b740e38`. * decouple * no bad bot --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: devtekve <7696966+devtekve@users.noreply.github.com> Co-authored-by: DevTekVE <devtekve@gmail.com> Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-01-03 21:01:21 -05:00
github-actions[bot]	9a04a5eaae	[bot] Update Python packages (#1565 ) * Update Python packages * no --------- Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com> Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-01-03 15:54:55 -05:00
Nayan	50b8ae9e09	sunnylink: update params metadata (#1636 ) * sunnylink model controls * cleanup more controls * update verbiage Co-authored-by: DevTekVE <devtekve@gmail.com> --------- Co-authored-by: DevTekVE <devtekve@gmail.com>	2026-01-03 08:35:02 -05:00
James Vecellio-Grant	a30fc9bcd2	modeld: configurable camera offset (#1614 ) * modeld: configurable camera offset Negative Values: Shears the image to the left, moving the models center to the Right. Positive Value: Shears the image to the right, moving the models center to the Left. * modeld: camera offset class * verify zero offset I @ A = A * slithered and slunked * Update params_metadata.json * wait * Update model_renderer.py * Update model_renderer.py * requested changes * stricter * Update model_renderer.py * more * return default * Update params_metadata.json * final --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-01-01 14:23:01 -05:00
Kumar	19a7d1d5d7	[TIZI/TICI] ui: update dmoji position and Developer UI adjustments (#1601 ) * ui: improve layout and centering of bottom developer UI elements * int * less is more, y'all * always show actual lat for all cars * lint * perfect * cleanup * too long * inherit * remove unused * inir * need to fix * final --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-31 00:27:53 -05:00
Jason Wen	fb8f46cba9	Reimplement sunnypilot Terms of Service & sunnylink Consent Screens (#1633 ) * tos reimpl * nah * simpler * check consent on sunnylink panel - mici * slight cleanup * rename * keep it off * decouple * more rename * more decouple * a bit more * fix state * decouple more * a bit more * wrong type * rearrange * don't do that * final * lint * include * more --------- Co-authored-by: nayan <nayan8teen@gmail.com>	2025-12-31 00:08:36 -05:00
Nayan	70386c6b00	ui: fix Always Offroad button visibility (#1632 ) always offroad button fix	2025-12-30 23:20:20 -05:00
James Vecellio-Grant	edeede5e82	modeld_v2: conditional model compilation for metadrive testing (#1623 ) * modeld_v2: conditional model compilation for PC * full send * shebang --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-29 22:03:08 -05:00
James Vecellio-Grant	6df313b974	modeld_v2: remove dead test (#1621 ) Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-29 17:01:58 -05:00
James Vecellio-Grant	9442bc9aec	modeld_v2: planplus model tuning (#1620 ) * modeld: planplus model tuning * little more * final --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-29 16:55:39 -05:00
DevTekVE	763049f068	SL: Re enable and validate ingestion of swaglogs (#1580 ) * Re enable and validate ingestion	2025-12-27 11:49:26 -05:00
Nayan	c6c644a3a6	[mici] ui: sunnypilot font on home menu (#1561 ) use sp font on home Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-23 16:34:00 -05:00
dzid26	c876a83a31	ui: fix malformed dongle ID display on the PC if dongleID is not set (#1612 )	2025-12-23 09:34:56 -05:00
Nayan	a04a5b4284	ui: expand `DeviceLayoutSP` (#1560 ) * commaai/openpilot:d05cb31e2e916fba41ba8167030945f427fd811b * bump opendbc * bump opendbc * bump opendbc * bump opendbc * bump opendbc * sunnypilot: remove Qt * cabana: revert to stock Qt * commaai/openpilot:5198b1b079c37742c1050f02ce0aa6dd42b038b9 * commaai/openpilot:954b567b9ba0f3d1ae57d6aa7797fa86dd92ec6e * commaai/openpilot:7534b2a160faa683412c04c1254440e338931c5e * sum more * bump opendbc * not yet * should've been symlink'ed * raylib says wut * quiet mode back * more fixes * no more * too extra red diff on the side * need to bring this back * too extra * let's update docs here * Revert "let's update docs here" This reverts commit `51fe03cd51`. * param to control stock vs sp ui * init styles * SP Toggles * Lint * optimizations * multi-button * Lint * param to control stock vs sp ui * init styles * SP Toggles * Lint * optimizations * sp raylib preview * fix callback * fix ui preview * better padding * this * support for next line multi-button * uhh * disabled colors * listitem -> listitemsp * listitem -> listitemsp * add show_description method * remove padding from line separator. like, WHY? 😩😩 * ui: `GuiApplicationExt` * simple button * simple button * add to readme * use gui_app.sunnypilot_ui() * i've got something to confessa * init * more init * power buttons always visible * uh, nope * add reset to offroad only * support wake up offroad * flippity floppity * dual button item sp * use dual button item sp * lint * keep @devtekve from going blind * more round * some * revert * slight diff * should've been inline * cleanup power btns and offroad transitions * bruh * 1st row red diff * 2nd row red diff * 3rd row red diff * slight diff * move around * more diff * only when onroad we move to the top, not the toggle * nah * sort --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com> Co-authored-by: DevTekVE <devtekve@gmail.com> Co-authored-by: James Vecellio-Grant <159560811+Discountchubbs@users.noreply.github.com> Co-authored-by: discountchubbs <alexgrant990@gmail.com>	2025-12-23 00:51:35 -05:00
Matt Purnell	373894a81f	docs: Update branch installation instructions in README (#1610 ) * Update branch installation instructions * Add another link * Add limited support link * Incorporate suggested link * Tweak wording	2025-12-23 00:42:24 -05:00
Jason Wen	34ce746869	ui: `DualButtonActionSP` and `dual_button_item_sp` helpers (#1608 )	2025-12-22 09:29:01 -05:00
Matt Purnell	e96b0da9d7	ci: Add unit test to prevent MADS DM regressions (#1602 ) * monitoring/tests: Add unit test to prevent MADS regressions * dm: remove TODO --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-21 23:07:01 -05:00
Jason Wen	6d7910ed74	ui: add `inline` to `option_item_sp` (#1600 )	2025-12-21 22:56:51 -05:00
Jason Wen	e54ddf30b8	ci: restore workflows from source branch for reset and squash (#1607 )	2025-12-21 22:48:45 -05:00
Nayan	3093bb0b66	ui: fix sunnylink paired/sponsorship state (#1603 ) * fix * no point polling when disabled	2025-12-21 22:26:11 -05:00
Jason Wen	9c7c84bd03	ui: simplify non-inline action button positioning in `ListViewSP` (#1599 ) ui: update non-inline action button positioning in `ListViewSP`	2025-12-20 23:30:30 -05:00
Jason Wen	6c6be573c7	ui: `LineSeparatorSP` (#1598 )	2025-12-20 22:50:58 -05:00
Jason Wen	8904300565	Toyota: Enforce Factory Longitudinal Control (#1596 ) * Toyota: enforce factory longitudinal control support * sunnylink! * bump * bruh	2025-12-20 22:40:40 -05:00
Jason Wen	09c4b933a8	ui: capitalize button texts in Vehicle panel (#1597 )	2025-12-20 22:14:19 -05:00
Jason Wen	1a1178140f	ui: include MADS enabled state to `engaged` check (#1595 )	2025-12-20 21:35:51 -05:00
Jason Wen	452aa67581	DM: fix upstream merge overwrite with `latActive` check (#1594 ) * Update enabled condition to include latActive * Todo-sp	2025-12-20 15:20:24 -05:00
Kumar	5bf2ac1657	[TIZI/TICI] ui: chevron metrics (#1487 ) * chevron info * sp dir * rename * decouple from stock model renderer * pain * RED DIFF: get from ui state directly * built in * banned * no magic * space --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-19 22:06:27 -05:00
Kumar	f42dbf0c34	[TIZI/TICI] ui: rainbow path (#1486 ) * rainbow * use monotonic * sp dir * lint * decouple from stock model renderer * call in ui state directly * it's a boolean * too long * nope --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-19 17:36:43 -05:00
zikeji	40f838260b	sunnylink: block remote modification of SSH key parameters (#1591 ) * feat: add blocked parameter names * add unit test to validate * test: use cached method * move it out --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-19 16:31:01 -05:00
Nayan	f8487cae23	sunnylink: elliptic curve keys support and improve key path handling (#1566 ) * support ecdsa for mici * lint * ugh * ugh ughain * more * symmetrical AES key derivation and some missing key handling * cleanup --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-19 15:49:24 -05:00
Jason Wen	2e576178cb	ci: fix duplicate `if` syntax error (#1590 )	2025-12-19 15:31:29 -05:00
royjr	5578b7e754	ui: lateral-only and longitudinal-only UI statuses support (#1539 ) * init * add only colors * fix LAT_ONLY on mici * better ball * hide wheel on LONG_ONLY * hide torquebar on LONG_ONLY * simpler * dont block demo * path only on long * lanelines only on lat * hide on override * better * same LANE_LINE_COLORS for mads * use mads colors * Revert "use mads colors" This reverts commit 556321e5debe44e33d4ad98f440f0ed9f961fdf5. * slight decouple confidence ball * slight decouple model renderer * slight decouple augmented road view * decouple status update * decouple and override with our own, no overriding with steering if long only * fix * fix it --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-19 14:36:10 -05:00
Nayan	57e7c0b2c1	[comma 4] ui: sunnylink panel (#1544 ) * param to control stock vs sp ui * init styles * SP Toggles * Lint * optimizations * sp raylib preview * fix callback * fix ui preview * sunnylink state * introducing ui_state_sp for py * poll from ui_state_sp * cloudlog & ruff * param to control stock vs sp ui * better * better padding * this * listitem -> listitemsp * add show_description method * remove padding from line separator. like, WHY? 😩😩 * ui: `GuiApplicationExt` * add to readme * use gui_app.sunnypilot_ui() * use gui_app.sunnypilot_ui() * fetch only when connected to network * init sunnylink panels * cleanup * lint * flippity floppity * fix backup/restore status * show contributor tier * sunnylink-mici * icons * fix * add uploader * final --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2025-12-18 23:15:52 -05:00
				`@@ -1 +0,0 @@`
				`fdb3b49ee19956e6ce09fdc3373cbba557f1263b2180e9f344c1d4053852284b`