Merge branch 'sync-20251114' into hkg-angle-steering-2025-sync-20251114

too extra
2026-06-23 12:12:07 +08:00 · 2025-11-15 01:53:09 -05:00 · 2025-11-15 01:53:04 -05:00 · 2025-11-15 01:51:58 -05:00 · 2025-11-15 01:51:50 -05:00 · 2025-11-15 01:44:05 -05:00
510 changed files with 26133 additions and 59321 deletions
@@ -1,19 +0,0 @@
---
-Checks: '
-bugprone-*,
-bugprone-integer-division,
-bugprone-narrowing-conversions,
-performance-*,
-clang-analyzer-*,
-misc-*,
-misc-unused-parameters,
-modernize-*,
-modernize-avoid-c-arrays,
-modernize-deprecated-headers,
-modernize-use-auto,
-modernize-use-using,
-modernize-use-nullptr,
-modernize-use-trailing-return-type,
-'
-CheckOptions:
-...
@@ -2,5 +2,6 @@ Wen
 REGIST
 PullRequest
 cancelled
+indeces
 FOF
 NoO
@@ -13,27 +13,6 @@
 *.o-*
 *.os
 *.os-*
-*.so
-*.a

 venv/
 .venv/
-
-notebooks
-phone
-massivemap
-neos
-installer
-chffr/app2
-chffr/backend/env
-selfdrive/nav
-selfdrive/baseui
-selfdrive/test/simulator2
-**/cache_data
-xx/plus
-xx/community
-xx/projects
-!xx/projects/eon_testing_master
-!xx/projects/map3d
-xx/ops
-xx/junk
@@ -7,10 +7,12 @@
 *.png filter=lfs diff=lfs merge=lfs -text
 *.gif filter=lfs diff=lfs merge=lfs -text
 *.ttf filter=lfs diff=lfs merge=lfs -text
+*.otf filter=lfs diff=lfs merge=lfs -text
 *.wav filter=lfs diff=lfs merge=lfs -text

 selfdrive/car/tests/test_models_segs.txt filter=lfs diff=lfs merge=lfs -text
-system/hardware/tici/updater filter=lfs diff=lfs merge=lfs -text
+system/hardware/tici/updater_weston filter=lfs diff=lfs merge=lfs -text
+system/hardware/tici/updater_magic filter=lfs diff=lfs merge=lfs -text
 third_party/**/*.a filter=lfs diff=lfs merge=lfs -text
 third_party/**/*.so filter=lfs diff=lfs merge=lfs -text
 third_party/**/*.so.* filter=lfs diff=lfs merge=lfs -text
@@ -16,7 +16,7 @@ simulation:

 ui:
  - changed-files:
-    - any-glob-to-all-files: '{selfdrive/ui/**,system/ui/**}'
+    - any-glob-to-all-files: '{selfdrive/assets/**,selfdrive/ui/**,system/ui/**}'

 tools:
  - changed-files:
@@ -23,7 +23,7 @@ jobs:
    - uses: ./.github/workflows/setup-with-retry
    - name: Push badges
      run: |
-        ${{ env.RUN }} "scons -j$(nproc) && python3 selfdrive/ui/translations/create_badges.py"
+        ${{ env.RUN }} "python3 selfdrive/ui/translations/create_badges.py"

        rm .gitattributes

@@ -11,7 +11,7 @@ concurrency:
  cancel-in-progress: true

 jobs:
-  selfdrive_tests:
-    uses: sunnypilot/sunnypilot/.github/workflows/selfdrive_tests.yaml@master
+  tests:
+    uses: sunnypilot/sunnypilot/.github/workflows/tests.yaml@master
    with:
      run_number: ${{ inputs.run_number }}
@@ -1,4 +1,4 @@
-name: "ui preview"
+name: "raylib ui preview"
 on:
  push:
    branches:
@@ -8,14 +8,16 @@ on:
    branches:
      - 'master'
    paths:
+      - 'selfdrive/assets/**'
      - 'selfdrive/ui/**'
+      - 'system/ui/**'
  workflow_dispatch:

 env:
-  UI_JOB_NAME: "Create UI Report"
+  UI_JOB_NAME: "Create raylib UI Report"
  REPORT_NAME: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && 'master' || github.event.number }}
  SHA: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && github.sha || github.event.pull_request.head.sha }}
-  BRANCH_NAME: "openpilot/pr-${{ github.event.number }}"
+  BRANCH_NAME: "openpilot/pr-${{ github.event.number }}-raylib-ui"

 jobs:
  preview:
@@ -52,7 +54,7 @@ jobs:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          run_id: ${{ steps.get_run_id.outputs.run_id }}
          search_artifacts: true
-          name: report-1-${{ env.REPORT_NAME }}
+          name: raylib-report-1-${{ env.REPORT_NAME }}
          path: ${{ github.workspace }}/pr_ui

      - name: Getting master ui
@@ -60,23 +62,23 @@ jobs:
        with:
          repository: sunnypilot/ci-artifacts
          ssh-key: ${{ secrets.CI_ARTIFACTS_DEPLOY_KEY }}
-          path: ${{ github.workspace }}/master_ui
-          ref: openpilot_master_ui
+          path: ${{ github.workspace }}/master_ui_raylib
+          ref: openpilot_master_ui_raylib

      - name: Saving new master ui
        if: github.ref == 'refs/heads/master' && github.event_name == 'push'
-        working-directory: ${{ github.workspace }}/master_ui
+        working-directory: ${{ github.workspace }}/master_ui_raylib
        run: |
-          git checkout --orphan=new_master_ui
+          git checkout --orphan=new_master_ui_raylib
          git rm -rf *
-          git branch -D openpilot_master_ui
-          git branch -m openpilot_master_ui
+          git branch -D openpilot_master_ui_raylib
+          git branch -m openpilot_master_ui_raylib
          git config user.name "GitHub Actions Bot"
          git config user.email "<>"
          mv ${{ github.workspace }}/pr_ui/*.png .
          git add .
-          git commit -m "screenshots for commit ${{ env.SHA }}"
-          git push origin openpilot_master_ui --force
+          git commit -m "raylib screenshots for commit ${{ env.SHA }}"
+          git push origin openpilot_master_ui_raylib --force

      - name: Finding diff
        if: github.event_name == 'pull_request_target'
@@ -94,7 +96,7 @@ jobs:
          for ((i=0; i<${#A[*]}; i=i+1));
          do
            # Check if the master file exists
-            if [ ! -f "${{ github.workspace }}/master_ui/${A[$i]}.png" ]; then
+            if [ ! -f "${{ github.workspace }}/master_ui_raylib/${A[$i]}.png" ]; then
              # This is a new file in PR UI that doesn't exist in master
              DIFF="${DIFF}<details open>"
              DIFF="${DIFF}<summary>${A[$i]} : \$\${\\color{cyan}\\text{NEW}}\$\$</summary>"
@@ -106,12 +108,12 @@ jobs:

              DIFF="${DIFF}</table>"
              DIFF="${DIFF}</details>"
-            elif ! compare -fuzz 2% -highlight-color DeepSkyBlue1 -lowlight-color Black -compose Src ${{ github.workspace }}/master_ui/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}_diff.png; then
+            elif ! compare -fuzz 2% -highlight-color DeepSkyBlue1 -lowlight-color Black -compose Src ${{ github.workspace }}/master_ui_raylib/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}_diff.png; then
              convert ${{ github.workspace }}/pr_ui/${A[$i]}_diff.png -transparent black mask.png
-              composite mask.png ${{ github.workspace }}/master_ui/${A[$i]}.png composite_diff.png
-              convert -delay 100 ${{ github.workspace }}/master_ui/${A[$i]}.png composite_diff.png -loop 0 ${{ github.workspace }}/pr_ui/${A[$i]}_diff.gif
+              composite mask.png ${{ github.workspace }}/master_ui_raylib/${A[$i]}.png composite_diff.png
+              convert -delay 100 ${{ github.workspace }}/master_ui_raylib/${A[$i]}.png composite_diff.png -loop 0 ${{ github.workspace }}/pr_ui/${A[$i]}_diff.gif

-              mv ${{ github.workspace }}/master_ui/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}_master_ref.png
+              mv ${{ github.workspace }}/master_ui_raylib/${A[$i]}.png ${{ github.workspace }}/pr_ui/${A[$i]}_master_ref.png

              DIFF="${DIFF}<details open>"
              DIFF="${DIFF}<summary>${A[$i]} : \$\${\\color{red}\\text{DIFFERENT}}\$\$</summary>"
@@ -149,7 +151,7 @@ jobs:

      - name: Saving proposed ui
        if: github.event_name == 'pull_request_target'
-        working-directory: ${{ github.workspace }}/master_ui
+        working-directory: ${{ github.workspace }}/master_ui_raylib
        run: |
          git config user.name "GitHub Actions Bot"
          git config user.email "<>"
@@ -157,7 +159,7 @@ jobs:
          git rm -rf *
          mv ${{ github.workspace }}/pr_ui/* .
          git add .
-          git commit -m "screenshots for PR #${{ github.event.number }}"
+          git commit -m "raylib screenshots for PR #${{ github.event.number }}"
          git push origin ${{ env.BRANCH_NAME }} --force

      - name: Comment Screenshots on PR
@@ -165,9 +167,9 @@ jobs:
        uses: thollander/actions-comment-pull-request@v2
        with:
          message: |
-            <!-- _(run_id_screenshots **${{ github.run_id }}**)_ -->
-            ## UI Preview
+            <!-- _(run_id_screenshots_raylib **${{ github.run_id }}**)_ -->
+            ## raylib UI Preview
            ${{ steps.find_diff.outputs.DIFF }}
-          comment_tag: run_id_screenshots
+          comment_tag: run_id_screenshots_raylib
          pr_number: ${{ github.event.number }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -1,4 +1,4 @@
-name: selfdrive
+name: tests

 on:
  push:
@@ -14,7 +14,7 @@ on:
        type: string

 concurrency:
-  group: selfdrive-tests-ci-run-${{ inputs.run_number }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && github.run_id || github.head_ref || github.ref }}-${{ github.workflow }}-${{ github.event_name }}
+  group: tests-ci-run-${{ inputs.run_number }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && github.run_id || github.head_ref || github.ref }}-${{ github.workflow }}-${{ github.event_name }}
  cancel-in-progress: true

 env:
@@ -195,8 +195,6 @@ jobs:
                        # Pre-compile Python bytecode so each pytest worker doesn't need to
                        $PYTEST --collect-only -m 'not slow' -qq && \
                        MAX_EXAMPLES=1 $PYTEST -m 'not slow' && \
-                        ./selfdrive/ui/tests/create_test_translations.sh && \
-                        QT_QPA_PLATFORM=offscreen ./selfdrive/ui/tests/test_translations && \
                        chmod -R 777 /tmp/comma_download_cache"

  process_replay:
@@ -257,7 +255,7 @@ jobs:
      (github.event.pull_request.head.repo.full_name == 'commaai/openpilot'))
      && fromJSON('["namespace-profile-amd64-8x16", "namespace-experiments:docker.builds.local-cache=separate"]')
      || fromJSON('["ubuntu-24.04"]') }}
-    if: (github.repository == 'commaai/openpilot') && ((github.event_name != 'pull_request') || (github.event.pull_request.head.repo.full_name == 'commaai/openpilot'))
+    if: false  # FIXME: Started to timeout recently
    steps:
    - uses: actions/checkout@v4
      with:
@@ -274,38 +272,28 @@ jobs:
                        source selfdrive/test/setup_vsound.sh && \
                        CI=1 pytest -s tools/sim/tests/test_metadrive_bridge.py"

-  create_ui_report:
-    # This job name needs to be the same as UI_JOB_NAME in ui_preview.yaml
-    name: Create UI Report
+  create_raylib_ui_report:
+    name: Create raylib UI Report
    runs-on: ${{
      (github.repository == 'commaai/openpilot') &&
      ((github.event_name != 'pull_request') ||
      (github.event.pull_request.head.repo.full_name == 'commaai/openpilot'))
      && fromJSON('["namespace-profile-amd64-8x16", "namespace-experiments:docker.builds.local-cache=separate"]')
      || fromJSON('["ubuntu-24.04"]') }}
-    if: false  # FIXME: FrameReader is broken on CI runners
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: true
      - uses: ./.github/workflows/setup-with-retry
-      - name: caching frames
-        id: frames-cache
-        uses: actions/cache@v4
-        with:
-          path: .ci_cache/comma_download_cache
-          key: ui_screenshots_test_${{ hashFiles('selfdrive/ui/tests/test_ui/run.py') }}
      - name: Build openpilot
        run: ${{ env.RUN }} "scons -j$(nproc)"
-      - name: Create Test Report
-        timeout-minutes: ${{ ((steps.frames-cache.outputs.cache-hit == 'true') && 2 || 4) }}
+      - name: Create raylib UI Report
        run: >
-            ${{ env.RUN }} "PYTHONWARNINGS=ignore &&
-                            source selfdrive/test/setup_xvfb.sh &&
-                            CACHE_ROOT=/tmp/comma_download_cache python3 selfdrive/ui/tests/test_ui/run.py &&
-                            chmod -R 777 /tmp/comma_download_cache"
-      - name: Upload Test Report
+          ${{ env.RUN }} "PYTHONWARNINGS=ignore &&
+                          source selfdrive/test/setup_xvfb.sh &&
+                          python3 selfdrive/ui/tests/test_ui/raylib_screenshots.py"
+      - name: Upload Raylib UI Report
        uses: actions/upload-artifact@v4
        with:
-          name: report-${{ inputs.run_number || '1' }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && 'master' || github.event.number }}
-          path: selfdrive/ui/tests/test_ui/report_1/screenshots
+          name: raylib-report-${{ inputs.run_number || '1' }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && 'master' || github.event.number }}
+          path: selfdrive/ui/tests/test_ui/raylib_report/screenshots
@@ -10,7 +10,6 @@ venv/
 .overlay_init
 .overlay_consistent
 .sconsign.dblite
-model2.png
 a.out
 .hypothesis
 .cache/
@@ -37,29 +36,23 @@ a.out
 *.class
 *.pyxbldc
 *.vcd
-*.qm
+*.mo
 *_pyx.cpp
+*.stats
 config.json
 clcache
 compile_commands.json
 compare_runtime*.html

-persist
 selfdrive/pandad/pandad
 cereal/services.h
 cereal/gen
 cereal/messaging/bridge
-selfdrive/mapd/default_speeds_by_region.json
 selfdrive/ui/translations/tmp
-selfdrive/test/longitudinal_maneuvers/out
 selfdrive/car/tests/cars_dump
 system/camerad/camerad
 system/camerad/test/ae_gray_test

-notebooks
-hyperthneed
-provisioning
-
 .coverage*
 coverage.xml
 htmlcov
@@ -76,6 +69,7 @@ sunnypilot/modeld*/thneed/compile
 sunnypilot/modeld*/models/*.thneed
 sunnypilot/modeld*/models/*.pkl

+# openpilot log files
 *.bz2
 *.zst

@@ -15,7 +15,7 @@
  url = https://github.com/commaai/teleoprtc
 [submodule "tinygrad"]
  path = tinygrad_repo
-  url = https://github.com/tinygrad/tinygrad.git
+  url = https://github.com/commaai/tinygrad.git
 [submodule "sunnypilot/neural_network_data"]
  path = sunnypilot/neural_network_data
  url = https://github.com/sunnypilot/neural-network-data.git
@@ -21,5 +21,12 @@
        </clean>
      </configuration>
    </target>
+    <target id="f2590b2b-9b93-49f9-8510-da3f3724a2ae" name="replay" defaultType="TOOL">
+      <configuration id="d475264f-6f4c-4092-9b4e-6773309f38b7" name="replay" toolchainName="Default">
+        <build type="TOOL">
+          <tool actionId="Tool_External Tools_uv build tools replay" />
+        </build>
+      </configuration>
+    </target>
  </component>
 </project>
@@ -20,4 +20,11 @@
      <option name="WORKING_DIRECTORY" value="$ProjectFileDir$" />
    </exec>
  </tool>
+  <tool name="uv build tools replay" showInMainMenu="false" showInEditor="false" showInProject="false" showInSearchPopup="false" disabled="false" useConsole="true" showConsoleOnStdOut="false" showConsoleOnStdErr="false" synchronizeAfterRun="true">
+    <exec>
+      <option name="COMMAND" value="bash" />
+      <option name="PARAMETERS" value="-c &quot;source .venv/bin/activate &amp;&amp; scons -u -j$(nproc) tools/replay/&quot;" />
+      <option name="WORKING_DIRECTORY" value="$ProjectFileDir$" />
+    </exec>
+  </tool>
 </toolSet>
@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Build Debug" type="CLionExternalRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" WORKING_DIR="file://$ProjectFileDir$/selfdrive/ui" PASS_PARENT_ENVS_2="true" PROJECT_NAME="sunnypilot" TARGET_NAME="uv Scons Build Debug" CONFIG_NAME="uv Scons Build Debug" RUN_PATH="ui">
+  <configuration default="false" name="Build Debug" type="CLionExternalRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" WORKING_DIR="file://$ProjectFileDir$/selfdrive/ui" PASS_PARENT_ENVS_2="true" PROJECT_NAME="openpilot-special" TARGET_NAME="uv Scons Build Debug" CONFIG_NAME="uv Scons Build Debug" RUN_PATH="ui">
    <envs>
      <env name="QT_DBL_CLICK_DIST" value="150" />
    </envs>
@@ -0,0 +1,27 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Debug Route Controls" type="PythonConfigurationType" factoryName="Python">
+    <module name="openpilot-special" />
+    <option name="ENV_FILES" value="" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="PARENT_ENVS" value="true" />
+    <envs>
+      <env name="PYTHONUNBUFFERED" value="1" />
+      <env name="FINGERPRINT" value="KIA_EV9" />
+      <env name="SKIP_FW_QUERY" value="1" />
+    </envs>
+    <option name="SDK_HOME" value="" />
+    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/selfdrive/car" />
+    <option name="IS_MODULE_SDK" value="true" />
+    <option name="ADD_CONTENT_ROOTS" value="true" />
+    <option name="ADD_SOURCE_ROOTS" value="true" />
+    <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+    <option name="SCRIPT_NAME" value="$PROJECT_DIR$/selfdrive/car/card.py" />
+    <option name="PARAMETERS" value="" />
+    <option name="SHOW_COMMAND_LINE" value="false" />
+    <option name="EMULATE_TERMINAL" value="true" />
+    <option name="MODULE_MODE" value="false" />
+    <option name="REDIRECT_INPUT" value="false" />
+    <option name="INPUT_FILE" value="" />
+    <method v="2" />
+  </configuration>
+</component>
@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Replay for controls + ui" type="Multirun" separateTabs="false" reuseTabsWithFailures="false" startOneByOne="true" markFailedProcess="true" hideSuccessProcess="false" delayTime="0.0">
+    <runConfiguration name="replay for controls" type="Native Application" />
+    <runConfiguration name="Build Debug" type="Custom Build Application" />
+    <method v="2" />
+  </configuration>
+</component>
@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="replay for controls" type="CLionNativeAppRunConfigurationType" focusToolWindowBeforeRun="true" PROGRAM_PARAMS="&quot;$Prompt$&quot; --block &quot;sendcan,carState,carParams,carOutput,liveTracks,carParamsSP,carStateSP,bookmarkButton&quot;" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="true" WORKING_DIR="file://$ProjectFileDir$/tools/replay" PASS_PARENT_ENVS_2="true" PROJECT_NAME="openpilot-special" TARGET_NAME="replay" CONFIG_NAME="replay" version="1" RUN_PATH="replay">
+    <method v="2">
+      <option name="CLION.COMPOUND.BUILD" enabled="true" />
+    </method>
+  </configuration>
+</component>
@@ -9,4 +9,6 @@ WORKDIR ${OPENPILOT_PATH}

 COPY . ${OPENPILOT_PATH}/

-RUN scons --cache-readonly -j$(nproc)
+ENV UV_BIN="/home/batman/.local/bin/"
+ENV PATH="$UV_BIN:$PATH"
+RUN UV_PROJECT_ENVIRONMENT=$VIRTUAL_ENV uv run scons --cache-readonly -j$(nproc)
@@ -167,7 +167,7 @@ node {
  env.GIT_COMMIT = checkout(scm).GIT_COMMIT

  def excludeBranches = ['__nightly', 'devel', 'devel-staging', 'release3', 'release3-staging',
-                         'release-tici', 'testing-closet*', 'hotfix-*']
+                         'release-tici', 'release-tizi', 'release-tizi-staging', 'testing-closet*', 'hotfix-*']
  def excludeRegex = excludeBranches.join('|').replaceAll('\\*', '.*')

  if (env.BRANCH_NAME != 'master' && !env.BRANCH_NAME.contains('__jenkins_loop_')) {
@@ -178,8 +178,8 @@ node {

  try {
    if (env.BRANCH_NAME == 'devel-staging') {
-      deviceStage("build release3-staging", "tizi-needs-can", [], [
-        step("build release3-staging", "RELEASE_BRANCH=release3-staging $SOURCE_DIR/release/build_release.sh"),
+      deviceStage("build release-tizi-staging", "tizi-needs-can", [], [
+        step("build release-tizi-staging", "RELEASE_BRANCH=release-tizi-staging $SOURCE_DIR/release/build_release.sh"),
      ])
    }

@@ -1,13 +1,20 @@
+Version 0.10.2 (2025-11-23)
+========================
+
 Version 0.10.1 (2025-09-08)
 ========================
-* New driving model
+* New driving model #36276
  * World Model: removed global localization inputs
  * World Model: 2x the number of parameters
  * World Model: trained on 4x the number of segments
+  * VAE Compression Model: new architecture and training objective
  * Driving Vision Model: trained on 4x the number of segments
+* New Driver Monitoring model #36198
+* Acura TLX 2021 support thanks to MVL!
 * Honda City 2023 support thanks to vanillagorillaa and drFritz!
 * Honda N-Box 2018 support thanks to miettal!
 * Honda Odyssey 2021-25 support thanks to csouers and MVL!
+* Honda Passport 2026 support thanks to vanillagorillaa and MVL!

 Version 0.10.0 (2025-08-05)
 ========================
@@ -3,176 +3,52 @@ import subprocess
 import sys
 import sysconfig
 import platform
+import shlex
 import numpy as np

 import SCons.Errors

 SCons.Warnings.warningAsException(True)

-# pending upstream fix - https://github.com/SCons/scons/issues/4461
-#SetOption('warn', 'all')
-
-TICI = os.path.isfile('/TICI')
-AGNOS = TICI
-
 Decider('MD5-timestamp')

 SetOption('num_jobs', max(1, int(os.cpu_count()/2)))

-AddOption('--kaitai',
-          action='store_true',
-          help='Regenerate kaitai struct parsers')
-
-AddOption('--asan',
-          action='store_true',
-          help='turn on ASAN')
-
-AddOption('--ubsan',
-          action='store_true',
-          help='turn on UBSan')
-
-AddOption('--coverage',
-          action='store_true',
-          help='build with test coverage options')
-
-AddOption('--clazy',
-          action='store_true',
-          help='build with clazy')
-
-AddOption('--ccflags',
-          action='store',
-          type='string',
-          default='',
-          help='pass arbitrary flags over the command line')
-
-AddOption('--external-sconscript',
-          action='store',
-          metavar='FILE',
-          dest='external_sconscript',
-          help='add an external SConscript to the build')
-
-AddOption('--mutation',
-          action='store_true',
-          help='generate mutation-ready code')
-
+AddOption('--kaitai', action='store_true', help='Regenerate kaitai struct parsers')
+AddOption('--asan', action='store_true', help='turn on ASAN')
+AddOption('--ubsan', action='store_true', help='turn on UBSan')
+AddOption('--mutation', action='store_true', help='generate mutation-ready code')
+AddOption('--ccflags', action='store', type='string', default='', help='pass arbitrary flags over the command line')
 AddOption('--minimal',
          action='store_false',
          dest='extras',
-          default=os.path.exists(File('#.lfsconfig').abspath), # minimal by default on release branch (where there's no LFS)
+          default=os.path.exists(File('#.gitattributes').abspath), # minimal by default on release branch (where there's no LFS)
          help='the minimum build to run openpilot. no tests, tools, etc.')

-AddOption('--stock-ui',
-          action='store_true',
-          dest='stock_ui',
-          default=False,
-          help='Build stock openpilot UI instead of sunnypilot UI')
-
-## Architecture name breakdown (arch)
-## - larch64: linux tici aarch64
-## - aarch64: linux pc aarch64
-## - x86_64:  linux pc x64
-## - Darwin:  mac x64 or arm64
-real_arch = arch = subprocess.check_output(["uname", "-m"], encoding='utf8').rstrip()
+# Detect platform
+arch = subprocess.check_output(["uname", "-m"], encoding='utf8').rstrip()
 if platform.system() == "Darwin":
  arch = "Darwin"
  brew_prefix = subprocess.check_output(['brew', '--prefix'], encoding='utf8').strip()
-elif arch == "aarch64" and AGNOS:
+elif arch == "aarch64" and os.path.isfile('/TICI'):
  arch = "larch64"
-assert arch in ["larch64", "aarch64", "x86_64", "Darwin"]
-
-lenv = {
-  "PATH": os.environ['PATH'],
-  "PYTHONPATH": Dir("#").abspath + ':' + Dir(f"#third_party/acados").abspath,
-
-  "ACADOS_SOURCE_DIR": Dir("#third_party/acados").abspath,
-  "ACADOS_PYTHON_INTERFACE_PATH": Dir("#third_party/acados/acados_template").abspath,
-  "TERA_PATH": Dir("#").abspath + f"/third_party/acados/{arch}/t_renderer"
-}
-
-rpath = []
-
-if arch == "larch64":
-  cpppath = [
-    "#third_party/opencl/include",
-  ]
-
-  libpath = [
-    "/usr/local/lib",
-    "/system/vendor/lib64",
-    f"#third_party/acados/{arch}/lib",
-  ]
-
-  libpath += [
-    "#third_party/snpe/larch64",
-    "#third_party/libyuv/larch64/lib",
-    "/usr/lib/aarch64-linux-gnu"
-  ]
-  cflags = ["-DQCOM2", "-mcpu=cortex-a57"]
-  cxxflags = ["-DQCOM2", "-mcpu=cortex-a57"]
-  rpath += ["/usr/local/lib"]
-else:
-  cflags = []
-  cxxflags = []
-  cpppath = []
-  rpath += []
-
-  # MacOS
-  if arch == "Darwin":
-    libpath = [
-      f"#third_party/libyuv/{arch}/lib",
-      f"#third_party/acados/{arch}/lib",
-      f"{brew_prefix}/lib",
-      f"{brew_prefix}/opt/openssl@3.0/lib",
-      "/System/Library/Frameworks/OpenGL.framework/Libraries",
-    ]
-
-    cflags += ["-DGL_SILENCE_DEPRECATION"]
-    cxxflags += ["-DGL_SILENCE_DEPRECATION"]
-    cpppath += [
-      f"{brew_prefix}/include",
-      f"{brew_prefix}/opt/openssl@3.0/include",
-    ]
-  # Linux
-  else:
-    libpath = [
-      f"#third_party/acados/{arch}/lib",
-      f"#third_party/libyuv/{arch}/lib",
-      "/usr/lib",
-      "/usr/local/lib",
-    ]
-
-    if arch == "x86_64":
-      libpath += [
-        f"#third_party/snpe/{arch}"
-      ]
-      rpath += [
-        Dir(f"#third_party/snpe/{arch}").abspath,
-      ]
-
-if GetOption('asan'):
-  ccflags = ["-fsanitize=address", "-fno-omit-frame-pointer"]
-  ldflags = ["-fsanitize=address"]
-elif GetOption('ubsan'):
-  ccflags = ["-fsanitize=undefined"]
-  ldflags = ["-fsanitize=undefined"]
-else:
-  ccflags = []
-  ldflags = []
-
-# no --as-needed on mac linker
-if arch != "Darwin":
-  ldflags += ["-Wl,--as-needed", "-Wl,--no-undefined"]
-
-if not GetOption('stock_ui'):
-  cflags += ["-DSUNNYPILOT"]
-  cxxflags += ["-DSUNNYPILOT"]
-
-ccflags_option = GetOption('ccflags')
-if ccflags_option:
-  ccflags += ccflags_option.split(' ')
+assert arch in [
+  "larch64",  # linux tici arm64
+  "aarch64",  # linux pc arm64
+  "x86_64",   # linux pc x64
+  "Darwin",   # macOS arm64 (x86 not supported)
+]

 env = Environment(
-  ENV=lenv,
+  ENV={
+    "PATH": os.environ['PATH'],
+    "PYTHONPATH": Dir("#").abspath + ':' + Dir(f"#third_party/acados").abspath,
+    "ACADOS_SOURCE_DIR": Dir("#third_party/acados").abspath,
+    "ACADOS_PYTHON_INTERFACE_PATH": Dir("#third_party/acados/acados_template").abspath,
+    "TERA_PATH": Dir("#").abspath + f"/third_party/acados/{arch}/t_renderer"
+  },
+  CC='clang',
+  CXX='clang++',
  CCFLAGS=[
    "-g",
    "-fPIC",
@@ -185,37 +61,32 @@ env = Environment(
    "-Wno-c99-designator",
    "-Wno-reorder-init-list",
    "-Wno-vla-cxx-extension",
-  ] + cflags + ccflags,
-
-  CPPPATH=cpppath + [
+  ],
+  CFLAGS=["-std=gnu11"],
+  CXXFLAGS=["-std=c++1z"],
+  CPPPATH=[
    "#",
+    "#msgq",
+    "#third_party",
+    "#third_party/json11",
+    "#third_party/linux/include",
    "#third_party/acados/include",
    "#third_party/acados/include/blasfeo/include",
    "#third_party/acados/include/hpipm/include",
    "#third_party/catch2/include",
    "#third_party/libyuv/include",
-    "#third_party/json11",
-    "#third_party/linux/include",
    "#third_party/snpe/include",
-    "#third_party",
-    "#msgq",
  ],
-
-  CC='clang',
-  CXX='clang++',
-  LINKFLAGS=ldflags,
-
-  RPATH=rpath,
-
-  CFLAGS=["-std=gnu11"] + cflags,
-  CXXFLAGS=["-std=c++1z"] + cxxflags,
-  LIBPATH=libpath + [
+  LIBPATH=[
+    "#common",
    "#msgq_repo",
    "#third_party",
    "#selfdrive/pandad",
-    "#common",
    "#rednose/helpers",
+    f"#third_party/libyuv/{arch}/lib",
+    f"#third_party/acados/{arch}/lib",
  ],
+  RPATH=[],
  CYTHONCFILESUFFIX=".cpp",
  COMPILATIONDB_USE_ABSPATH=True,
  REDNOSE_ROOT="#",
@@ -223,30 +94,72 @@ env = Environment(
  toolpath=["#site_scons/site_tools", "#rednose_repo/site_scons/site_tools"],
 )

-if arch == "Darwin":
-  # RPATH is not supported on macOS, instead use the linker flags
-  darwin_rpath_link_flags = [f"-Wl,-rpath,{path}" for path in env["RPATH"]]
-  env["LINKFLAGS"] += darwin_rpath_link_flags
+# Arch-specific flags and paths
+if arch == "larch64":
+  env.Append(CPPPATH=["#third_party/opencl/include"])
+  env.Append(LIBPATH=[
+    "/usr/local/lib",
+    "/system/vendor/lib64",
+    "/usr/lib/aarch64-linux-gnu",
+    "#third_party/snpe/larch64",
+  ])
+  arch_flags = ["-D__TICI__", "-mcpu=cortex-a57", "-DQCOM2"]
+  env.Append(CCFLAGS=arch_flags)
+  env.Append(CXXFLAGS=arch_flags)
+elif arch == "Darwin":
+  env.Append(LIBPATH=[
+    f"{brew_prefix}/lib",
+    f"{brew_prefix}/opt/openssl@3.0/lib",
+    f"{brew_prefix}/opt/llvm/lib/c++",
+    "/System/Library/Frameworks/OpenGL.framework/Libraries",
+  ])
+  env.Append(CCFLAGS=["-DGL_SILENCE_DEPRECATION"])
+  env.Append(CXXFLAGS=["-DGL_SILENCE_DEPRECATION"])
+  env.Append(CPPPATH=[
+    f"{brew_prefix}/include",
+    f"{brew_prefix}/opt/openssl@3.0/include",
+  ])
+else:
+  env.Append(LIBPATH=[
+    "/usr/lib",
+    "/usr/local/lib",
+  ])

-env.CompilationDatabase('compile_commands.json')
+  if arch == "x86_64":
+    env.Append(LIBPATH=[
+      f"#third_party/snpe/{arch}"
+    ])
+    env.Append(RPATH=[
+      Dir(f"#third_party/snpe/{arch}").abspath,
+    ])

-# Setup cache dir
-default_cache_dir = '/data/scons_cache' if AGNOS else '/tmp/scons_cache'
-cache_dir = ARGUMENTS.get('cache_dir', default_cache_dir)
-CacheDir(cache_dir)
-Clean(["."], cache_dir)
+# Sanitizers and extra CCFLAGS from CLI
+if GetOption('asan'):
+  env.Append(CCFLAGS=["-fsanitize=address", "-fno-omit-frame-pointer"])
+  env.Append(LINKFLAGS=["-fsanitize=address"])
+elif GetOption('ubsan'):
+  env.Append(CCFLAGS=["-fsanitize=undefined"])
+  env.Append(LINKFLAGS=["-fsanitize=undefined"])

+_extra_cc = shlex.split(GetOption('ccflags') or '')
+if _extra_cc:
+  env.Append(CCFLAGS=_extra_cc)
+
+# no --as-needed on mac linker
+if arch != "Darwin":
+  env.Append(LINKFLAGS=["-Wl,--as-needed", "-Wl,--no-undefined"])
+
+# progress output
 node_interval = 5
 node_count = 0
 def progress_function(node):
  global node_count
  node_count += node_interval
  sys.stderr.write("progress: %d\n" % node_count)
-
 if os.environ.get('SCONS_PROGRESS'):
  Progress(progress_function, interval=node_interval)

-# Cython build environment
+# ********** Cython build environment **********
 py_include = sysconfig.get_paths()['include']
 envCython = env.Clone()
 envCython["CPPPATH"] += [py_include, np.get_include()]
@@ -255,84 +168,27 @@ envCython["CCFLAGS"].remove("-Werror")

 envCython["LIBS"] = []
 if arch == "Darwin":
-  envCython["LINKFLAGS"] = ["-bundle", "-undefined", "dynamic_lookup"] + darwin_rpath_link_flags
+  envCython["LINKFLAGS"] = env["LINKFLAGS"] + ["-bundle", "-undefined", "dynamic_lookup"]
 else:
  envCython["LINKFLAGS"] = ["-pthread", "-shared"]

 np_version = SCons.Script.Value(np.__version__)
 Export('envCython', 'np_version')

-# Qt build environment
-qt_env = env.Clone()
-qt_modules = ["Widgets", "Gui", "Core", "Network", "Concurrent", "DBus", "Xml"]
+Export('env', 'arch')

-qt_libs = []
-if arch == "Darwin":
-  qt_env['QTDIR'] = f"{brew_prefix}/opt/qt@5"
-  qt_dirs = [
-    os.path.join(qt_env['QTDIR'], "include"),
-  ]
-  qt_dirs += [f"{qt_env['QTDIR']}/include/Qt{m}" for m in qt_modules]
-  qt_env["LINKFLAGS"] += ["-F" + os.path.join(qt_env['QTDIR'], "lib")]
-  qt_env["FRAMEWORKS"] += [f"Qt{m}" for m in qt_modules] + ["OpenGL"]
-  qt_env.AppendENVPath('PATH', os.path.join(qt_env['QTDIR'], "bin"))
-else:
-  qt_install_prefix = subprocess.check_output(['qmake', '-query', 'QT_INSTALL_PREFIX'], encoding='utf8').strip()
-  qt_install_headers = subprocess.check_output(['qmake', '-query', 'QT_INSTALL_HEADERS'], encoding='utf8').strip()
+# Setup cache dir
+cache_dir = '/data/scons_cache' if arch == "larch64" else '/tmp/scons_cache'
+CacheDir(cache_dir)
+Clean(["."], cache_dir)

-  qt_env['QTDIR'] = qt_install_prefix
-  qt_dirs = [
-    f"{qt_install_headers}",
-  ]
-
-  qt_gui_path = os.path.join(qt_install_headers, "QtGui")
-  qt_gui_dirs = [d for d in os.listdir(qt_gui_path) if os.path.isdir(os.path.join(qt_gui_path, d))]
-  qt_dirs += [f"{qt_install_headers}/QtGui/{qt_gui_dirs[0]}/QtGui", ] if qt_gui_dirs else []
-  qt_dirs += [f"{qt_install_headers}/Qt{m}" for m in qt_modules]
-
-  qt_libs = [f"Qt5{m}" for m in qt_modules]
-  if arch == "larch64":
-    qt_libs += ["GLESv2", "wayland-client"]
-    qt_env.PrependENVPath('PATH', Dir("#third_party/qt5/larch64/bin/").abspath)
-  elif arch != "Darwin":
-    qt_libs += ["GL"]
-qt_env['QT3DIR'] = qt_env['QTDIR']
-qt_env.Tool('qt3')
-
-qt_env['CPPPATH'] += qt_dirs + ["#third_party/qrcode"]
-qt_flags = [
-  "-D_REENTRANT",
-  "-DQT_NO_DEBUG",
-  "-DQT_WIDGETS_LIB",
-  "-DQT_GUI_LIB",
-  "-DQT_CORE_LIB",
-  "-DQT_MESSAGELOGCONTEXT",
-]
-qt_env['CXXFLAGS'] += qt_flags
-qt_env['LIBPATH'] += ['#selfdrive/ui', ]
-qt_env['LIBS'] = qt_libs
-
-if GetOption("clazy"):
-  checks = [
-    "level0",
-    "level1",
-    "no-range-loop",
-    "no-non-pod-global-static",
-  ]
-  qt_env['CXX'] = 'clazy'
-  qt_env['ENV']['CLAZY_IGNORE_DIRS'] = qt_dirs[0]
-  qt_env['ENV']['CLAZY_CHECKS'] = ','.join(checks)
-
-Export('env', 'qt_env', 'arch', 'real_arch')
+# ********** start building stuff **********

 # Build common module
 SConscript(['common/SConscript'])
-Import('_common', '_gpucommon')
-
+Import('_common')
 common = [_common, 'json11', 'zmq']
-gpucommon = [_gpucommon]
-
-Export('common', 'gpucommon')
+Export('common')

 # Build messaging (cereal + msgq + socketmaster + their dependencies)
 # Enable swaglog include in submodules
@@ -375,6 +231,5 @@ if Dir('#tools/cabana/').exists() and GetOption('extras'):
  if arch != "larch64":
    SConscript(['tools/cabana/SConscript'])

-external_sconscript = GetOption('external_sconscript')
-if external_sconscript:
-  SConscript([external_sconscript])
+
+env.CompilationDatabase('compile_commands.json')
@@ -918,6 +918,8 @@ struct ControlsState @0x97ff69c53601abf1 {
    saturated @7 :Bool;
    actualLateralAccel @9 :Float32;
    desiredLateralAccel @10 :Float32;
+    desiredLateralJerk @11 :Float32;
+    version @12 :Int32;
   }

  struct LateralLQRState {
@@ -2146,13 +2148,10 @@ struct Joystick {
 struct DriverStateV2 {
  frameId @0 :UInt32;
  modelExecutionTime @1 :Float32;
-  dspExecutionTimeDEPRECATED @2 :Float32;
  gpuExecutionTime @8 :Float32;
  rawPredictions @3 :Data;

-  poorVisionProb @4 :Float32;
  wheelOnRightProb @5 :Float32;
-
  leftDriverData @6 :DriverData;
  rightDriverData @7 :DriverData;

@@ -2167,10 +2166,13 @@ struct DriverStateV2 {
    leftBlinkProb @7 :Float32;
    rightBlinkProb @8 :Float32;
    sunglassesProb @9 :Float32;
-    occludedProb @10 :Float32;
-    readyProb @11 :List(Float32);
    notReadyProb @12 :List(Float32);
+    occludedProbDEPRECATED @10 :Float32;
+    readyProbDEPRECATED @11 :List(Float32);
  }
+
+  dspExecutionTimeDEPRECATED @2 :Float32;
+  poorVisionProbDEPRECATED @4 :Float32;
 }

 struct DriverStateDEPRECATED @0xb83c6cc593ed0a00 {
@@ -2222,6 +2224,7 @@ struct DriverMonitoringState @0xb83cda094a1da284 {
  hiStdCount @14 :UInt32;
  isActiveMode @16 :Bool;
  isRHD @4 :Bool;
+  uncertainCount @19 :UInt32;

  isPreviewDEPRECATED @15 :Bool;
  rhdCheckedDEPRECATED @5 :Bool;
@@ -4,18 +4,12 @@ common_libs = [
  'params.cc',
  'swaglog.cc',
  'util.cc',
-  'watchdog.cc',
-  'ratekeeper.cc'
-]
-
-_common = env.Library('common', common_libs, LIBS="json11")
-
-files = [
+  'ratekeeper.cc',
  'clutil.cc',
 ]

-_gpucommon = env.Library('gpucommon', files)
-Export('_common', '_gpucommon')
+_common = env.Library('common', common_libs, LIBS="json11")
+Export('_common')

 if GetOption('extras'):
  env.Program('tests/test_common',
@@ -14,9 +14,13 @@ class Api:
  def post(self, *args, **kwargs):
    return self.service.post(*args, **kwargs)

-  def get_token(self, expiry_hours=1):
-    return self.service.get_token(expiry_hours)
+  def get_token(self, payload_extra=None, expiry_hours=1):
+    return self.service.get_token(payload_extra, expiry_hours)


 def api_get(endpoint, method='GET', timeout=None, access_token=None, **params):
  return CommaConnectApi(None).api_get(endpoint, method, timeout, access_token, **params)
+
+
+def get_key_pair():
+  return CommaConnectApi(None).get_key_pair()
@@ -1,18 +1,22 @@
 import jwt
+import os
 import requests
 import unicodedata
 from datetime import datetime, timedelta, UTC
 from openpilot.system.hardware.hw import Paths
 from openpilot.system.version import get_version

+       # name : jwt signature algorithm
+KEYS = {"id_rsa" : "RS256",
+        "id_ecdsa" : "ES256"}
+

 class BaseApi:
  def __init__(self, dongle_id, api_host, user_agent="openpilot-"):
    self.dongle_id = dongle_id
    self.api_host = api_host
    self.user_agent = user_agent
-    with open(f'{Paths.persist_root()}/comma/id_rsa') as f:
-      self.private_key = f.read()
+    self.jwt_algorithm, self.private_key, _ = self.get_key_pair()

  def get(self, *args, **kwargs):
    return self.request('GET', *args, **kwargs)
@@ -23,7 +27,7 @@ class BaseApi:
  def request(self, method, endpoint, timeout=None, access_token=None, **params):
    return self.api_get(endpoint, method=method, timeout=timeout, access_token=access_token, **params)

-  def _get_token(self, expiry_hours=1, **extra_payload):
+  def _get_token(self, payload_extra=None, expiry_hours=1, **extra_payload):
    now = datetime.now(UTC).replace(tzinfo=None)
    payload = {
      'identity': self.dongle_id,
@@ -32,13 +36,15 @@ class BaseApi:
      'exp': now + timedelta(hours=expiry_hours),
      **extra_payload
    }
-    token = jwt.encode(payload, self.private_key, algorithm='RS256')
+    if payload_extra is not None:
+      payload.update(payload_extra)
+    token = jwt.encode(payload, self.private_key, algorithm=self.jwt_algorithm)
    if isinstance(token, bytes):
      token = token.decode('utf8')
    return token

-  def get_token(self, expiry_hours=1):
-    return self._get_token(expiry_hours)
+  def get_token(self, payload_extra=None, expiry_hours=1):
+    return self._get_token(payload_extra, expiry_hours)

  def remove_non_ascii_chars(self, text):
    normalized_text = unicodedata.normalize('NFD', text)
@@ -54,3 +60,11 @@ class BaseApi:
    headers['User-Agent'] = self.user_agent + version

    return requests.request(method, f"{self.api_host}/{endpoint}", timeout=timeout, headers=headers, json=json, params=params)
+
+  @staticmethod
+  def get_key_pair():
+    for key in KEYS:
+      if os.path.isfile(Paths.persist_root() + f'/comma/{key}') and os.path.isfile(Paths.persist_root() + f'/comma/{key}.pub'):
+        with open(Paths.persist_root() + f'/comma/{key}') as private, open(Paths.persist_root() + f'/comma/{key}.pub') as public:
+          return KEYS[key], private.read(), public.read()
+    return None, None, None
@@ -1,9 +0,0 @@
-# remove all keys that end in DEPRECATED
-def strip_deprecated_keys(d):
-  for k in list(d.keys()):
-    if isinstance(k, str):
-      if k.endswith('DEPRECATED'):
-        d.pop(k)
-      elif isinstance(d[k], dict):
-        strip_deprecated_keys(d[k])
-  return d
@@ -1,6 +1,6 @@
 from functools import cache
 import subprocess
-from openpilot.common.run import run_cmd, run_cmd_default
+from openpilot.common.utils import run_cmd, run_cmd_default


@cache
@@ -1 +1 @@
-#define DEFAULT_MODEL "Firehose (Default)"
+#define DEFAULT_MODEL "The Cool People (Default)"
@@ -66,7 +66,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"IsTakingSnapshot", {CLEAR_ON_MANAGER_START, BOOL}},
    {"IsTestedBranch", {CLEAR_ON_MANAGER_START, BOOL}},
    {"JoystickDebugMode", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, BOOL}},
-    {"LanguageSetting", {PERSISTENT | BACKUP, STRING, "main_en"}},
+    {"LanguageSetting", {PERSISTENT | BACKUP, STRING, "en"}},
    {"LastAthenaPingTime", {CLEAR_ON_MANAGER_START, INT}},
    {"LastGPSPosition", {PERSISTENT, STRING}},
    {"LastManagerExitReason", {CLEAR_ON_MANAGER_START, STRING}},
@@ -97,6 +97,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"Offroad_TemperatureTooHigh", {CLEAR_ON_MANAGER_START, JSON}},
    {"Offroad_UnregisteredHardware", {CLEAR_ON_MANAGER_START, JSON}},
    {"Offroad_UpdateFailed", {CLEAR_ON_MANAGER_START, JSON}},
+    {"Offroad_DriverMonitoringUncertain", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, JSON}},
    {"OnroadCycleRequested", {CLEAR_ON_MANAGER_START, BOOL}},
    {"OpenpilotEnabledToggle", {PERSISTENT | BACKUP, BOOL, "1"}},
    {"PandaHeartbeatLost", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, BOOL}},
@@ -108,6 +109,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"RecordFront", {PERSISTENT | BACKUP, BOOL}},
    {"RecordFrontLock", {PERSISTENT, BOOL}},  // for the internal fleet
    {"SecOCKey", {PERSISTENT | DONT_LOG | BACKUP, STRING}},
+    {"ShowDebugInfo", {PERSISTENT, BOOL}},
    {"RouteCount", {PERSISTENT, INT, "0"}},
    {"SnoozeUpdate", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, BOOL}},
    {"SshEnabled", {PERSISTENT | BACKUP, BOOL}},
@@ -260,4 +262,11 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"TorqueParamsOverrideEnabled", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"TorqueParamsOverrideFriction", {PERSISTENT | BACKUP, FLOAT, "0.1"}},
    {"TorqueParamsOverrideLatAccelFactor", {PERSISTENT | BACKUP, FLOAT, "2.5"}},
+
+    // Tuning keys
+    {"EnableHkgTuningAngleSmoothingFactor", {PERSISTENT | BACKUP, BOOL, "1"}},
+    {"HkgTuningAngleMinTorqueReductionGain", {PERSISTENT | BACKUP, INT, "10"}},
+    {"HkgTuningAngleMaxTorqueReductionGain", {PERSISTENT | BACKUP, INT, "100"}},
+    {"HkgTuningAngleActiveTorqueReductionGain", {PERSISTENT | BACKUP, INT, "100"}},
+    {"HkgTuningOverridingCycles", {PERSISTENT | BACKUP, INT, "17"}},
 };
@@ -2,11 +2,10 @@ import numpy as np
 from numbers import Number

 class PIDController:
-  def __init__(self, k_p, k_i, k_f=0., k_d=0., pos_limit=1e308, neg_limit=-1e308, rate=100):
+  def __init__(self, k_p, k_i, k_d=0., pos_limit=1e308, neg_limit=-1e308, rate=100):
    self._k_p = k_p
    self._k_i = k_i
    self._k_d = k_d
-    self.k_f = k_f   # feedforward gain
    if isinstance(self._k_p, Number):
      self._k_p = [[0], [self._k_p]]
    if isinstance(self._k_i, Number):
@@ -16,7 +15,7 @@ class PIDController:

    self.set_limits(pos_limit, neg_limit)

-    self.i_rate = 1.0 / rate
+    self.i_dt = 1.0 / rate
    self.speed = 0.0

    self.reset()
@@ -46,12 +45,12 @@ class PIDController:

  def update(self, error, error_rate=0.0, speed=0.0, feedforward=0., freeze_integrator=False):
    self.speed = speed
-    self.p = float(error) * self.k_p
-    self.f = feedforward * self.k_f
-    self.d = error_rate * self.k_d
+    self.p = self.k_p * float(error)
+    self.d = self.k_d * error_rate
+    self.f = feedforward

    if not freeze_integrator:
-      i = self.i + error * self.k_i * self.i_rate
+      i = self.i + self.k_i * self.i_dt * error

      # Don't allow windup if already clipping
      test_control = self.p + i + self.d + self.f
@@ -1,30 +0,0 @@
-import time
-import functools
-
-from openpilot.common.swaglog import cloudlog
-
-
-def retry(attempts=3, delay=1.0, ignore_failure=False):
-  def decorator(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-      for _ in range(attempts):
-        try:
-          return func(*args, **kwargs)
-        except Exception:
-          cloudlog.exception(f"{func.__name__} failed, trying again")
-          time.sleep(delay)
-
-      if ignore_failure:
-        cloudlog.error(f"{func.__name__} failed after retry")
-      else:
-        raise Exception(f"{func.__name__} failed after retry")
-    return wrapper
-  return decorator
-
-
-if __name__ == "__main__":
-  @retry(attempts=10)
-  def abc():
-    raise ValueError("abc failed :(")
-  abc()
@@ -1,28 +0,0 @@
-import subprocess
-from contextlib import contextmanager
-from subprocess import Popen, PIPE, TimeoutExpired
-
-
-def run_cmd(cmd: list[str], cwd=None, env=None) -> str:
-  return subprocess.check_output(cmd, encoding='utf8', cwd=cwd, env=env).strip()
-
-
-def run_cmd_default(cmd: list[str], default: str = "", cwd=None, env=None) -> str:
-  try:
-    return run_cmd(cmd, cwd=cwd, env=env)
-  except subprocess.CalledProcessError:
-    return default
-
-
-@contextmanager
-def managed_proc(cmd: list[str], env: dict[str, str]):
-  proc = Popen(cmd, env=env, stdout=PIPE, stderr=PIPE)
-  try:
-    yield proc
-  finally:
-    if proc.poll() is None:
-      proc.terminate()
-    try:
-      proc.wait(timeout=5)
-    except TimeoutExpired:
-      proc.kill()
@@ -1,7 +1,7 @@
 import os
 from uuid import uuid4

-from openpilot.common.file_helpers import atomic_write_in_dir
+from openpilot.common.utils import atomic_write_in_dir


 class TestFileHelpers:
@@ -2,9 +2,14 @@ import io
 import os
 import tempfile
 import contextlib
+import subprocess
+import time
+import functools
+from subprocess import Popen, PIPE, TimeoutExpired
 import zstandard as zstd
+from openpilot.common.swaglog import cloudlog

-LOG_COMPRESSION_LEVEL = 10 # little benefit up to level 15. level ~17 is a small step change
+LOG_COMPRESSION_LEVEL = 10  # little benefit up to level 15. level ~17 is a small step change


 class CallbackReader:
@@ -27,7 +32,7 @@ class CallbackReader:


@contextlib.contextmanager
-def atomic_write_in_dir(path: str, mode: str = 'w', buffering: int = -1, encoding: str = None, newline: str = None,
+def atomic_write_in_dir(path: str, mode: str = 'w', buffering: int = -1, encoding: str | None = None, newline: str | None = None,
                        overwrite: bool = False):
  """Write to a file atomically using a temporary file in the same directory as the destination file."""
  dir_name = os.path.dirname(path)
@@ -56,3 +61,58 @@ def get_upload_stream(filepath: str, should_compress: bool) -> tuple[io.Buffered
    compressed_size = compressed_stream.tell()
    compressed_stream.seek(0)
    return compressed_stream, compressed_size
+
+
+# remove all keys that end in DEPRECATED
+def strip_deprecated_keys(d):
+  for k in list(d.keys()):
+    if isinstance(k, str):
+      if k.endswith('DEPRECATED'):
+        d.pop(k)
+      elif isinstance(d[k], dict):
+        strip_deprecated_keys(d[k])
+  return d
+
+
+def run_cmd(cmd: list[str], cwd=None, env=None) -> str:
+  return subprocess.check_output(cmd, encoding='utf8', cwd=cwd, env=env).strip()
+
+
+def run_cmd_default(cmd: list[str], default: str = "", cwd=None, env=None) -> str:
+  try:
+    return run_cmd(cmd, cwd=cwd, env=env)
+  except subprocess.CalledProcessError:
+    return default
+
+
+@contextlib.contextmanager
+def managed_proc(cmd: list[str], env: dict[str, str]):
+  proc = Popen(cmd, env=env, stdout=PIPE, stderr=PIPE)
+  try:
+    yield proc
+  finally:
+    if proc.poll() is None:
+      proc.terminate()
+    try:
+      proc.wait(timeout=5)
+    except TimeoutExpired:
+      proc.kill()
+
+
+def retry(attempts=3, delay=1.0, ignore_failure=False):
+  def decorator(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+      for _ in range(attempts):
+        try:
+          return func(*args, **kwargs)
+        except Exception:
+          cloudlog.exception(f"{func.__name__} failed, trying again")
+          time.sleep(delay)
+
+      if ignore_failure:
+        cloudlog.error(f"{func.__name__} failed after retry")
+      else:
+        raise Exception(f"{func.__name__} failed after retry")
+    return wrapper
+  return decorator
@@ -1 +1 @@
-#define COMMA_VERSION "0.10.1"
+#define COMMA_VERSION "0.10.2"
@@ -1,12 +0,0 @@
-#include <string>
-
-#include "common/watchdog.h"
-#include "common/util.h"
-#include "system/hardware/hw.h"
-
-const std::string watchdog_fn_prefix = Path::shm_path() + "/wd_";  // + <pid>
-
-bool watchdog_kick(uint64_t ts) {
-  static std::string fn = watchdog_fn_prefix + std::to_string(getpid());
-  return util::write_file(fn.c_str(), &ts, sizeof(ts), O_WRONLY | O_CREAT) > 0;
-}
@@ -1,5 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-bool watchdog_kick(uint64_t ts);
@@ -1,22 +0,0 @@
-import os
-import time
-import struct
-from openpilot.system.hardware.hw import Paths
-
-WATCHDOG_FN = f"{Paths.shm_path()}/wd_"
-_LAST_KICK = 0.0
-
-def kick_watchdog():
-  global _LAST_KICK
-  current_time = time.monotonic()
-
-  if current_time - _LAST_KICK < 1.0:
-    return
-
-  try:
-    with open(f"{WATCHDOG_FN}{os.getpid()}", 'wb') as f:
-      f.write(struct.pack('<Q', int(current_time * 1e9)))
-      f.flush()
-    _LAST_KICK = current_time
-  except OSError:
-    pass
@@ -0,0 +1,65 @@
+# CarState signals
+
+## Required for basic lateral control
+
+* `brakePressed`
+* `cruiseState`
+* `doorOpen`
+* `espDisabled`
+* `gasPressed`
+* `gearShifter`
+* `leftBlinker` / `rightBlinker`
+* `seatbeltUnlatched`
+* `standstill`
+* `steeringAngleDeg`
+* `steeringPressed`
+* `steeringTorque`
+* `steerFaultPermanent`
+* `steerFaultTemporary`
+* `vCruise`
+* `wheelSpeeds.[fl|fr|rl|rr]`: Speed of each of the car's four wheels, in m/s. The car's CAN bus often broadcasts the
+speed in kph, so the helper function `parse_wheel_speeds` performs this conversion by default.
+
+## Recommended / Required for openpilot longitudinal control
+
+* `accFaulted`
+* `espActive`
+* `parkingBrake`
+
+## Application Dependent
+
+* `blockPcmEnable`
+* `buttonEnable`
+* `brakeHoldActive`
+* `carFaultedNonCritical`
+* `invalidLkasSetting`
+* `lowSpeedAlert`
+* `regenBraking`
+* `steeringAngleOffsetDeg`
+* `steeringDisengage`
+* `steeringTorqueEps`
+* `stockLkas`
+* `vCruiseCluster`
+* `vEgoCluster`
+* `vehicleSensorsInvalid`
+
+## Automatically populated
+
+* `buttonEvents`
+
+These values are populated automatically by `parse_wheel_speeds`:
+
+* `aEgo`: Acceleration of the ego vehicle, Kalman filtered derivative of `vEgo`.
+* `vEgo`: Speed of the ego vehicle, Kalman filtered from `vEgoRaw`.
+* `vEgoRaw`: Speed of the ego vehicle, based on the average of all four wheel speeds, unfiltered.
+
+## Optional
+
+* `brake`
+* `charging`
+* `fuelGauge`
+* `leftBlindspot` / `rightBlindspot`
+* `steeringRateDeg`
+* `stockAeb`
+* `stockFcw`
+* `yawRate`
@@ -0,0 +1,85 @@
+# Stimulus-Response Tests
+
+These are example test drives that can help identify the CAN bus messaging necessary for ADAS control. Each scripted
+test should be done in a separate route (ignition cycle). These tests are a guide, not necessarily exhaustive.
+
+While testing, constant power to the comma device is highly recommended, using [comma power](https://comma.ai/shop/comma-power) if
+necessary to make sure all test activity is fully captured and for ease of uploading. If constant power isn't
+available, keep the ignition on for at least one minute after your test to make sure power loss doesn't result
+in loss of the last minute of testing data.
+
+## Stationary ignition-only tests, part 1
+
+1. Ignition on, but don't start engine, remain in Park
+2. Open and close each door in a defined order: driver, passenger, rear left, rear right
+3. Re-enter the vehicle, close the driver's door, and fasten the driver's seatbelt
+4. Slowly press and release the accelerator pedal 3 times
+5. Slowly press and release the brake pedal 3 times
+6. Hold the brake and move the gearshift to reverse, then neutral, then drive, then sport/eco/etc if applicable
+7. Return to Park, ignition off
+
+Brake-pressed information may show up in several messages and signals, both as on/off states and as a percentage or
+pressure. It may reflect a switch on the driver's brake pedal, or a pressure-threshold state, or signals to turn on
+the rear brake lights. Start by identifying all the potential signals, and confirm while driving with ACC later.
+
+Locate signals for all four door states if possible, but some cars only expose the driver's door state on the ADAS bus.
+Driver/passenger door signals may or may not change positions for LHD vs RHD cars. For cars where only the driver's
+door signal is available, the same signal may follow the driver.
+
+## Stationary ignition-only tests, part 2
+
+1. Ignition on, but don't start engine, remain in Park
+2. Press each ACC button in a defined order: main switch on/off, set, resume, cancel, accel, decel, gap adjust
+3. Set the left turn signal for about five seconds
+4. Operate the left turn signal one time in its touch-to-pass mode
+5. Set the right turn signal for about five seconds
+6. Operate the right turn signal one time in its touch-to-pass mode
+7. Set the hazard / emergency indicator switch for about five seconds
+8. Ignition off
+
+Your vehicle may have a momentary-press main ACC switch or a physical toggle that remains set. Actual ACC engagement
+isn't necessary for purposes of detecting the ACC button presses.
+
+## Steering angle and steering torque tests
+
+Power steering should be available. On ICE cars, engine RPM may be present.
+
+1. Ignition on, start engine if applicable, remain in Park
+2. Rotate the steering wheel as follows, with a few seconds pause between each step
+   * Start as close to exact center as possible
+   * Turn to 45 degrees right and hold
+   * Turn to 90 degrees right and hold
+   * Turn to 180 degrees right and hold
+   * Turn to full lock right and hold, with firm pressure against lock
+   * Release the wheel and allow it to bounce back slightly from lock
+   * Turn to 180 degrees left and hold
+   * Return to center and release
+3. Ignition off
+
+Performing the full test to the right, followed by an abbreviated test to the left, helps give additional confirmation
+of signal scale, and sign/direction for both the steering wheel angle and driver input torque signals.
+
+## Low speed / parking lot driving tests
+
+Before this test, drive to a place like an empty parking lot where you are free to drive in a series of curves.
+
+1. Ignition on, start engine if applicable, prepare to drive
+2. Slowly (10-20mph at most) drive a figure-8 if possible, or at least one sharp left and one sharp right.
+3. Come to a complete stop
+4. When and where safe, drive in reverse for a short distance (10-15 feet)
+5. Park the car in a safe place, ignition off
+
+## High speed / highway driving tests
+
+Select a place and time where you can safely set cruise control at normal travel speeds with little interference from
+traffic ahead, and safely test the response of your factory lane guidance system.
+
+1. Ignition on, start engine if applicable, prepare to drive
+2. When safely able, engage adaptive cruise control below 50 mph
+3. When safely able, use the ACC buttons to accelerate to 50mph, then 55mph, then 60mph
+4. Disengage adaptive cruise
+5. When safely able, allow your factory lane guidance to prevent lane departures, 2-3 times on both the left and right
+
+The series of setpoints can be adjusted to local traffic regulations, and of course metric units. The specific cruise
+setpoints are useful for locating the ACC HUD signals later, and confirming their precise scaling. When the car reaches
+and holds the setpoint, that can also provide additional confirmation of wheel speed scaling.
@@ -6,8 +6,17 @@ export NUMEXPR_NUM_THREADS=1
 export OPENBLAS_NUM_THREADS=1
 export VECLIB_MAXIMUM_THREADS=1

+# models get lower priority than ui
+# - ui is ~5ms
+# - modeld is 20ms
+# - DM is 10ms
+# in order to run ui at 60fps (16.67ms), we need to allow
+# it to preempt the model workloads. we have enough
+# headroom for this until ui is moved to the CPU.
+export QCOM_PRIORITY=12
+
 if [ -z "$AGNOS_VERSION" ]; then
-  export AGNOS_VERSION="13.1"
+  export AGNOS_VERSION="15"
 fi

 export STAGING_ROOT="/data/safe_staging"
@@ -23,7 +23,7 @@ dependencies = [
  # core
  "cffi",
  "scons",
-  "pycapnp",
+  "pycapnp==2.1.0",
  "Cython",
  "setuptools",
  "numpy >=2.0",
@@ -72,7 +72,9 @@ dependencies = [
  "zstandard",

  # ui
+  "raylib < 5.5.0.3", # TODO: unpin when they fix https://github.com/electronstudio/raylib-python-cffi/issues/186
  "qrcode",
+  "mapbox-earcut",
 ]

 [project.optional-dependencies]
@@ -119,7 +121,6 @@ dev = [
  "tabulate",
  "types-requests",
  "types-tabulate",
-  "raylib",
 ]

 tools = [
@@ -177,7 +178,7 @@ quiet-level = 3
 # if you've got a short variable name that's getting flagged, add it here
 ignore-words-list = "bu,ro,te,ue,alo,hda,ois,nam,nams,ned,som,parm,setts,inout,warmup,bumb,nd,sie,preints,whit,indexIn,ws,uint,grey,deque,stdio,amin,BA,LITE,atEnd,UIs,errorString,arange,FocusIn,od,tim,relA,hist,copyable,jupyter,thead,TGE,abl,lite"
 builtin = "clear,rare,informal,code,names,en-GB_to_en-US"
-skip = "./third_party/*, ./tinygrad/*, ./tinygrad_repo/*, ./msgq/*, ./panda/*, ./opendbc/*, ./opendbc_repo/*, ./rednose/*, ./rednose_repo/*, ./teleoprtc/*, ./teleoprtc_repo/*, *.ts, uv.lock, *.onnx, ./cereal/gen/*, */c_generated_code/*, docs/assets/*, tools/plotjuggler/layouts/*"
+skip = "./third_party/*, ./tinygrad/*, ./tinygrad_repo/*, ./msgq/*, ./panda/*, ./opendbc/*, ./opendbc_repo/*, ./rednose/*, ./rednose_repo/*, ./teleoprtc/*, ./teleoprtc_repo/*, *.po, uv.lock, *.onnx, ./cereal/gen/*, */c_generated_code/*, docs/assets/*, tools/plotjuggler/layouts/*"

 [tool.mypy]
 python_version = "3.11"
@@ -235,7 +236,6 @@ lint.ignore = [
  "B027",
  "B024",
  "NPY002",  # new numpy random syntax is worse
-  "UP038",   # (x, y) -> x|y for isinstance
 ]
 line-length = 160
 target-version ="py311"
@@ -263,8 +263,13 @@ lint.flake8-implicit-str-concat.allow-multiline = false
 "tools".msg = "Use openpilot.tools"
 "pytest.main".msg = "pytest.main requires special handling that is easy to mess up!"
 "unittest".msg = "Use pytest"
-"pyray.measure_text_ex".msg = "Use openpilot.system.ui.lib.text_measure"
 "time.time".msg = "Use time.monotonic"

+# raylib banned APIs
+"pyray.measure_text_ex".msg = "Use openpilot.system.ui.lib.text_measure"
+"pyray.is_mouse_button_pressed".msg = "This can miss events. Use Widget._handle_mouse_press"
+"pyray.is_mouse_button_released".msg = "This can miss events. Use Widget._handle_mouse_release"
+"pyray.draw_text".msg = "Use a function (such as rl.draw_font_ex) that takes font as an argument"
+
 [tool.ruff.format]
 quote-style = "preserve"
@@ -12,7 +12,7 @@ from openpilot.common.basedir import BASEDIR


 DIRS = ['cereal', 'openpilot']
-EXTS = ['.png', '.py', '.ttf', '.capnp']
+EXTS = ['.png', '.py', '.ttf', '.capnp', '.json', '.fnt', '.mo']
 INTERPRETER = '/usr/bin/env python3'


@@ -13,7 +13,7 @@ cd $ROOT

 FAILED=0

-IGNORED_FILES="uv\.lock|docs\/CARS.md|LICENSE\.md"
+IGNORED_FILES="uv\.lock|docs\/CARS.md|LICENSE\.md|layouts\/.*\.xml|.*\.ipynb"
 IGNORED_DIRS="^third_party.*|^msgq.*|^msgq_repo.*|^opendbc.*|^opendbc_repo.*|^cereal.*|^panda.*|^rednose.*|^rednose_repo.*|^tinygrad.*|^tinygrad_repo.*|^teleoprtc.*|^teleoprtc_repo.*"

 function run() {
@@ -3,4 +3,4 @@ SConscript(['controls/lib/lateral_mpc_lib/SConscript'])
 SConscript(['controls/lib/longitudinal_mpc_lib/SConscript'])
 SConscript(['locationd/SConscript'])
 SConscript(['modeld/SConscript'])
-SConscript(['ui/SConscript'])
+SConscript(['ui/SConscript'])
@@ -1,2 +1,4 @@
 *.cc
+fonts/*.fnt
+fonts/*.png
 translations_assets.qrc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93cdc4ee9aa40e2afceecc63da0ca05ec7aab4bec991ece51a6b52389f48a477
+size 10788068
@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+from pathlib import Path
+import json
+
+import pyray as rl
+
+FONT_DIR = Path(__file__).resolve().parent
+SELFDRIVE_DIR = FONT_DIR.parents[1]
+TRANSLATIONS_DIR = SELFDRIVE_DIR / "ui" / "translations"
+LANGUAGES_FILE = TRANSLATIONS_DIR / "languages.json"
+
+GLYPH_PADDING = 6
+EXTRA_CHARS = "–‑✓×°§•€£¥"
+UNIFONT_LANGUAGES = {"ar", "th", "zh-CHT", "zh-CHS", "ko", "ja"}
+
+
+def _languages():
+  if not LANGUAGES_FILE.exists():
+    return {}
+  with LANGUAGES_FILE.open(encoding="utf-8") as f:
+    return json.load(f)
+
+
+def _char_sets():
+  base = set(map(chr, range(32, 127))) | set(EXTRA_CHARS)
+  unifont = set(base)
+
+  for language, code in _languages().items():
+    unifont.update(language)
+    po_path = TRANSLATIONS_DIR / f"app_{code}.po"
+    try:
+      chars = set(po_path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+      continue
+    (unifont if code in UNIFONT_LANGUAGES else base).update(chars)
+
+  return tuple(sorted(ord(c) for c in base)), tuple(sorted(ord(c) for c in unifont))
+
+
+def _glyph_metrics(glyphs, rects, codepoints):
+  entries = []
+  min_offset_y, max_extent = None, 0
+  for idx, codepoint in enumerate(codepoints):
+    glyph = glyphs[idx]
+    rect = rects[idx]
+    width = int(round(rect.width))
+    height = int(round(rect.height))
+    offset_y = int(round(glyph.offsetY))
+    min_offset_y = offset_y if min_offset_y is None else min(min_offset_y, offset_y)
+    max_extent = max(max_extent, offset_y + height)
+    entries.append({
+      "id": codepoint,
+      "x": int(round(rect.x)),
+      "y": int(round(rect.y)),
+      "width": width,
+      "height": height,
+      "xoffset": int(round(glyph.offsetX)),
+      "yoffset": offset_y,
+      "xadvance": int(round(glyph.advanceX)),
+    })
+
+  if min_offset_y is None:
+    raise RuntimeError("No glyphs were generated")
+
+  line_height = int(round(max_extent - min_offset_y))
+  base = int(round(max_extent))
+  return entries, line_height, base
+
+
+def _write_bmfont(path: Path, font_size: int, face: str, atlas_name: str, line_height: int, base: int, atlas_size, entries):
+  lines = [
+    f"info face=\"{face}\" size=-{font_size} bold=0 italic=0 charset=\"\" unicode=1 stretchH=100 smooth=0 aa=1 padding=0,0,0,0 spacing=0,0 outline=0",
+    f"common lineHeight={line_height} base={base} scaleW={atlas_size[0]} scaleH={atlas_size[1]} pages=1 packed=0 alphaChnl=0 redChnl=4 greenChnl=4 blueChnl=4",
+    f"page id=0 file=\"{atlas_name}\"",
+    f"chars count={len(entries)}",
+  ]
+  for entry in entries:
+    lines.append(
+      ("char id={id:<4} x={x:<5} y={y:<5} width={width:<5} height={height:<5} " +
+       "xoffset={xoffset:<5} yoffset={yoffset:<5} xadvance={xadvance:<5} page=0  chnl=15").format(**entry)
+    )
+  path.write_text("\n".join(lines) + "\n")
+
+
+def _process_font(font_path: Path, codepoints: tuple[int, ...]):
+  print(f"Processing {font_path.name}...")
+
+  font_size = {
+    "unifont.otf": 16,  # unifont is only 16x8 or 16x16 pixels per glyph
+  }.get(font_path.name, 200)
+
+  data = font_path.read_bytes()
+  file_buf = rl.ffi.new("unsigned char[]", data)
+  cp_buffer = rl.ffi.new("int[]", codepoints)
+  cp_ptr = rl.ffi.cast("int *", cp_buffer)
+  glyphs = rl.load_font_data(rl.ffi.cast("unsigned char *", file_buf), len(data), font_size, cp_ptr, len(codepoints), rl.FontType.FONT_DEFAULT)
+  if glyphs == rl.ffi.NULL:
+    raise RuntimeError("raylib failed to load font data")
+
+  rects_ptr = rl.ffi.new("Rectangle **")
+  image = rl.gen_image_font_atlas(glyphs, rects_ptr, len(codepoints), font_size, GLYPH_PADDING, 0)
+  if image.width == 0 or image.height == 0:
+    raise RuntimeError("raylib returned an empty atlas")
+
+  rects = rects_ptr[0]
+  atlas_name = f"{font_path.stem}.png"
+  atlas_path = FONT_DIR / atlas_name
+  entries, line_height, base = _glyph_metrics(glyphs, rects, codepoints)
+
+  if not rl.export_image(image, atlas_path.as_posix()):
+    raise RuntimeError("Failed to export atlas image")
+
+  _write_bmfont(FONT_DIR / f"{font_path.stem}.fnt", font_size, font_path.stem, atlas_name, line_height, base, (image.width, image.height), entries)
+
+
+def main():
+  base_cp, unifont_cp = _char_sets()
+  fonts = sorted(FONT_DIR.glob("*.ttf")) + sorted(FONT_DIR.glob("*.otf"))
+  for font in fonts:
+    if "emoji" in font.name.lower():
+      continue
+    glyphs = unifont_cp if font.stem.lower().startswith("unifont") else base_cp
+    _process_font(font, glyphs)
+  return 0
+
+
+if __name__ == "__main__":
+  raise SystemExit(main())
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9712a9bc089af7ddc06e0826aa84f2ee23ed2f1a1dddaf2a89c2483e753a8475
+size 5321484
@@ -62,8 +62,8 @@ class TestCarInterfaces:
    #  hypothesis also slows down significantly with just one more message draw
    LongControl(car_params, car_params_sp)
    if car_params.steerControlType == CarParams.SteerControlType.angle:
-      LatControlAngle(car_params, car_params_sp, car_interface)
+      LatControlAngle(car_params, car_params_sp, car_interface, DT_CTRL)
    elif car_params.lateralTuning.which() == 'pid':
-      LatControlPID(car_params, car_params_sp, car_interface)
+      LatControlPID(car_params, car_params_sp, car_interface, DT_CTRL)
    elif car_params.lateralTuning.which() == 'torque':
-      LatControlTorque(car_params, car_params_sp, car_interface)
+      LatControlTorque(car_params, car_params_sp, car_interface, DT_CTRL)
@@ -189,7 +189,7 @@ class TestCarModelBase(unittest.TestCase):
      if tuning == 'pid':
        self.assertTrue(len(self.CP.lateralTuning.pid.kpV))
      elif tuning == 'torque':
-        self.assertTrue(self.CP.lateralTuning.torque.kf > 0)
+        self.assertTrue(self.CP.lateralTuning.torque.latAccelFactor > 0)
      else:
        raise Exception("unknown tuning")

@@ -8,7 +8,7 @@ from cereal import car, log
 import cereal.messaging as messaging
 from openpilot.common.constants import CV
 from openpilot.common.params import Params
-from openpilot.common.realtime import config_realtime_process, Priority, Ratekeeper
+from openpilot.common.realtime import config_realtime_process, DT_CTRL, Priority, Ratekeeper
 from openpilot.common.swaglog import cloudlog

 from opendbc.car.car_helpers import interfaces
@@ -19,6 +19,7 @@ from openpilot.selfdrive.controls.lib.latcontrol_pid import LatControlPID
 from openpilot.selfdrive.controls.lib.latcontrol_angle import LatControlAngle, STEER_ANGLE_SATURATION_THRESHOLD
 from openpilot.selfdrive.controls.lib.latcontrol_torque import LatControlTorque
 from openpilot.selfdrive.controls.lib.longcontrol import LongControl
+from openpilot.selfdrive.modeld.modeld import LAT_SMOOTH_SECONDS
 from openpilot.selfdrive.locationd.helpers import PoseCalibrator, Pose

 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
@@ -45,7 +46,7 @@ class Controls(ControlsExt, ModelStateBase):

    self.CI = interfaces[self.CP.carFingerprint](self.CP, self.CP_SP)

-    self.sm = messaging.SubMaster(['liveParameters', 'liveTorqueParameters', 'modelV2', 'selfdriveState',
+    self.sm = messaging.SubMaster(['liveDelay', 'liveParameters', 'liveTorqueParameters', 'modelV2', 'selfdriveState',
                                   'liveCalibration', 'livePose', 'longitudinalPlan', 'carState', 'carOutput',
                                   'driverMonitoringState', 'onroadEvents', 'driverAssistance', 'liveDelay'] + self.sm_services_ext,
                                  poll='selfdriveState')
@@ -62,11 +63,11 @@ class Controls(ControlsExt, ModelStateBase):
    self.VM = VehicleModel(self.CP)
    self.LaC: LatControl
    if self.CP.steerControlType == car.CarParams.SteerControlType.angle:
-      self.LaC = LatControlAngle(self.CP, self.CP_SP, self.CI)
+      self.LaC = LatControlAngle(self.CP, self.CP_SP, self.CI, DT_CTRL)
    elif self.CP.lateralTuning.which() == 'pid':
-      self.LaC = LatControlPID(self.CP, self.CP_SP, self.CI)
+      self.LaC = LatControlPID(self.CP, self.CP_SP, self.CI, DT_CTRL)
    elif self.CP.lateralTuning.which() == 'torque':
-      self.LaC = LatControlTorque(self.CP, self.CP_SP, self.CI)
+      self.LaC = LatControlTorque(self.CP, self.CP_SP, self.CI, DT_CTRL)

  def update(self):
    self.sm.update(15)
@@ -139,11 +140,12 @@ class Controls(ControlsExt, ModelStateBase):
    # Reset desired curvature to current to avoid violating the limits on engage
    new_desired_curvature = model_v2.action.desiredCurvature if CC.latActive else self.curvature
    self.desired_curvature, curvature_limited = clip_curvature(CS.vEgo, self.desired_curvature, new_desired_curvature, lp.roll)
+    lat_delay = self.sm["liveDelay"].lateralDelay + LAT_SMOOTH_SECONDS

    actuators.curvature = self.desired_curvature
    steer, steeringAngleDeg, lac_log = self.LaC.update(CC.latActive, CS, self.VM, lp,
                                                       self.steer_limited_by_safety, self.desired_curvature,
-                                                       self.calibrated_pose, curvature_limited)  # TODO what if not available
+                                                       self.calibrated_pose, curvature_limited, lat_delay)
    actuators.torque = float(steer)
    actuators.steeringAngleDeg = float(steeringAngleDeg)
    # Ensure no NaNs/Infs
@@ -22,7 +22,7 @@ def smooth_value(val, prev_val, tau, dt=DT_MDL):
  alpha = 1 - np.exp(-dt/tau) if tau > 0 else 1
  return alpha * val + (1 - alpha) * prev_val

-def clip_curvature(v_ego, prev_curvature, new_curvature, roll):
+def clip_curvature(v_ego, prev_curvature, new_curvature, roll) -> tuple[float, bool]:
  # This function respects ISO lateral jerk and acceleration limits + a max curvature
  v_ego = max(v_ego, MIN_SPEED)
  max_curvature_rate = MAX_LATERAL_JERK / (v_ego ** 2)  # inexact calculation, check https://github.com/commaai/openpilot/pull/24755
@@ -1,31 +1,31 @@
 import numpy as np
 from abc import abstractmethod, ABC
-
-from openpilot.common.realtime import DT_CTRL
+from openpilot.selfdrive.locationd.helpers import Pose


 class LatControl(ABC):
-  def __init__(self, CP, CP_SP, CI):
-    self.sat_count_rate = 1.0 * DT_CTRL
+  def __init__(self, CP, CP_SP, CI, dt):
+    self.dt = dt
    self.sat_limit = CP.steerLimitTimer
-    self.sat_count = 0.
+    self.sat_time = 0.
    self.sat_check_min_speed = 10.

    # we define the steer torque scale as [-1.0...1.0]
    self.steer_max = 1.0

  @abstractmethod
-  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited):
+  def update(self, active: bool, CS, VM, params, steer_limited_by_safety: bool, desired_curvature: float, calibrated_pose: Pose,
+             curvature_limited: bool, lat_delay: float):
    pass

  def reset(self):
-    self.sat_count = 0.
+    self.sat_time = 0.

  def _check_saturation(self, saturated, CS, steer_limited_by_safety, curvature_limited):
    # Saturated only if control output is not being limited by car torque/angle rate limits
    if (saturated or curvature_limited) and CS.vEgo > self.sat_check_min_speed and not steer_limited_by_safety and not CS.steeringPressed:
-      self.sat_count += self.sat_count_rate
+      self.sat_time += self.dt
    else:
-      self.sat_count -= self.sat_count_rate
-    self.sat_count = np.clip(self.sat_count, 0.0, self.sat_limit)
-    return self.sat_count > (self.sat_limit - 1e-3)
+      self.sat_time -= self.dt
+    self.sat_time = np.clip(self.sat_time, 0.0, self.sat_limit)
+    return self.sat_time > (self.sat_limit - 1e-3)
@@ -8,12 +8,12 @@ STEER_ANGLE_SATURATION_THRESHOLD = 2.5  # Degrees


 class LatControlAngle(LatControl):
-  def __init__(self, CP, CP_SP, CI):
-    super().__init__(CP, CP_SP, CI)
+  def __init__(self, CP, CP_SP, CI, dt):
+    super().__init__(CP, CP_SP, CI, dt)
    self.sat_check_min_speed = 5.
    self.use_steer_limited_by_safety = CP.brand == "tesla"

-  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited):
+  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited, lat_delay):
    angle_log = log.ControlsState.LateralAngleState.new_message()

    if not active:
@@ -6,14 +6,15 @@ from openpilot.common.pid import PIDController


 class LatControlPID(LatControl):
-  def __init__(self, CP, CP_SP, CI):
-    super().__init__(CP, CP_SP, CI)
+  def __init__(self, CP, CP_SP, CI, dt):
+    super().__init__(CP, CP_SP, CI, dt)
    self.pid = PIDController((CP.lateralTuning.pid.kpBP, CP.lateralTuning.pid.kpV),
                             (CP.lateralTuning.pid.kiBP, CP.lateralTuning.pid.kiV),
-                             k_f=CP.lateralTuning.pid.kf, pos_limit=self.steer_max, neg_limit=-self.steer_max)
+                             pos_limit=self.steer_max, neg_limit=-self.steer_max)
+    self.ff_factor = CP.lateralTuning.pid.kf
    self.get_steer_feedforward = CI.get_steer_feedforward_function()

-  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited):
+  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited, lat_delay):
    pid_log = log.ControlsState.LateralPIDState.new_message()
    pid_log.steeringAngleDeg = float(CS.steeringAngleDeg)
    pid_log.steeringRateDeg = float(CS.steeringRateDeg)
@@ -30,7 +31,7 @@ class LatControlPID(LatControl):

    else:
      # offset does not contribute to resistive torque
-      ff = self.get_steer_feedforward(angle_steers_des_no_offset, CS.vEgo)
+      ff = self.ff_factor * self.get_steer_feedforward(angle_steers_des_no_offset, CS.vEgo)
      freeze_integrator = steer_limited_by_safety or CS.steeringPressed or CS.vEgo < 5

      output_torque = self.pid.update(error,
@@ -1,9 +1,11 @@
 import math
 import numpy as np
+from collections import deque

 from cereal import log
 from opendbc.car.lateral import FRICTION_THRESHOLD, get_friction
 from openpilot.common.constants import ACCELERATION_DUE_TO_GRAVITY
+from openpilot.common.filter_simple import FirstOrderFilter
 from openpilot.selfdrive.controls.lib.latcontrol import LatControl
 from openpilot.common.pid import PIDController

@@ -15,25 +17,34 @@ from openpilot.sunnypilot.selfdrive.controls.lib.latcontrol_torque_ext import La
 # wheel slip, or to speed.

 # This controller applies torque to achieve desired lateral
-# accelerations. To compensate for the low speed effects we
-# use a LOW_SPEED_FACTOR in the error. Additionally, there is
-# friction in the steering wheel that needs to be overcome to
-# move it at all, this is compensated for too.
+# accelerations. To compensate for the low speed effects the
+# proportional gain is increased at low speeds by the PID controller.
+# Additionally, there is friction in the steering wheel that needs
+# to be overcome to move it at all, this is compensated for too.

-LOW_SPEED_X = [0, 10, 20, 30]
-LOW_SPEED_Y = [15, 13, 10, 5]
+KP = 1.0
+KI = 0.3
+KD = 0.0
+INTERP_SPEEDS = [1, 1.5, 2.0, 3.0, 5, 7.5, 10, 15, 30]
+KP_INTERP = [250, 120, 65, 30, 11.5, 5.5, 3.5, 2.0, KP]

+LP_FILTER_CUTOFF_HZ = 1.2
+LAT_ACCEL_REQUEST_BUFFER_SECONDS = 1.0
+VERSION = 0

 class LatControlTorque(LatControl):
-  def __init__(self, CP, CP_SP, CI):
-    super().__init__(CP, CP_SP, CI)
+  def __init__(self, CP, CP_SP, CI, dt):
+    super().__init__(CP, CP_SP, CI, dt)
    self.torque_params = CP.lateralTuning.torque.as_builder()
    self.torque_from_lateral_accel = CI.torque_from_lateral_accel()
    self.lateral_accel_from_torque = CI.lateral_accel_from_torque()
-    self.pid = PIDController(self.torque_params.kp, self.torque_params.ki,
-                             k_f=self.torque_params.kf)
+    self.pid = PIDController([INTERP_SPEEDS, KP_INTERP], KI, KD, rate=1/self.dt)
    self.update_limits()
    self.steering_angle_deadzone_deg = self.torque_params.steeringAngleDeadzoneDeg
+    self.lat_accel_request_buffer_len = int(LAT_ACCEL_REQUEST_BUFFER_SECONDS / self.dt)
+    self.lat_accel_request_buffer = deque([0.] * self.lat_accel_request_buffer_len , maxlen=self.lat_accel_request_buffer_len)
+    self.previous_measurement = 0.0
+    self.measurement_rate_filter = FirstOrderFilter(0.0, 1 / (2 * np.pi * LP_FILTER_CUTOFF_HZ), self.dt)

    self.extension = LatControlTorqueExt(self, CP, CP_SP, CI)

@@ -47,57 +58,68 @@ class LatControlTorque(LatControl):
    self.pid.set_limits(self.lateral_accel_from_torque(self.steer_max, self.torque_params),
                        self.lateral_accel_from_torque(-self.steer_max, self.torque_params))

-  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited):
+  def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, calibrated_pose, curvature_limited, lat_delay):
    # Override torque params from extension
    if self.extension.update_override_torque_params(self.torque_params):
      self.update_limits()

    pid_log = log.ControlsState.LateralTorqueState.new_message()
+    pid_log.version = VERSION
    if not active:
      output_torque = 0.0
      pid_log.active = False
    else:
-      actual_curvature = -VM.calc_curvature(math.radians(CS.steeringAngleDeg - params.angleOffsetDeg), CS.vEgo, params.roll)
+      measured_curvature = -VM.calc_curvature(math.radians(CS.steeringAngleDeg - params.angleOffsetDeg), CS.vEgo, params.roll)
      roll_compensation = params.roll * ACCELERATION_DUE_TO_GRAVITY
      curvature_deadzone = abs(VM.calc_curvature(math.radians(self.steering_angle_deadzone_deg), CS.vEgo, 0.0))
-
-      desired_lateral_accel = desired_curvature * CS.vEgo ** 2
-      actual_lateral_accel = actual_curvature * CS.vEgo ** 2
      lateral_accel_deadzone = curvature_deadzone * CS.vEgo ** 2

-      low_speed_factor = np.interp(CS.vEgo, LOW_SPEED_X, LOW_SPEED_Y)**2
-      setpoint = desired_lateral_accel + low_speed_factor * desired_curvature
-      measurement = actual_lateral_accel + low_speed_factor * actual_curvature
-      gravity_adjusted_lateral_accel = desired_lateral_accel - roll_compensation
+      delay_frames = int(np.clip(lat_delay / self.dt, 1, self.lat_accel_request_buffer_len))
+      expected_lateral_accel = self.lat_accel_request_buffer[-delay_frames]
+      # TODO factor out lateral jerk from error to later replace it with delay independent alternative
+      future_desired_lateral_accel = desired_curvature * CS.vEgo ** 2
+      self.lat_accel_request_buffer.append(future_desired_lateral_accel)
+      gravity_adjusted_future_lateral_accel = future_desired_lateral_accel - roll_compensation
+      desired_lateral_jerk = (future_desired_lateral_accel - expected_lateral_accel) / lat_delay
+
+      measurement = measured_curvature * CS.vEgo ** 2
+      measurement_rate = self.measurement_rate_filter.update((measurement - self.previous_measurement) / self.dt)
+      self.previous_measurement = measurement
+
+      setpoint = lat_delay * desired_lateral_jerk + expected_lateral_accel
+      error = setpoint - measurement

      # do error correction in lateral acceleration space, convert at end to handle non-linear torque responses correctly
-      pid_log.error = float(setpoint - measurement)
-      ff = gravity_adjusted_lateral_accel
+      pid_log.error = float(error)
+      ff = gravity_adjusted_future_lateral_accel
      # latAccelOffset corrects roll compensation bias from device roll misalignment relative to car roll
      ff -= self.torque_params.latAccelOffset
-      ff += get_friction(desired_lateral_accel - actual_lateral_accel, lateral_accel_deadzone, FRICTION_THRESHOLD, self.torque_params)
+      # TODO jerk is weighted by lat_delay for legacy reasons, but should be made independent of it
+      ff += get_friction(error, lateral_accel_deadzone, FRICTION_THRESHOLD, self.torque_params)

      freeze_integrator = steer_limited_by_safety or CS.steeringPressed or CS.vEgo < 5
      output_lataccel = self.pid.update(pid_log.error,
-                                      feedforward=ff,
-                                      speed=CS.vEgo,
-                                      freeze_integrator=freeze_integrator)
+                                       -measurement_rate,
+                                        feedforward=ff,
+                                        speed=CS.vEgo,
+                                        freeze_integrator=freeze_integrator)
      output_torque = self.torque_from_lateral_accel(output_lataccel, self.torque_params)

      # Lateral acceleration torque controller extension updates
      # Overrides pid_log.error and output_torque
      pid_log, output_torque = self.extension.update(CS, VM, self.pid, params, ff, pid_log, setpoint, measurement, calibrated_pose, roll_compensation,
-                                                     desired_lateral_accel, actual_lateral_accel, lateral_accel_deadzone, gravity_adjusted_lateral_accel,
-                                                     desired_curvature, actual_curvature, steer_limited_by_safety, output_torque)
+                                                     future_desired_lateral_accel, measurement, lateral_accel_deadzone, gravity_adjusted_future_lateral_accel,
+                                                     desired_curvature, measured_curvature, steer_limited_by_safety, output_torque)

      pid_log.active = True
      pid_log.p = float(self.pid.p)
      pid_log.i = float(self.pid.i)
      pid_log.d = float(self.pid.d)
      pid_log.f = float(self.pid.f)
-      pid_log.output = float(-output_torque)  # TODO: log lat accel?
-      pid_log.actualLateralAccel = float(actual_lateral_accel)
-      pid_log.desiredLateralAccel = float(desired_lateral_accel)
+      pid_log.output = float(-output_torque) # TODO: log lat accel?
+      pid_log.actualLateralAccel = float(measurement)
+      pid_log.desiredLateralAccel = float(setpoint)
+      pid_log.desiredLateralJerk = float(desired_lateral_jerk)
      pid_log.saturated = bool(self._check_saturation(self.steer_max - abs(output_torque) < 1e-3, CS, steer_limited_by_safety, curvature_limited))

    # TODO left is positive in this convention
@@ -54,7 +54,7 @@ class LongControl:
    self.long_control_state = LongCtrlState.off
    self.pid = PIDController((CP.longitudinalTuning.kpBP, CP.longitudinalTuning.kpV),
                             (CP.longitudinalTuning.kiBP, CP.longitudinalTuning.kiV),
-                             k_f=CP.longitudinalTuning.kf, rate=1 / DT_CTRL)
+                             rate=1 / DT_CTRL)
    self.last_output_accel = 0.0

  def reset(self):
@@ -7,6 +7,7 @@ from opendbc.car.toyota.values import CAR as TOYOTA
 from opendbc.car.nissan.values import CAR as NISSAN
 from opendbc.car.gm.values import CAR as GM
 from opendbc.car.vehicle_model import VehicleModel
+from openpilot.common.realtime import DT_CTRL
 from openpilot.selfdrive.car.helpers import convert_to_capnp
 from openpilot.selfdrive.controls.lib.latcontrol_pid import LatControlPID
 from openpilot.selfdrive.controls.lib.latcontrol_torque import LatControlTorque
@@ -29,7 +30,7 @@ class TestLatControl:
    CP_SP = convert_to_capnp(CP_SP)
    VM = VehicleModel(CP)

-    controller = controller(CP.as_reader(), CP_SP.as_reader(), CI)
+    controller = controller(CP.as_reader(), CP_SP.as_reader(), CI, DT_CTRL)

    CS = car.CarState.new_message()
    CS.vEgo = 30
@@ -42,13 +43,13 @@ class TestLatControl:

    # Saturate for curvature limited and controller limited
    for _ in range(1000):
-      _, _, lac_log = controller.update(True, CS, VM, params, False, 0, pose, True)
+      _, _, lac_log = controller.update(True, CS, VM, params, False, 0, pose, True, 0.2)
    assert lac_log.saturated

    for _ in range(1000):
-      _, _, lac_log = controller.update(True, CS, VM, params, False, 0, pose, False)
+      _, _, lac_log = controller.update(True, CS, VM, params, False, 0, pose, False, 0.2)
    assert not lac_log.saturated

    for _ in range(1000):
-      _, _, lac_log = controller.update(True, CS, VM, params, False, 1, pose, False)
+      _, _, lac_log = controller.update(True, CS, VM, params, False, 1, pose, False, 0.2)
    assert lac_log.saturated
@@ -6,7 +6,7 @@ from collections import defaultdict
 import matplotlib.pyplot as plt

 from cereal.services import SERVICE_LIST
-from openpilot.common.file_helpers import LOG_COMPRESSION_LEVEL
+from openpilot.common.utils import LOG_COMPRESSION_LEVEL
 from openpilot.tools.lib.logreader import LogReader
 from tqdm import tqdm

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+import os
 import numpy as np
 from collections import deque, defaultdict

@@ -250,6 +251,8 @@ class TorqueEstimator(ParameterEstimator, TorqueEstimatorExt):
 def main(demo=False):
  config_realtime_process([0, 1, 2, 3], 5)

+  DEBUG = bool(int(os.getenv("DEBUG", "0")))
+
  pm = messaging.PubMaster(['liveTorqueParameters'])
  sm = messaging.SubMaster(['carControl', 'carOutput', 'carState', 'liveCalibration', 'livePose', 'liveDelay'], poll='livePose')

@@ -268,7 +271,7 @@ def main(demo=False):

    # 4Hz driven by livePose
    if sm.frame % 5 == 0:
-      pm.send('liveTorqueParameters', estimator.get_msg(valid=sm.all_checks()))
+      pm.send('liveTorqueParameters', estimator.get_msg(valid=sm.all_checks(), with_points=DEBUG))

    # Cache points every 60 seconds while onroad
    if sm.frame % 240 == 0:
@@ -1,11 +1,11 @@
 import os
 import glob

-Import('env', 'envCython', 'arch', 'cereal', 'messaging', 'common', 'gpucommon', 'visionipc', 'transformations')
+Import('env', 'envCython', 'arch', 'cereal', 'messaging', 'common', 'visionipc', 'transformations')
 lenv = env.Clone()
 lenvCython = envCython.Clone()

-libs = [cereal, messaging, visionipc, gpucommon, common, 'capnp', 'kj', 'pthread']
+libs = [cereal, messaging, visionipc, common, 'capnp', 'kj', 'pthread']
 frameworks = []

 common_src = [
@@ -25,13 +25,13 @@ from openpilot.selfdrive.modeld.runners.tinygrad_helpers import qcom_tensor_from
 MODEL_WIDTH, MODEL_HEIGHT = DM_INPUT_SIZE
 CALIB_LEN = 3
 FEATURE_LEN = 512
-OUTPUT_SIZE = 84 + FEATURE_LEN
+OUTPUT_SIZE = 83 + FEATURE_LEN

 PROCESS_NAME = "selfdrive.modeld.dmonitoringmodeld"
 SEND_RAW_PRED = os.getenv('SEND_RAW_PRED')
 MODEL_PKL_PATH = Path(__file__).parent / 'models/dmonitoring_model_tinygrad.pkl'

-
+# TODO: slice from meta
 class DriverStateResult(ctypes.Structure):
  _fields_ = [
    ("face_orientation", ctypes.c_float*3),
@@ -46,8 +46,8 @@ class DriverStateResult(ctypes.Structure):
    ("left_blink_prob", ctypes.c_float),
    ("right_blink_prob", ctypes.c_float),
    ("sunglasses_prob", ctypes.c_float),
-    ("occluded_prob", ctypes.c_float),
-    ("ready_prob", ctypes.c_float*4),
+    ("_unused_c", ctypes.c_float),
+    ("_unused_d", ctypes.c_float*4),
    ("not_ready_prob", ctypes.c_float*2)]


@@ -55,7 +55,6 @@ class DMonitoringModelResult(ctypes.Structure):
  _fields_ = [
    ("driver_state_lhd", DriverStateResult),
    ("driver_state_rhd", DriverStateResult),
-    ("poor_vision_prob", ctypes.c_float),
    ("wheel_on_right_prob", ctypes.c_float),
    ("features", ctypes.c_float*FEATURE_LEN)]

@@ -107,8 +106,6 @@ def fill_driver_state(msg, ds_result: DriverStateResult):
  msg.leftBlinkProb = float(sigmoid(ds_result.left_blink_prob))
  msg.rightBlinkProb = float(sigmoid(ds_result.right_blink_prob))
  msg.sunglassesProb = float(sigmoid(ds_result.sunglasses_prob))
-  msg.occludedProb = float(sigmoid(ds_result.occluded_prob))
-  msg.readyProb = [float(sigmoid(x)) for x in ds_result.ready_prob]
  msg.notReadyProb = [float(sigmoid(x)) for x in ds_result.not_ready_prob]


@@ -119,7 +116,6 @@ def get_driverstate_packet(model_output: np.ndarray, frame_id: int, location_ts:
  ds.frameId = frame_id
  ds.modelExecutionTime = execution_time
  ds.gpuExecutionTime = gpu_execution_time
-  ds.poorVisionProb = float(sigmoid(model_result.poor_vision_prob))
  ds.wheelOnRightProb = float(sigmoid(model_result.wheel_on_right_prob))
  ds.rawPredictions = model_output.tobytes() if SEND_RAW_PRED else b''
  fill_driver_state(ds.leftDriverData, model_result.driver_state_lhd)
@@ -62,6 +62,5 @@ Refer to **slice_outputs** and **parse_vision_outputs/parse_policy_outputs** in
    * (deprecated) distracted probabilities: 2
    * using phone probability: 1
    * distracted probability: 1
-  * common outputs 2
-    * poor camera vision probability: 1
+  * common outputs 1
    * left hand drive probability: 1
@@ -1,2 +0,0 @@
-fa69be01-b430-4504-9d72-7dcb058eb6dd
-d9fb22d1c4fa3ca3d201dbc8edf1d0f0918e53e6
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:50efe6451a3fb3fa04b6bb0e846544533329bd46ecefe9e657e91214dee2aaeb
-size 7196502
+oid sha256:3a53626ab84757813fb16a1441704f2ae7192bef88c331bdc2415be6981d204f
+size 7191776
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ebb38a934d6472c061cc6010f46d9720ca132d631a47e585a893bdd41ade2419
-size 12343535
+oid sha256:c5a1f0655ddf266ed42ad1980389d96f47cc5e756da1fa3ca1477a920bb9b157
+size 13926324
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:befac016a247b7ad5dc5b55d339d127774ed7bd2b848f1583f72aa4caee37781
-size 46271991
+oid sha256:8f16d548ea4eb5d01518a9e90d4527cd97c31a84bcaf6f695dead8f0015fecc4
+size 46271942
@@ -4,11 +4,13 @@ import numpy as np
 from cereal import car, log
 import cereal.messaging as messaging
 from openpilot.selfdrive.selfdrived.events import Events
+from openpilot.selfdrive.selfdrived.alertmanager import set_offroad_alert
 from openpilot.common.realtime import DT_DMON
 from openpilot.common.filter_simple import FirstOrderFilter
 from openpilot.common.params import Params
 from openpilot.common.stat_live import RunningStatFilter
 from openpilot.common.transformations.camera import DEVICE_CAMERAS
+from openpilot.system.hardware import HARDWARE

 EventName = log.OnroadEvent.EventName

@@ -34,12 +36,13 @@ class DRIVER_MONITOR_SETTINGS:
    self._SG_THRESHOLD = 0.9
    self._BLINK_THRESHOLD = 0.865

-    self._EE_THRESH11 = 0.4
+    if HARDWARE.get_device_type() == 'mici':
+      self._EE_THRESH11 = 0.75
+    else:
+      self._EE_THRESH11 = 0.4
    self._EE_THRESH12 = 15.0
    self._EE_MAX_OFFSET1 = 0.06
    self._EE_MIN_OFFSET1 = 0.025
-    self._EE_THRESH21 = 0.01
-    self._EE_THRESH22 = 0.35

    self._POSE_PITCH_THRESHOLD = 0.3133
    self._POSE_PITCH_THRESHOLD_SLACK = 0.3237
@@ -55,6 +58,9 @@ class DRIVER_MONITOR_SETTINGS:
    self._YAW_MAX_OFFSET = 0.289
    self._YAW_MIN_OFFSET = -0.0246

+    self._DCAM_UNCERTAIN_ALERT_THRESHOLD = 0.1
+    self._DCAM_UNCERTAIN_ALERT_COUNT = int(60  / self._DT_DMON)
+    self._DCAM_UNCERTAIN_RESET_COUNT = int(20  / self._DT_DMON)
    self._POSESTD_THRESHOLD = 0.3
    self._HI_STD_FALLBACK_TIME = int(10  / self._DT_DMON)  # fall back to wheel touch if model is uncertain for 10s
    self._DISTRACTED_FILTER_TS = 0.25  # 0.6Hz
@@ -137,11 +143,8 @@ class DriverMonitoring:
    self.pose = DriverPose(self.settings._POSE_OFFSET_MAX_COUNT)
    self.blink = DriverBlink()
    self.eev1 = 0.
-    self.eev2 = 1.
    self.ee1_offseter = RunningStatFilter(max_trackable=self.settings._POSE_OFFSET_MAX_COUNT)
-    self.ee2_offseter = RunningStatFilter(max_trackable=self.settings._POSE_OFFSET_MAX_COUNT)
    self.ee1_calibrated = False
-    self.ee2_calibrated = False

    self.always_on = always_on
    self.distracted_types = []
@@ -159,6 +162,9 @@ class DriverMonitoring:
    self.hi_stds = 0
    self.threshold_pre = self.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL / self.settings._DISTRACTED_TIME
    self.threshold_prompt = self.settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL / self.settings._DISTRACTED_TIME
+    self.dcam_uncertain_cnt = 0
+    self.dcam_uncertain_alerted = False # once per drive
+    self.dcam_reset_cnt = 0

    self.params = Params()
    self.too_distracted = self.params.get_bool("DriverTooDistracted")
@@ -246,7 +252,7 @@ class DriverMonitoring:

    return distracted_types

-  def _update_states(self, driver_state, cal_rpy, car_speed, op_engaged):
+  def _update_states(self, driver_state, cal_rpy, car_speed, op_engaged, standstill):
    rhd_pred = driver_state.wheelOnRightProb
    # calibrates only when there's movement and either face detected
    if car_speed > self.settings._WHEELPOS_CALIB_MIN_SPEED and (driver_state.leftDriverData.faceProb > self.settings._FACE_THRESHOLD or
@@ -262,7 +268,7 @@ class DriverMonitoring:
    driver_data = driver_state.rightDriverData if self.wheel_on_right else driver_state.leftDriverData
    if not all(len(x) > 0 for x in (driver_data.faceOrientation, driver_data.facePosition,
                                    driver_data.faceOrientationStd, driver_data.facePositionStd,
-                                    driver_data.readyProb, driver_data.notReadyProb)):
+                                    driver_data.notReadyProb)):
      return

    self.face_detected = driver_data.faceProb > self.settings._FACE_THRESHOLD
@@ -279,7 +285,6 @@ class DriverMonitoring:
    self.blink.right = driver_data.rightBlinkProb * (driver_data.rightEyeProb > self.settings._EYE_THRESHOLD) \
                                                                  * (driver_data.sunglassesProb < self.settings._SG_THRESHOLD)
    self.eev1 = driver_data.notReadyProb[0]
-    self.eev2 = driver_data.readyProb[0]

    self.distracted_types = self._get_distracted_types()
    self.driver_distracted = (DistractedType.DISTRACTED_E2E in self.distracted_types or DistractedType.DISTRACTED_POSE in self.distracted_types
@@ -293,12 +298,20 @@ class DriverMonitoring:
      self.pose.pitch_offseter.push_and_update(self.pose.pitch)
      self.pose.yaw_offseter.push_and_update(self.pose.yaw)
      self.ee1_offseter.push_and_update(self.eev1)
-      self.ee2_offseter.push_and_update(self.eev2)

    self.pose.calibrated = self.pose.pitch_offseter.filtered_stat.n > self.settings._POSE_OFFSET_MIN_COUNT and \
                                       self.pose.yaw_offseter.filtered_stat.n > self.settings._POSE_OFFSET_MIN_COUNT
    self.ee1_calibrated = self.ee1_offseter.filtered_stat.n > self.settings._POSE_OFFSET_MIN_COUNT
-    self.ee2_calibrated = self.ee2_offseter.filtered_stat.n > self.settings._POSE_OFFSET_MIN_COUNT
+
+    if self.face_detected and not self.driver_distracted:
+      if model_std_max > self.settings._DCAM_UNCERTAIN_ALERT_THRESHOLD:
+        if not standstill:
+          self.dcam_uncertain_cnt += 1
+          self.dcam_reset_cnt = 0
+      else:
+        self.dcam_reset_cnt += 1
+        if self.dcam_reset_cnt > self.settings._DCAM_UNCERTAIN_RESET_COUNT:
+          self.dcam_uncertain_cnt = 0

    self.is_model_uncertain = self.hi_stds > self.settings._HI_STD_FALLBACK_TIME
    self._set_timers(self.face_detected and not self.is_model_uncertain)
@@ -376,6 +389,10 @@ class DriverMonitoring:
    if alert is not None:
      self.current_events.add(alert)

+    if self.dcam_uncertain_cnt > self.settings._DCAM_UNCERTAIN_ALERT_COUNT and not self.dcam_uncertain_alerted:
+      set_offroad_alert("Offroad_DriverMonitoringUncertain", True)
+      self.dcam_uncertain_alerted = True
+

  def get_state_packet(self, valid=True):
    # build driverMonitoringState packet
@@ -397,6 +414,7 @@ class DriverMonitoring:
      "hiStdCount": self.hi_stds,
      "isActiveMode": self.active_monitoring_mode,
      "isRHD": self.wheel_on_right,
+      "uncertainCount": self.dcam_uncertain_cnt,
    }
    return dat

@@ -412,7 +430,8 @@ class DriverMonitoring:
      driver_state=sm['driverStateV2'],
      cal_rpy=sm['liveCalibration'].rpyCalib,
      car_speed=sm['carState'].vEgo,
-      op_engaged=sm['selfdriveState'].enabled or sm['carControl'].latActive
+      op_engaged=sm['selfdriveState'].enabled or sm['carControl'].latActive,
+      standstill=sm['carState'].standstill,
    )

    # Update distraction events
@@ -25,7 +25,6 @@ def make_msg(face_detected, distracted=False, model_uncertain=False):
  ds.leftDriverData.faceOrientationStd = [1.*model_uncertain, 1.*model_uncertain, 1.*model_uncertain]
  ds.leftDriverData.facePositionStd = [1.*model_uncertain, 1.*model_uncertain]
  # TODO: test both separately when e2e is used
-  ds.leftDriverData.readyProb = [0., 0., 0., 0.]
  ds.leftDriverData.notReadyProb = [0., 0.]
  return ds

@@ -54,7 +53,7 @@ class TestMonitoring:
    DM = DriverMonitoring()
    events = []
    for idx in range(len(msgs)):
-      DM._update_states(msgs[idx], [0, 0, 0], 0, engaged[idx])
+      DM._update_states(msgs[idx], [0, 0, 0], 0, engaged[idx], standstill[idx])
      # cal_rpy and car_speed don't matter here

      # evaluate events at 10Hz for tests
@@ -80,7 +80,7 @@ Panda *connect(std::string serial="", uint32_t index=0) {
  }
  //panda->enable_deepsleep();

-  for (int i = 0; i < PANDA_BUS_CNT; i++) {
+  for (int i = 0; i < PANDA_CAN_CNT; i++) {
    panda->set_can_fd_auto(i, true);
  }

@@ -5,8 +5,7 @@ import time
 import cereal.messaging as messaging
 from cereal import log
 from openpilot.common.gpio import gpio_set, gpio_init
-from panda import Panda, PandaDFU, PandaProtocolMismatch
-from openpilot.common.retry import retry
+from panda import Panda, PandaDFU
 from openpilot.system.manager.process_config import managed_processes
 from openpilot.system.hardware import HARDWARE
 from openpilot.system.hardware.tici.pins import GPIO
@@ -50,8 +49,7 @@ class TestPandad:
    assert not Panda.wait_for_dfu(None, 3)
    assert not Panda.wait_for_panda(None, 3)

-  @retry(attempts=3)
-  def _flash_bootstub_and_test(self, fn, expect_mismatch=False):
+  def _flash_bootstub(self, fn):
    self._go_to_dfu()
    pd = PandaDFU(None)
    if fn is None:
@@ -61,16 +59,6 @@ class TestPandad:
    pd.reset()
    HARDWARE.reset_internal_panda()

-    assert Panda.wait_for_panda(None, 10)
-    if expect_mismatch:
-      with pytest.raises(PandaProtocolMismatch):
-        Panda()
-    else:
-      with Panda() as p:
-        assert p.bootstub
-
-    self._run_test(45)
-
  def test_in_dfu(self):
    HARDWARE.recover_internal_panda()
    self._run_test(60)
@@ -106,13 +94,14 @@ class TestPandad:
    print("startup times", ts, sum(ts) / len(ts))
    assert 0.1 < (sum(ts)/len(ts)) < 0.7

-  def test_protocol_version_check(self):
-    # 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_and_test(None)
+    self._flash_bootstub(None)
+    self._run_test(45)

  def test_recover_from_bad_bootstub(self):
    self._go_to_dfu()
@@ -9,7 +9,7 @@ from pprint import pprint
 import cereal.messaging as messaging
 from cereal import car, log
 from opendbc.car.can_definitions import CanData
-from openpilot.common.retry import retry
+from openpilot.common.utils import retry
 from openpilot.common.params import Params
 from openpilot.common.timeout import Timeout
 from openpilot.selfdrive.pandad import can_list_to_can_capnp
@@ -41,6 +41,10 @@
    "text": "OpenStreetMap database is out of date. New maps must be downloaded if you wish to continue using OpenStreetMap data for Enhanced Speed Control and road name display.\n\n%1",
    "severity": 0
  },
+  "Offroad_DriverMonitoringUncertain": {
+    "text": "openpilot detected poor visibility for driver monitoring. Ensure the device has a clear view of the driver. This can be checked using Settings -> Device -> Driver Camera Preview. Extreme lighting conditions and/or unconventional mounting positions may also trigger this alert.",
+    "severity": 0
+  },
  "Offroad_ExcessiveActuation": {
    "text": "openpilot detected excessive %1 actuation on your last drive. Please contact support at https://comma.ai/support and share your device's Dongle ID for troubleshooting.",
    "severity": 1,
@@ -80,7 +80,7 @@ def below_engage_speed_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.

 def below_steer_speed_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
  return Alert(
-    f"Steer Unavailable Below {get_display_speed(CP.minSteerSpeed, metric)}",
+    f"Steer Assist Unavailable Below {get_display_speed(CP.minSteerSpeed, metric)}",
    "",
    AlertStatus.userPrompt, AlertSize.small,
    Priority.LOW, VisualAlert.none, AudibleAlert.prompt, 0.4)
@@ -322,7 +322,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = {

  EventName.steerTempUnavailableSilent: {
    ET.WARNING: Alert(
-      "Steering Temporarily Unavailable",
+      "Steering Assist Temporarily Unavailable",
      "",
      AlertStatus.userPrompt, AlertSize.small,
      Priority.LOW, VisualAlert.steerRequired, AudibleAlert.prompt, 1.8),
@@ -568,7 +568,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = {
  },

  EventName.steerTempUnavailable: {
-    ET.SOFT_DISABLE: soft_disable_alert("Steering Temporarily Unavailable"),
+    ET.SOFT_DISABLE: soft_disable_alert("Steering Assist Temporarily Unavailable"),
    ET.NO_ENTRY: NoEntryAlert("Steering Temporarily Unavailable"),
  },

@@ -1 +1 @@
-afcab1abb62b9d5678342956cced4712f44e909e
+b508f43fb0481bce0859c9b6ab4f45ee690b8dab
@@ -42,6 +42,7 @@ sudo systemctl restart NetworkManager
 sudo systemctl disable ssh-param-watcher.path
 sudo systemctl disable ssh-param-watcher.service
 sudo mount -o ro,remount /
+sudo systemctl stop power_monitor

 while true; do
  if ! sudo systemctl is-active -q ssh; then
@@ -54,7 +55,6 @@ while true; do
  #  /data/ciui.py &
  #fi

-  awk '{print \$1}' /proc/uptime > /var/tmp/power_watchdog
  sleep 5s
 done

@@ -32,7 +32,7 @@ CPU usage budget
 TEST_DURATION = 25
 LOG_OFFSET = 8

-MAX_TOTAL_CPU = 300.  # total for all 8 cores
+MAX_TOTAL_CPU = 350.  # total for all 8 cores
 PROCS = {
  # Baseline CPU usage by process
  "selfdrive.controls.controlsd": 16.0,
@@ -42,7 +42,7 @@ PROCS = {
  "./encoderd": 13.0,
  "./camerad": 10.0,
  "selfdrive.controls.plannerd": 8.0,
-  "./ui": 18.0,
+  "selfdrive.ui.ui": 40.0,
  "system.sensord.sensord": 13.0,
  "selfdrive.controls.radard": 2.0,
  "selfdrive.modeld.modeld": 22.0,
@@ -206,7 +206,8 @@ class TestOnroad:
    result += "-------------- UI Draw Timing ------------------\n"
    result += "------------------------------------------------\n"

-    ts = self.ts['uiDebug']['drawTimeMillis']
+    # skip first few frames -- connecting to vipc
+    ts = self.ts['uiDebug']['drawTimeMillis'][15:]
    result += f"min  {min(ts):.2f}ms\n"
    result += f"max  {max(ts):.2f}ms\n"
    result += f"std  {np.std(ts):.2f}ms\n"
@@ -215,7 +216,7 @@ class TestOnroad:
    print(result)

    assert max(ts) < 250.
-    assert np.mean(ts) < 10.
+    assert np.mean(ts) < 20.  # TODO: ~6-11ms, increase consistency
    #self.assertLess(np.std(ts), 5.)

    # some slow frames are expected since camerad/modeld can preempt ui
@@ -285,7 +286,7 @@ class TestOnroad:

    # check for big leaks. note that memory usage is
    # expected to go up while the MSGQ buffers fill up
-    assert np.average(mems) <= 65, "Average memory usage above 65%"
+    assert np.average(mems) <= 85, "Average memory usage above 85%"
    assert np.max(np.diff(mems)) <= 4, "Max memory increase too high"
    assert np.average(np.diff(mems)) <= 1, "Average memory increase too high"

@@ -1,14 +1 @@
-moc_*
-*.moc
-
-translations/main_test_en.*
-
-ui
-mui
-watch3
 installer/installers/*
-qt/setup/setup
-qt/setup/reset
-qt/setup/wifi
-qt/setup/updater
-translations/alerts_generated.h
@@ -1,75 +1,37 @@
+import os
+import re
 import json
-Import('env', 'qt_env', 'arch', 'common', 'messaging', 'visionipc', 'transformations')
+from pathlib import Path
+Import('env', 'arch', 'common')

-base_libs = [common, messaging, visionipc, transformations,
-             'm', 'OpenCL', 'ssl', 'crypto', 'pthread'] + qt_env["LIBS"]
+# build the fonts
+generator = File("#selfdrive/assets/fonts/process.py")
+source_files = Glob("#selfdrive/assets/fonts/*.ttf") + Glob("#selfdrive/assets/fonts/*.otf")
+output_files = [
+  (f.abspath.split('.')[0] + ".fnt", f.abspath.split('.')[0] + ".png")
+  for f in source_files
+  if "NotoColor" not in f.name
+]
+env.Command(
+  target=output_files,
+  source=[generator, source_files],
+  action=f"python3 {generator}",
+)

-if arch == 'larch64':
-  base_libs.append('EGL')
-
-if arch == "Darwin":
-  del base_libs[base_libs.index('OpenCL')]
-  qt_env['FRAMEWORKS'] += ['OpenCL']
-
-sp_widgets_src = []
-sp_qt_src = []
-sp_qt_util = []
-if not GetOption('stock_ui'):
-  SConscript(['sunnypilot/SConscript'])
-  Import('sp_widgets_src', 'sp_qt_src', 'sp_qt_util')
-
-# FIXME: remove this once we're on 5.15 (24.04)
-qt_env['CXXFLAGS'] += ["-Wno-deprecated-declarations"]
-
-qt_util = qt_env.Library("qt_util", ["#selfdrive/ui/qt/api.cc", "#selfdrive/ui/qt/util.cc"] + sp_qt_util, LIBS=base_libs)
-widgets_src = ["qt/widgets/input.cc", "qt/widgets/wifi.cc", "qt/prime_state.cc",
-               "qt/widgets/ssh_keys.cc", "qt/widgets/toggle.cc", "qt/widgets/controls.cc",
-               "qt/widgets/offroad_alerts.cc", "qt/widgets/prime.cc", "qt/widgets/keyboard.cc",
-               "qt/widgets/scrollview.cc", "qt/widgets/cameraview.cc", "#third_party/qrcode/QrCode.cc",
-               "qt/request_repeater.cc", "qt/qt_window.cc", "qt/network/networking.cc", "qt/network/wifi_manager.cc"] + sp_widgets_src
-
-widgets = qt_env.Library("qt_widgets", widgets_src, LIBS=base_libs)
-Export('widgets')
-qt_libs = [widgets, qt_util] + base_libs
-
-qt_src = ["main.cc", "ui.cc", "qt/sidebar.cc", "qt/body.cc",
-          "qt/window.cc", "qt/home.cc", "qt/offroad/settings.cc", "qt/offroad/offroad_home.cc",
-          "qt/offroad/software_settings.cc", "qt/offroad/developer_panel.cc", "qt/offroad/onboarding.cc",
-          "qt/offroad/driverview.cc", "qt/offroad/experimental_mode.cc", "qt/offroad/firehose.cc",
-          "qt/onroad/onroad_home.cc", "qt/onroad/annotated_camera.cc", "qt/onroad/model.cc",
-          "qt/onroad/buttons.cc", "qt/onroad/alerts.cc", "qt/onroad/driver_monitoring.cc", "qt/onroad/hud.cc"] + sp_qt_src
-
-# build translation files
+# compile gettext .po -> .mo translations
 with open(File("translations/languages.json").abspath) as f:
  languages = json.loads(f.read())
-translation_sources = [f"#selfdrive/ui/translations/{l}.ts" for l in languages.values()]
-translation_targets = [src.replace(".ts", ".qm") for src in translation_sources]
-lrelease_bin = 'third_party/qt5/larch64/bin/lrelease' if arch == 'larch64' else 'lrelease'

-lrelease = qt_env.Command(translation_targets, translation_sources, f"{lrelease_bin} $SOURCES")
-qt_env.NoClean(translation_sources)
-qt_env.Precious(translation_sources)
+po_sources = [f"#selfdrive/ui/translations/app_{l}.po" for l in languages.values()]
+po_sources = [src for src in po_sources if os.path.exists(File(src).abspath)]
+mo_targets = [src.replace(".po", ".mo") for src in po_sources]
+mo_build = []
+for src, tgt in zip(po_sources, mo_targets):
+  mo_build.append(env.Command(tgt, src, "msgfmt -o $TARGET $SOURCE"))
+mo_alias = env.Alias('mo', mo_build)
+env.AlwaysBuild(mo_alias)

-# create qrc file for compiled translations to include with assets
-translations_assets_src = "#selfdrive/assets/translations_assets.qrc"
-with open(File(translations_assets_src).abspath, 'w') as f:
-  f.write('<!DOCTYPE RCC><RCC version="1.0">\n<qresource>\n')
-  f.write('\n'.join([f'<file alias="{l}">../ui/translations/{l}.qm</file>' for l in languages.values()]))
-  f.write('\n</qresource>\n</RCC>')
-
-# build assets
-assets = "#selfdrive/assets/assets.cc"
-assets_src = "#selfdrive/assets/assets.qrc"
-qt_env.Command(assets, [assets_src, translations_assets_src], f"rcc $SOURCES -o $TARGET")
-qt_env.Depends(assets, Glob('#selfdrive/assets/*', exclude=[assets, assets_src, translations_assets_src, "#selfdrive/assets/assets.o"]) + [lrelease])
-asset_obj = qt_env.Object("assets", assets)
-
-# build main UI
-qt_env.Program("ui", qt_src + [asset_obj], LIBS=qt_libs)
 if GetOption('extras'):
-  qt_src.remove("main.cc")  # replaced by test_runner
-  qt_env.Program('tests/test_translations', [asset_obj, 'tests/test_runner.cc', 'tests/test_translations.cc'] + qt_src, LIBS=qt_libs)
-
  # build installers
  if arch != "Darwin":
    raylib_env = env.Clone()
@@ -78,7 +40,7 @@ if GetOption('extras'):

    raylib_libs = common + ["raylib"]
    if arch == "larch64":
-      raylib_libs += ["GLESv2", "wayland-client", "wayland-egl", "EGL"]
+      raylib_libs += ["GLESv2", "EGL", "gbm", "drm"]
    else:
      raylib_libs += ["GL"]

@@ -0,0 +1 @@
+UI_BORDER_SIZE = 30
@@ -5,6 +5,7 @@

 #include "common/swaglog.h"
 #include "common/util.h"
+#include "system/hardware/hw.h"
 #include "third_party/raylib/include/raylib.h"

 int freshClone();
@@ -38,6 +39,27 @@ extern const uint8_t inter_ttf_end[] asm("_binary_selfdrive_ui_installer_inter_a

 Font font;

+std::vector<std::string> tici_prebuilt_branches = {"release3", "release-tizi", "release3-staging", "nightly", "nightly-dev"};
+std::string migrated_branch;
+
+void branchMigration() {
+  migrated_branch = BRANCH_STR;
+  cereal::InitData::DeviceType device_type = Hardware::get_device_type();
+  if (device_type == cereal::InitData::DeviceType::TICI) {
+    if (std::find(tici_prebuilt_branches.begin(), tici_prebuilt_branches.end(), BRANCH_STR) != tici_prebuilt_branches.end()) {
+      migrated_branch = "release-tici";
+    } else if (BRANCH_STR == "master") {
+      migrated_branch = "master-tici";
+    }
+  } else if (device_type == cereal::InitData::DeviceType::TIZI) {
+    if (BRANCH_STR == "release3") {
+      migrated_branch = "release-tizi";
+    } else if (BRANCH_STR == "release3-staging") {
+      migrated_branch = "release-tizi-staging";
+    }
+  }
+}
+
 void run(const char* cmd) {
  int err = std::system(cmd);
  assert(err == 0);
@@ -87,7 +109,7 @@ int doInstall() {
 int freshClone() {
  LOGD("Doing fresh clone");
  std::string cmd = util::string_format("git clone --progress %s -b %s --depth=1 --recurse-submodules %s 2>&1",
-                                        GIT_URL.c_str(), BRANCH_STR.c_str(), TMP_INSTALL_PATH);
+                                        GIT_URL.c_str(), migrated_branch.c_str(), TMP_INSTALL_PATH);
  return executeGitCommand(cmd);
 }

@@ -95,11 +117,11 @@ int cachedFetch(const std::string &cache) {
  LOGD("Fetching with cache: %s", cache.c_str());

  run(util::string_format("cp -rp %s %s", cache.c_str(), TMP_INSTALL_PATH).c_str());
-  run(util::string_format("cd %s && git remote set-branches --add origin %s", TMP_INSTALL_PATH, BRANCH_STR.c_str()).c_str());
+  run(util::string_format("cd %s && git remote set-branches --add origin %s", TMP_INSTALL_PATH, migrated_branch.c_str()).c_str());

  renderProgress(10);

-  return executeGitCommand(util::string_format("cd %s && git fetch --progress origin %s 2>&1", TMP_INSTALL_PATH, BRANCH_STR.c_str()));
+  return executeGitCommand(util::string_format("cd %s && git fetch --progress origin %s 2>&1", TMP_INSTALL_PATH, migrated_branch.c_str()));
 }

 int executeGitCommand(const std::string &cmd) {
@@ -142,8 +164,8 @@ void cloneFinished(int exitCode) {
  // ensure correct branch is checked out
  int err = chdir(TMP_INSTALL_PATH);
  assert(err == 0);
-  run(("git checkout " + BRANCH_STR).c_str());
-  run(("git reset --hard origin/" + BRANCH_STR).c_str());
+  run(("git checkout " + migrated_branch).c_str());
+  run(("git reset --hard origin/" + migrated_branch).c_str());
  run("git submodule update --init");

  // move into place
@@ -193,6 +215,8 @@ int main(int argc, char *argv[]) {
  font = LoadFontFromMemory(".ttf", inter_ttf, inter_ttf_end - inter_ttf, FONT_SIZE, NULL, 0);
  SetTextureFilter(font.texture, TEXTURE_FILTER_BILINEAR);

+  branchMigration();
+
  if (util::file_exists(CONTINUE_PATH)) {
    finishInstall();
  } else {
@@ -8,7 +8,9 @@ from openpilot.selfdrive.ui.widgets.exp_mode_button import ExperimentalModeButto
 from openpilot.selfdrive.ui.widgets.prime import PrimeWidget
 from openpilot.selfdrive.ui.widgets.setup import SetupWidget
 from openpilot.system.ui.lib.text_measure import measure_text_cached
-from openpilot.system.ui.lib.application import gui_app, FontWeight, DEFAULT_TEXT_COLOR
+from openpilot.system.ui.lib.application import gui_app, FontWeight, MousePos
+from openpilot.system.ui.lib.multilang import tr, trn
+from openpilot.system.ui.widgets.label import gui_label
 from openpilot.system.ui.widgets import Widget

 HEADER_HEIGHT = 80
@@ -35,12 +37,17 @@ class HomeLayout(Widget):
    self.update_alert = UpdateAlert()
    self.offroad_alert = OffroadAlert()

+    self._layout_widgets = {HomeLayoutState.UPDATE: self.update_alert, HomeLayoutState.ALERTS: self.offroad_alert}
+
    self.current_state = HomeLayoutState.HOME
    self.last_refresh = 0
    self.settings_callback: callable | None = None

    self.update_available = False
    self.alert_count = 0
+    self._version_text = ""
+    self._prev_update_available = False
+    self._prev_alerts_present = False

    self.header_rect = rl.Rectangle(0, 0, 0, 0)
    self.content_rect = rl.Rectangle(0, 0, 0, 0)
@@ -56,14 +63,30 @@ class HomeLayout(Widget):
    self._exp_mode_button = ExperimentalModeButton()
    self._setup_callbacks()

+  def show_event(self):
+    self._exp_mode_button.show_event()
+    self.last_refresh = time.monotonic()
+    self._refresh()
+
  def _setup_callbacks(self):
    self.update_alert.set_dismiss_callback(lambda: self._set_state(HomeLayoutState.HOME))
    self.offroad_alert.set_dismiss_callback(lambda: self._set_state(HomeLayoutState.HOME))
+    self._exp_mode_button.set_click_callback(lambda: self.settings_callback() if self.settings_callback else None)

  def set_settings_callback(self, callback: Callable):
    self.settings_callback = callback

  def _set_state(self, state: HomeLayoutState):
+    # propagate show/hide events
+    if state != self.current_state:
+      if state == HomeLayoutState.HOME:
+        self._exp_mode_button.show_event()
+
+      if state in self._layout_widgets:
+        self._layout_widgets[state].show_event()
+      if self.current_state in self._layout_widgets:
+        self._layout_widgets[self.current_state].hide_event()
+
    self.current_state = state

  def _render(self, rect: rl.Rectangle):
@@ -72,7 +95,6 @@ class HomeLayout(Widget):
      self._refresh()
      self.last_refresh = current_time

-    self._handle_input()
    self._render_header()

    # Render content based on current state
@@ -83,7 +105,7 @@ class HomeLayout(Widget):
    elif self.current_state == HomeLayoutState.ALERTS:
      self._render_alerts_view()

-  def _update_layout_rects(self):
+  def _update_state(self):
    self.header_rect = rl.Rectangle(
      self._rect.x + CONTENT_MARGIN, self._rect.y + CONTENT_MARGIN, self._rect.width - 2 * CONTENT_MARGIN, HEADER_HEIGHT
    )
@@ -110,59 +132,54 @@ class HomeLayout(Widget):
    self.alert_notif_rect.x = notif_x
    self.alert_notif_rect.y = self.header_rect.y + (self.header_rect.height - 60) // 2

-  def _handle_input(self):
-    if not rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT):
-      return
-
-    mouse_pos = rl.get_mouse_position()
+  def _handle_mouse_release(self, mouse_pos: MousePos):
+    super()._handle_mouse_release(mouse_pos)

    if self.update_available and rl.check_collision_point_rec(mouse_pos, self.update_notif_rect):
      self._set_state(HomeLayoutState.UPDATE)
-      return
-
-    if self.alert_count > 0 and rl.check_collision_point_rec(mouse_pos, self.alert_notif_rect):
+    elif self.alert_count > 0 and rl.check_collision_point_rec(mouse_pos, self.alert_notif_rect):
      self._set_state(HomeLayoutState.ALERTS)
-      return
-
-    # Content area input handling
-    if self.current_state == HomeLayoutState.UPDATE:
-      self.update_alert.handle_input(mouse_pos, True)
-    elif self.current_state == HomeLayoutState.ALERTS:
-      self.offroad_alert.handle_input(mouse_pos, True)

  def _render_header(self):
    font = gui_app.font(FontWeight.MEDIUM)

+    version_text_width = self.header_rect.width
+
    # Update notification button
    if self.update_available:
+      version_text_width -= self.update_notif_rect.width
+
      # Highlight if currently viewing updates
-      highlight_color = rl.Color(255, 140, 40, 255) if self.current_state == HomeLayoutState.UPDATE else rl.Color(255, 102, 0, 255)
+      highlight_color = rl.Color(75, 95, 255, 255) if self.current_state == HomeLayoutState.UPDATE else rl.Color(54, 77, 239, 255)
      rl.draw_rectangle_rounded(self.update_notif_rect, 0.3, 10, highlight_color)

-      text = "UPDATE"
-      text_width = measure_text_cached(font, text, HEAD_BUTTON_FONT_SIZE).x
-      text_x = self.update_notif_rect.x + (self.update_notif_rect.width - text_width) // 2
-      text_y = self.update_notif_rect.y + (self.update_notif_rect.height - HEAD_BUTTON_FONT_SIZE) // 2
+      text = tr("UPDATE")
+      text_size = measure_text_cached(font, text, HEAD_BUTTON_FONT_SIZE)
+      text_x = self.update_notif_rect.x + (self.update_notif_rect.width - text_size.x) // 2
+      text_y = self.update_notif_rect.y + (self.update_notif_rect.height - text_size.y) // 2
      rl.draw_text_ex(font, text, rl.Vector2(int(text_x), int(text_y)), HEAD_BUTTON_FONT_SIZE, 0, rl.WHITE)

    # Alert notification button
    if self.alert_count > 0:
+      version_text_width -= self.alert_notif_rect.width
+
      # Highlight if currently viewing alerts
      highlight_color = rl.Color(255, 70, 70, 255) if self.current_state == HomeLayoutState.ALERTS else rl.Color(226, 44, 44, 255)
      rl.draw_rectangle_rounded(self.alert_notif_rect, 0.3, 10, highlight_color)

-      alert_text = f"{self.alert_count} ALERT{'S' if self.alert_count > 1 else ''}"
-      text_width = measure_text_cached(font, alert_text, HEAD_BUTTON_FONT_SIZE).x
-      text_x = self.alert_notif_rect.x + (self.alert_notif_rect.width - text_width) // 2
-      text_y = self.alert_notif_rect.y + (self.alert_notif_rect.height - HEAD_BUTTON_FONT_SIZE) // 2
+      alert_text = trn("{} ALERT", "{} ALERTS", self.alert_count).format(self.alert_count)
+      text_size = measure_text_cached(font, alert_text, HEAD_BUTTON_FONT_SIZE)
+      text_x = self.alert_notif_rect.x + (self.alert_notif_rect.width - text_size.x) // 2
+      text_y = self.alert_notif_rect.y + (self.alert_notif_rect.height - text_size.y) // 2
      rl.draw_text_ex(font, alert_text, rl.Vector2(int(text_x), int(text_y)), HEAD_BUTTON_FONT_SIZE, 0, rl.WHITE)

    # Version text (right aligned)
-    version_text = self._get_version_text()
-    text_width = measure_text_cached(gui_app.font(FontWeight.NORMAL), version_text, 48).x
-    version_x = self.header_rect.x + self.header_rect.width - text_width
-    version_y = self.header_rect.y + (self.header_rect.height - 48) // 2
-    rl.draw_text_ex(gui_app.font(FontWeight.NORMAL), version_text, rl.Vector2(int(version_x), int(version_y)), 48, 0, DEFAULT_TEXT_COLOR)
+    if self.update_available or self.alert_count > 0:
+      version_text_width -= SPACING * 1.5
+
+    version_rect = rl.Rectangle(self.header_rect.x + self.header_rect.width - version_text_width, self.header_rect.y,
+                                version_text_width, self.header_rect.height)
+    gui_label(version_rect, self._version_text, 48, rl.WHITE, alignment=rl.GuiTextAlignment.TEXT_ALIGN_RIGHT)

  def _render_home_content(self):
    self._render_left_column()
@@ -193,20 +210,23 @@ class HomeLayout(Widget):
    self._setup_widget.render(setup_rect)

  def _refresh(self):
-    # TODO: implement _update_state with a timer
-    self.update_available = self.update_alert.refresh()
-    self.alert_count = self.offroad_alert.refresh()
-    self._update_state_priority(self.update_available, self.alert_count > 0)
-
-  def _update_state_priority(self, update_available: bool, alerts_present: bool):
-    current_state = self.current_state
+    self._version_text = self._get_version_text()
+    update_available = self.update_alert.refresh()
+    alert_count = self.offroad_alert.refresh()
+    alerts_present = alert_count > 0

+    # Show panels on transition from no alert/update to any alerts/update
    if not update_available and not alerts_present:
-      self.current_state = HomeLayoutState.HOME
-    elif update_available and (current_state == HomeLayoutState.HOME or (not alerts_present and current_state == HomeLayoutState.ALERTS)):
-      self.current_state = HomeLayoutState.UPDATE
-    elif alerts_present and (current_state == HomeLayoutState.HOME or (not update_available and current_state == HomeLayoutState.UPDATE)):
-      self.current_state = HomeLayoutState.ALERTS
+      self._set_state(HomeLayoutState.HOME)
+    elif update_available and ((not self._prev_update_available) or (not alerts_present and self.current_state == HomeLayoutState.ALERTS)):
+      self._set_state(HomeLayoutState.UPDATE)
+    elif alerts_present and ((not self._prev_alerts_present) or (not update_available and self.current_state == HomeLayoutState.UPDATE)):
+      self._set_state(HomeLayoutState.ALERTS)
+
+    self.update_available = update_available
+    self.alert_count = alert_count
+    self._prev_update_available = update_available
+    self._prev_alerts_present = alerts_present

  def _get_version_text(self) -> str:
    brand = "openpilot"
@@ -1,12 +1,14 @@
 import pyray as rl
 from enum import IntEnum
 import cereal.messaging as messaging
+from openpilot.system.ui.lib.application import gui_app
 from openpilot.selfdrive.ui.layouts.sidebar import Sidebar, SIDEBAR_WIDTH
 from openpilot.selfdrive.ui.layouts.home import HomeLayout
 from openpilot.selfdrive.ui.layouts.settings.settings import SettingsLayout, PanelType
 from openpilot.selfdrive.ui.onroad.augmented_road_view import AugmentedRoadView
 from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.system.ui.widgets import Widget
+from openpilot.selfdrive.ui.layouts.onboarding import OnboardingWindow


 class MainState(IntEnum):
@@ -34,16 +36,23 @@ class MainLayout(Widget):
    # Set callbacks
    self._setup_callbacks()

+    # Start onboarding if terms or training not completed
+    self._onboarding_window = OnboardingWindow()
+    if not self._onboarding_window.completed:
+      gui_app.set_modal_overlay(self._onboarding_window)
+
  def _render(self, _):
    self._handle_onroad_transition()
    self._render_main_content()

  def _setup_callbacks(self):
    self._sidebar.set_callbacks(on_settings=self._on_settings_clicked,
-                                on_flag=self._on_bookmark_clicked)
+                                on_flag=self._on_bookmark_clicked,
+                                open_settings=lambda: self.open_settings(PanelType.TOGGLES))
    self._layouts[MainState.HOME]._setup_widget.set_open_settings_callback(lambda: self.open_settings(PanelType.FIREHOSE))
+    self._layouts[MainState.HOME].set_settings_callback(lambda: self.open_settings(PanelType.TOGGLES))
    self._layouts[MainState.SETTINGS].set_callbacks(on_close=self._set_mode_for_state)
-    self._layouts[MainState.ONROAD].set_callbacks(on_click=self._on_onroad_clicked)
+    self._layouts[MainState.ONROAD].set_click_callback(self._on_onroad_clicked)
    device.add_interactive_timeout_callback(self._set_mode_for_state)

  def _update_layout_rects(self):
@@ -0,0 +1,214 @@
+import os
+import re
+import threading
+from enum import IntEnum
+
+import pyray as rl
+from openpilot.common.basedir import BASEDIR
+from openpilot.system.ui.lib.application import FontWeight, gui_app
+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.selfdrive.ui.ui_state import ui_state
+
+DEBUG = False
+
+STEP_RECTS = [rl.Rectangle(104, 800, 633, 175), rl.Rectangle(1835, 0, 2159, 1080), rl.Rectangle(1835, 0, 2156, 1080),
+              rl.Rectangle(1526, 473, 427, 472), rl.Rectangle(1643, 441, 217, 223), rl.Rectangle(1835, 0, 2155, 1080),
+              rl.Rectangle(1786, 591, 267, 236), rl.Rectangle(1353, 0, 804, 1080), rl.Rectangle(1458, 485, 633, 211),
+              rl.Rectangle(95, 794, 1158, 187), rl.Rectangle(1560, 170, 392, 397), rl.Rectangle(1835, 0, 2159, 1080),
+              rl.Rectangle(1351, 0, 807, 1080), rl.Rectangle(1835, 0, 2158, 1080), rl.Rectangle(1531, 82, 441, 920),
+              rl.Rectangle(1336, 438, 490, 393), rl.Rectangle(1835, 0, 2159, 1080), rl.Rectangle(1835, 0, 2159, 1080),
+              rl.Rectangle(87, 795, 1187, 186)]
+
+DM_RECORD_STEP = 9
+DM_RECORD_YES_RECT = rl.Rectangle(695, 794, 558, 187)
+
+RESTART_TRAINING_RECT = rl.Rectangle(87, 795, 472, 186)
+
+
+class OnboardingState(IntEnum):
+  TERMS = 0
+  ONBOARDING = 1
+  DECLINE = 2
+
+
+class TrainingGuide(Widget):
+  def __init__(self, completed_callback=None):
+    super().__init__()
+    self._completed_callback = completed_callback
+
+    self._step = 0
+    self._load_image_paths()
+
+    # Load first image now so we show something immediately
+    self._textures = [gui_app.texture(self._image_paths[0])]
+    self._image_objs = []
+
+    threading.Thread(target=self._preload_thread, daemon=True).start()
+
+  def _load_image_paths(self):
+    paths = [fn for fn in os.listdir(os.path.join(BASEDIR, "selfdrive/assets/training")) if re.match(r'^step\d*\.png$', fn)]
+    paths = sorted(paths, key=lambda x: int(re.search(r'\d+', x).group()))
+    self._image_paths = [os.path.join(BASEDIR, "selfdrive/assets/training", fn) for fn in paths]
+
+  def _preload_thread(self):
+    # PNG loading is slow in raylib, so we preload in a thread and upload to GPU in main thread
+    # We've already loaded the first image on init
+    for path in self._image_paths[1:]:
+      self._image_objs.append(gui_app._load_image_from_path(path))
+
+  def _handle_mouse_release(self, mouse_pos):
+    if rl.check_collision_point_rec(mouse_pos, STEP_RECTS[self._step]):
+      # Record DM camera?
+      if self._step == DM_RECORD_STEP:
+        yes = rl.check_collision_point_rec(mouse_pos, DM_RECORD_YES_RECT)
+        print(f"putting RecordFront to {yes}")
+        ui_state.params.put_bool("RecordFront", yes)
+
+      # Restart training?
+      elif self._step == len(self._image_paths) - 1:
+        if rl.check_collision_point_rec(mouse_pos, RESTART_TRAINING_RECT):
+          self._step = -1
+
+      self._step += 1
+
+      # Finished?
+      if self._step >= len(self._image_paths):
+        self._step = 0
+        if self._completed_callback:
+          self._completed_callback()
+
+  def _update_state(self):
+    if len(self._image_objs):
+      self._textures.append(gui_app._load_texture_from_image(self._image_objs.pop(0)))
+
+  def _render(self, _):
+    # Safeguard against fast tapping
+    step = min(self._step, len(self._textures) - 1)
+    rl.draw_texture(self._textures[step], 0, 0, rl.WHITE)
+
+    # progress bar
+    if 0 < step < len(STEP_RECTS) - 1:
+      h = 20
+      w = int((step / (len(STEP_RECTS) - 1)) * self._rect.width)
+      rl.draw_rectangle(int(self._rect.x), int(self._rect.y + self._rect.height - h),
+                        w, h, rl.Color(70, 91, 234, 255))
+
+    if DEBUG:
+      rl.draw_rectangle_lines_ex(STEP_RECTS[step], 3, rl.RED)
+
+    return -1
+
+
+class TermsPage(Widget):
+  def __init__(self, on_accept=None, on_decline=None):
+    super().__init__()
+    self._on_accept = on_accept
+    self._on_decline = on_decline
+
+    self._title = Label(tr("Welcome to openpilot"), 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 openpilot. Read the latest terms at https://comma.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_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
+    # TODO: Label doesn't top align when wrapping
+    desc_y = welcome_y - 100
+    desc_rect = rl.Rectangle(desc_x, desc_y, self._rect.width - desc_x, self._rect.height - desc_y - 250)
+    self._desc.render(desc_rect)
+
+    btn_y = self._rect.y + self._rect.height - 160 - 45
+    btn_width = (self._rect.width - 45 * 3) / 2
+    self._decline_btn.render(rl.Rectangle(self._rect.x + 45, btn_y, btn_width, 160))
+    self._accept_btn.render(rl.Rectangle(self._rect.x + 45 * 2 + btn_width, btn_y, btn_width, 160))
+
+    if DEBUG:
+      rl.draw_rectangle_lines_ex(welcome_rect, 3, rl.RED)
+      rl.draw_rectangle_lines_ex(desc_rect, 3, rl.RED)
+
+    return -1
+
+
+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 openpilot."),
+                       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 openpilot"), button_style=ButtonStyle.DANGER,
+                                 click_callback=self._on_uninstall_clicked)
+
+  def _on_uninstall_clicked(self):
+    ui_state.params.put_bool("DoUninstall", True)
+    gui_app.request_close()
+
+  def _render(self, _):
+    btn_y = self._rect.y + self._rect.height - 160 - 45
+    btn_width = (self._rect.width - 45 * 3) / 2
+    self._back_btn.render(rl.Rectangle(self._rect.x + 45, btn_y, btn_width, 160))
+    self._uninstall_btn.render(rl.Rectangle(self._rect.x + 45 * 2 + btn_width, btn_y, btn_width, 160))
+
+    # text rect in middle of top and button
+    text_height = btn_y - (200 + 45)
+    text_rect = rl.Rectangle(self._rect.x + 165, self._rect.y + (btn_y - text_height) / 2 + 10, self._rect.width - (165 * 2), text_height)
+    if DEBUG:
+      rl.draw_rectangle_lines_ex(text_rect, 3, rl.RED)
+    self._text.render(text_rect)
+
+
+class OnboardingWindow(Widget):
+  def __init__(self):
+    super().__init__()
+    self._current_terms_version = ui_state.params.get("TermsVersion")
+    self._current_training_version = ui_state.params.get("TrainingVersion")
+    self._accepted_terms: bool = ui_state.params.get("HasAcceptedTerms") == self._current_terms_version
+    self._training_done: bool = ui_state.params.get("CompletedTrainingVersion") == self._current_training_version
+
+    self._state = OnboardingState.TERMS if not self._accepted_terms else OnboardingState.ONBOARDING
+
+    # Windows
+    self._terms = TermsPage(on_accept=self._on_terms_accepted, on_decline=self._on_terms_declined)
+    self._training_guide: TrainingGuide | None = None
+    self._decline_page = DeclinePage(back_callback=self._on_decline_back)
+
+  @property
+  def completed(self) -> bool:
+    return self._accepted_terms and self._training_done
+
+  def _on_terms_declined(self):
+    self._state = OnboardingState.DECLINE
+
+  def _on_decline_back(self):
+    self._state = OnboardingState.TERMS
+
+  def _on_terms_accepted(self):
+    ui_state.params.put("HasAcceptedTerms", self._current_terms_version)
+    self._state = OnboardingState.ONBOARDING
+    if self._training_done:
+      gui_app.set_modal_overlay(None)
+
+  def _on_completed_training(self):
+    ui_state.params.put("CompletedTrainingVersion", self._current_training_version)
+    gui_app.set_modal_overlay(None)
+
+  def _render(self, _):
+    if self._training_guide is None:
+      self._training_guide = TrainingGuide(completed_callback=self._on_completed_training)
+
+    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.DECLINE:
+      self._decline_page.render(self._rect)
+    return -1
@@ -1,20 +1,30 @@
 from openpilot.common.params import Params
 from openpilot.selfdrive.ui.widgets.ssh_key import ssh_key_item
+from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.list_view import toggle_item
 from openpilot.system.ui.widgets.scroller import Scroller
+from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
+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

 # Description constants
 DESCRIPTIONS = {
-  'enable_adb': (
+  'enable_adb': tr_noop(
    "ADB (Android Debug Bridge) allows connecting to your device over USB or over the network. " +
    "See https://docs.comma.ai/how-to/connect-to-comma for more info."
  ),
-  'joystick_debug_mode': "Preview the driver facing camera to ensure that driver monitoring has good visibility. (vehicle must be off)",
-  'ssh_key': (
+  'ssh_key': tr_noop(
    "Warning: This grants SSH access to all public keys in your GitHub settings. Never enter a GitHub username " +
    "other than your own. A comma employee will NEVER ask you to add their GitHub username."
  ),
+  'alpha_longitudinal': tr_noop(
+    "<b>WARNING: openpilot longitudinal control is in alpha for this car and will disable Automatic Emergency Braking (AEB).</b><br><br>" +
+    "On this car, openpilot defaults to the car's built-in ACC instead of openpilot's longitudinal control. " +
+    "Enable this to switch to openpilot longitudinal control. Enabling Experimental mode is recommended when enabling openpilot longitudinal control alpha. " +
+    "Changing this setting will restart openpilot if the car is powered on."
+  ),
 }


@@ -22,40 +32,154 @@ class DeveloperLayout(Widget):
  def __init__(self):
    super().__init__()
    self._params = Params()
-    items = [
-      toggle_item(
-        "Enable ADB",
-        description=DESCRIPTIONS["enable_adb"],
-        initial_state=self._params.get_bool("AdbEnabled"),
-        callback=self._on_enable_adb,
-      ),
-      ssh_key_item("SSH Key", description=DESCRIPTIONS["ssh_key"]),
-      toggle_item(
-        "Joystick Debug Mode",
-        description=DESCRIPTIONS["joystick_debug_mode"],
-        initial_state=self._params.get_bool("JoystickDebugMode"),
-        callback=self._on_joystick_debug_mode,
-      ),
-      toggle_item(
-        "Longitudinal Maneuver Mode",
-        description="",
-        initial_state=self._params.get_bool("LongitudinalManeuverMode"),
-        callback=self._on_long_maneuver_mode,
-      ),
-      toggle_item(
-        "openpilot Longitudinal Control (Alpha)",
-        description="",
-        initial_state=self._params.get_bool("AlphaLongitudinalEnabled"),
-        callback=self._on_alpha_long_enabled,
-      ),
-    ]
+    self._is_release = self._params.get_bool("IsReleaseBranch")

-    self._scroller = Scroller(items, line_separator=True, spacing=0)
+    # Build items and keep references for callbacks/state updates
+    self._adb_toggle = toggle_item(
+      lambda: tr("Enable ADB"),
+      description=lambda: tr(DESCRIPTIONS["enable_adb"]),
+      initial_state=self._params.get_bool("AdbEnabled"),
+      callback=self._on_enable_adb,
+      enabled=ui_state.is_offroad,
+    )
+
+    # SSH enable toggle + SSH key management
+    self._ssh_toggle = toggle_item(
+      lambda: tr("Enable SSH"),
+      description="",
+      initial_state=self._params.get_bool("SshEnabled"),
+      callback=self._on_enable_ssh,
+    )
+    self._ssh_keys = ssh_key_item(lambda: tr("SSH Keys"), description=lambda: tr(DESCRIPTIONS["ssh_key"]))
+
+    self._joystick_toggle = toggle_item(
+      lambda: tr("Joystick Debug Mode"),
+      description="",
+      initial_state=self._params.get_bool("JoystickDebugMode"),
+      callback=self._on_joystick_debug_mode,
+      enabled=ui_state.is_offroad,
+    )
+
+    self._long_maneuver_toggle = toggle_item(
+      lambda: tr("Longitudinal Maneuver Mode"),
+      description="",
+      initial_state=self._params.get_bool("LongitudinalManeuverMode"),
+      callback=self._on_long_maneuver_mode,
+    )
+
+    self._alpha_long_toggle = toggle_item(
+      lambda: tr("openpilot Longitudinal Control (Alpha)"),
+      description=lambda: tr(DESCRIPTIONS["alpha_longitudinal"]),
+      initial_state=self._params.get_bool("AlphaLongitudinalEnabled"),
+      callback=self._on_alpha_long_enabled,
+      enabled=lambda: not ui_state.engaged,
+    )
+
+    self._ui_debug_toggle = toggle_item(
+      lambda: tr("UI Debug Mode"),
+      description="",
+      initial_state=self._params.get_bool("ShowDebugInfo"),
+      callback=self._on_enable_ui_debug,
+    )
+    self._on_enable_ui_debug(self._params.get_bool("ShowDebugInfo"))
+
+    self._scroller = Scroller([
+      self._adb_toggle,
+      self._ssh_toggle,
+      self._ssh_keys,
+      self._joystick_toggle,
+      self._long_maneuver_toggle,
+      self._alpha_long_toggle,
+      self._ui_debug_toggle,
+    ], line_separator=True, spacing=0)
+
+    # Toggles should be not available to change in onroad state
+    ui_state.add_offroad_transition_callback(self._update_toggles)

  def _render(self, rect):
    self._scroller.render(rect)

-  def _on_enable_adb(self): pass
-  def _on_joystick_debug_mode(self): pass
-  def _on_long_maneuver_mode(self): pass
-  def _on_alpha_long_enabled(self): pass
+  def show_event(self):
+    self._scroller.show_event()
+    self._update_toggles()
+
+  def _update_toggles(self):
+    ui_state.update_params()
+
+    # Hide non-release toggles on release builds
+    # TODO: we can do an onroad cycle, but alpha long toggle requires a deinit function to re-enable radar and not fault
+    for item in (self._joystick_toggle, self._long_maneuver_toggle, self._alpha_long_toggle):
+      item.set_visible(not self._is_release)
+
+    # CP gating
+    if ui_state.CP is not None:
+      alpha_avail = ui_state.CP.alphaLongitudinalAvailable
+      if not alpha_avail or self._is_release:
+        self._alpha_long_toggle.set_visible(False)
+        self._params.remove("AlphaLongitudinalEnabled")
+      else:
+        self._alpha_long_toggle.set_visible(True)
+
+      long_man_enabled = ui_state.has_longitudinal_control and ui_state.is_offroad()
+      self._long_maneuver_toggle.action_item.set_enabled(long_man_enabled)
+      if not long_man_enabled:
+        self._long_maneuver_toggle.action_item.set_state(False)
+        self._params.put_bool("LongitudinalManeuverMode", False)
+    else:
+      self._long_maneuver_toggle.action_item.set_enabled(False)
+      self._alpha_long_toggle.set_visible(False)
+
+    # TODO: make a param control list item so we don't need to manage internal state as much here
+    # refresh toggles from params to mirror external changes
+    for key, item in (
+      ("AdbEnabled", self._adb_toggle),
+      ("SshEnabled", self._ssh_toggle),
+      ("JoystickDebugMode", self._joystick_toggle),
+      ("LongitudinalManeuverMode", self._long_maneuver_toggle),
+      ("AlphaLongitudinalEnabled", self._alpha_long_toggle),
+      ("ShowDebugInfo", self._ui_debug_toggle),
+    ):
+      item.action_item.set_state(self._params.get_bool(key))
+
+  def _on_enable_ui_debug(self, state: bool):
+    self._params.put_bool("ShowDebugInfo", state)
+    gui_app.set_show_touches(state)
+    gui_app.set_show_fps(state)
+
+  def _on_enable_adb(self, state: bool):
+    self._params.put_bool("AdbEnabled", state)
+
+  def _on_enable_ssh(self, state: bool):
+    self._params.put_bool("SshEnabled", state)
+
+  def _on_joystick_debug_mode(self, state: bool):
+    self._params.put_bool("JoystickDebugMode", state)
+    self._params.put_bool("LongitudinalManeuverMode", False)
+    self._long_maneuver_toggle.action_item.set_state(False)
+
+  def _on_long_maneuver_mode(self, state: bool):
+    self._params.put_bool("LongitudinalManeuverMode", state)
+    self._params.put_bool("JoystickDebugMode", False)
+    self._joystick_toggle.action_item.set_state(False)
+
+  def _on_alpha_long_enabled(self, state: bool):
+    if state:
+      def confirm_callback(result: int):
+        if result == DialogResult.CONFIRM:
+          self._params.put_bool("AlphaLongitudinalEnabled", True)
+          self._params.put_bool("OnroadCycleRequested", True)
+          self._update_toggles()
+        else:
+          self._alpha_long_toggle.action_item.set_state(False)
+
+      # show confirmation dialog
+      content = (f"<h1>{self._alpha_long_toggle.title}</h1><br>" +
+                 f"<p>{self._alpha_long_toggle.description}</p>")
+
+      dlg = ConfirmDialog(content, tr("Enable"), rich=True)
+      gui_app.set_modal_overlay(dlg, callback=confirm_callback)
+
+    else:
+      self._params.put_bool("AlphaLongitudinalEnabled", False)
+      self._params.put_bool("OnroadCycleRequested", True)
+      self._update_toggles()
@@ -1,29 +1,30 @@
 import os
-import json
+import math

+from cereal import messaging, log
 from openpilot.common.basedir import BASEDIR
 from openpilot.common.params import Params
+from openpilot.common.swaglog import cloudlog
 from openpilot.selfdrive.ui.onroad.driver_camera_dialog import DriverCameraDialog
 from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.selfdrive.ui.layouts.onboarding import TrainingGuide
 from openpilot.selfdrive.ui.widgets.pairing_dialog import PairingDialog
 from openpilot.system.hardware import TICI
-from openpilot.system.ui.lib.application import gui_app
+from openpilot.system.ui.lib.application import FontWeight, gui_app
+from openpilot.system.ui.lib.multilang import multilang, tr, tr_noop
 from openpilot.system.ui.widgets import Widget, DialogResult
-from openpilot.system.ui.widgets.confirm_dialog import confirm_dialog, alert_dialog
-from openpilot.system.ui.widgets.html_render import HtmlRenderer
+from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog, alert_dialog
+from openpilot.system.ui.widgets.html_render import HtmlModal
 from openpilot.system.ui.widgets.list_view import text_item, button_item, dual_button_item
 from openpilot.system.ui.widgets.option_dialog import MultiOptionDialog
 from openpilot.system.ui.widgets.scroller import Scroller

 # Description constants
 DESCRIPTIONS = {
-  'pair_device': "Pair your device with comma connect (connect.comma.ai) and claim your comma prime offer.",
-  'driver_camera': "Preview the driver facing camera to ensure that driver monitoring has good visibility. (vehicle must be off)",
-  'reset_calibration': (
-      "openpilot requires the device to be mounted within 4° left or right and within 5° " +
-      "up or 9° down. openpilot is continuously calibrating, resetting is rarely required."
-  ),
-  'review_guide': "Review the rules, features, and limitations of openpilot",
+  'pair_device': tr_noop("Pair your device with comma connect (connect.comma.ai) and claim your comma prime offer."),
+  'driver_camera': tr_noop("Preview the driver facing camera to ensure that driver monitoring has good visibility. (vehicle must be off)"),
+  'reset_calibration': tr_noop("openpilot requires the device to be mounted within 4° left or right and within 5° up or 9° down."),
+  'review_guide': tr_noop("Review the rules, features, and limitations of openpilot"),
 }


@@ -35,49 +36,61 @@ class DeviceLayout(Widget):
    self._select_language_dialog: MultiOptionDialog | None = None
    self._driver_camera: DriverCameraDialog | None = None
    self._pair_device_dialog: PairingDialog | None = None
-    self._fcc_dialog: HtmlRenderer | None = None
+    self._fcc_dialog: HtmlModal | None = None
+    self._training_guide: TrainingGuide | None = None

    items = self._initialize_items()
    self._scroller = Scroller(items, line_separator=True, spacing=0)

+    ui_state.add_offroad_transition_callback(self._offroad_transition)
+
  def _initialize_items(self):
-    dongle_id = self._params.get("DongleId") or "N/A"
-    serial = self._params.get("HardwareSerial") or "N/A"
+    self._pair_device_btn = button_item(lambda: tr("Pair Device"), lambda: tr("PAIR"), lambda: tr(DESCRIPTIONS['pair_device']), callback=self._pair_device)
+    self._pair_device_btn.set_visible(lambda: not ui_state.prime_state.is_paired())
+
+    self._reset_calib_btn = button_item(lambda: tr("Reset Calibration"), lambda: tr("RESET"), lambda: tr(DESCRIPTIONS['reset_calibration']),
+                                        callback=self._reset_calibration_prompt)
+    self._reset_calib_btn.set_description_opened_callback(self._update_calib_description)
+
+    self._power_off_btn = dual_button_item(lambda: tr("Reboot"), lambda: tr("Power Off"),
+                                           left_callback=self._reboot_prompt, right_callback=self._power_off_prompt)

    items = [
-      text_item("Dongle ID", dongle_id),
-      text_item("Serial", serial),
-      button_item("Pair Device", "PAIR", DESCRIPTIONS['pair_device'], callback=self._pair_device),
-      button_item("Driver Camera", "PREVIEW", DESCRIPTIONS['driver_camera'], callback=self._show_driver_camera, enabled=ui_state.is_offroad),
-      button_item("Reset Calibration", "RESET", DESCRIPTIONS['reset_calibration'], callback=self._reset_calibration_prompt),
-      regulatory_btn := button_item("Regulatory", "VIEW", callback=self._on_regulatory),
-      button_item("Review Training Guide", "REVIEW", DESCRIPTIONS['review_guide'], self._on_review_training_guide),
-      button_item("Change Language", "CHANGE", callback=self._show_language_selection, enabled=ui_state.is_offroad),
-      dual_button_item("Reboot", "Power Off", left_callback=self._reboot_prompt, right_callback=self._power_off_prompt),
+      text_item(lambda: tr("Dongle ID"), self._params.get("DongleId") or (lambda: tr("N/A"))),
+      text_item(lambda: tr("Serial"), self._params.get("HardwareSerial") or (lambda: tr("N/A"))),
+      self._pair_device_btn,
+      button_item(lambda: tr("Driver Camera"), lambda: tr("PREVIEW"), lambda: tr(DESCRIPTIONS['driver_camera']),
+                  callback=self._show_driver_camera, enabled=ui_state.is_offroad),
+      self._reset_calib_btn,
+      button_item(lambda: tr("Review Training Guide"), lambda: tr("REVIEW"), lambda: tr(DESCRIPTIONS['review_guide']),
+                  self._on_review_training_guide, enabled=ui_state.is_offroad),
+      regulatory_btn := button_item(lambda: tr("Regulatory"), lambda: tr("VIEW"), callback=self._on_regulatory, enabled=ui_state.is_offroad),
+      button_item(lambda: tr("Change Language"), lambda: tr("CHANGE"), callback=self._show_language_dialog),
+      self._power_off_btn,
    ]
    regulatory_btn.set_visible(TICI)
    return items

+  def _offroad_transition(self):
+    self._power_off_btn.action_item.right_button.set_visible(ui_state.is_offroad())
+
+  def show_event(self):
+    self._scroller.show_event()
+
  def _render(self, rect):
    self._scroller.render(rect)

-  def _show_language_selection(self):
-    try:
-      languages_file = os.path.join(BASEDIR, "selfdrive/ui/translations/languages.json")
-      with open(languages_file, encoding='utf-8') as f:
-        languages = json.load(f)
+  def _show_language_dialog(self):
+    def handle_language_selection(result: int):
+      if result == 1 and self._select_language_dialog:
+        selected_language = multilang.languages[self._select_language_dialog.selection]
+        multilang.change_language(selected_language)
+        self._update_calib_description()
+      self._select_language_dialog = None

-      self._select_language_dialog = MultiOptionDialog("Select a language", languages)
-      gui_app.set_modal_overlay(self._select_language_dialog, callback=self._handle_language_selection)
-    except FileNotFoundError:
-      pass
-
-  def _handle_language_selection(self, result: int):
-    if result == 1 and self._select_language_dialog:
-      selected_language = self._select_language_dialog.selection
-      self._params.put("LanguageSetting", selected_language)
-
-    self._select_language_dialog = None
+    self._select_language_dialog = MultiOptionDialog(tr("Select a language"), multilang.languages, multilang.codes[multilang.language],
+                                                     option_font_weight=FontWeight.UNIFONT)
+    gui_app.set_modal_overlay(self._select_language_dialog, callback=handle_language_selection)

  def _show_driver_camera(self):
    if not self._driver_camera:
@@ -87,34 +100,80 @@ class DeviceLayout(Widget):

  def _reset_calibration_prompt(self):
    if ui_state.engaged:
-      gui_app.set_modal_overlay(lambda: alert_dialog("Disengage to Reset Calibration"))
+      gui_app.set_modal_overlay(alert_dialog(tr("Disengage to Reset Calibration")))
      return

-    gui_app.set_modal_overlay(
-      lambda: confirm_dialog("Are you sure you want to reset calibration?", "Reset"),
-      callback=self._reset_calibration,
-    )
+    def reset_calibration(result: int):
+      # Check engaged again in case it changed while the dialog was open
+      if ui_state.engaged or result != DialogResult.CONFIRM:
+        return

-  def _reset_calibration(self, result: int):
-    if ui_state.engaged or result != DialogResult.CONFIRM:
-      return
+      self._params.remove("CalibrationParams")
+      self._params.remove("LiveTorqueParameters")
+      self._params.remove("LiveParameters")
+      self._params.remove("LiveParametersV2")
+      self._params.remove("LiveDelay")
+      self._params.put_bool("OnroadCycleRequested", True)
+      self._update_calib_description()

-    self._params.remove("CalibrationParams")
-    self._params.remove("LiveTorqueParameters")
-    self._params.remove("LiveParameters")
-    self._params.remove("LiveParametersV2")
-    self._params.remove("LiveDelay")
-    self._params.put_bool("OnroadCycleRequested", True)
+    dialog = ConfirmDialog(tr("Are you sure you want to reset calibration?"), tr("Reset"))
+    gui_app.set_modal_overlay(dialog, callback=reset_calibration)
+
+  def _update_calib_description(self):
+    desc = tr(DESCRIPTIONS['reset_calibration'])
+
+    calib_bytes = self._params.get("CalibrationParams")
+    if calib_bytes:
+      try:
+        calib = messaging.log_from_bytes(calib_bytes, log.Event).liveCalibration
+
+        if calib.calStatus != log.LiveCalibrationData.Status.uncalibrated:
+          pitch = math.degrees(calib.rpyCalib[1])
+          yaw = math.degrees(calib.rpyCalib[2])
+          desc += tr(" Your device is pointed {:.1f}° {} and {:.1f}° {}.").format(abs(pitch), tr("down") if pitch > 0 else tr("up"),
+                                                                                  abs(yaw), tr("left") if yaw > 0 else tr("right"))
+      except Exception:
+        cloudlog.exception("invalid CalibrationParams")
+
+    lag_perc = 0
+    lag_bytes = self._params.get("LiveDelay")
+    if lag_bytes:
+      try:
+        lag_perc = messaging.log_from_bytes(lag_bytes, log.Event).liveDelay.calPerc
+      except Exception:
+        cloudlog.exception("invalid LiveDelay")
+    if lag_perc < 100:
+      desc += tr("<br><br>Steering lag calibration is {}% complete.").format(lag_perc)
+    else:
+      desc += tr("<br><br>Steering lag calibration is complete.")
+
+    torque_bytes = self._params.get("LiveTorqueParameters")
+    if torque_bytes:
+      try:
+        torque = messaging.log_from_bytes(torque_bytes, log.Event).liveTorqueParameters
+        # don't add for non-torque cars
+        if torque.useParams:
+          torque_perc = torque.calPerc
+          if torque_perc < 100:
+            desc += tr(" Steering torque response calibration is {}% complete.").format(torque_perc)
+          else:
+            desc += tr(" Steering torque response calibration is complete.")
+      except Exception:
+        cloudlog.exception("invalid LiveTorqueParameters")
+
+    desc += "<br><br>"
+    desc += tr("openpilot is continuously calibrating, resetting is rarely required. " +
+               "Resetting calibration will restart openpilot if the car is powered on.")
+
+    self._reset_calib_btn.set_description(desc)

  def _reboot_prompt(self):
    if ui_state.engaged:
-      gui_app.set_modal_overlay(lambda: alert_dialog("Disengage to Reboot"))
+      gui_app.set_modal_overlay(alert_dialog(tr("Disengage to Reboot")))
      return

-    gui_app.set_modal_overlay(
-      lambda: confirm_dialog("Are you sure you want to reboot?", "Reboot"),
-      callback=self._perform_reboot,
-    )
+    dialog = ConfirmDialog(tr("Are you sure you want to reboot?"), tr("Reboot"))
+    gui_app.set_modal_overlay(dialog, callback=self._perform_reboot)

  def _perform_reboot(self, result: int):
    if not ui_state.engaged and result == DialogResult.CONFIRM:
@@ -122,13 +181,11 @@ class DeviceLayout(Widget):

  def _power_off_prompt(self):
    if ui_state.engaged:
-      gui_app.set_modal_overlay(lambda: alert_dialog("Disengage to Power Off"))
+      gui_app.set_modal_overlay(alert_dialog(tr("Disengage to Power Off")))
      return

-    gui_app.set_modal_overlay(
-      lambda: confirm_dialog("Are you sure you want to power off?", "Power Off"),
-      callback=self._perform_power_off,
-    )
+    dialog = ConfirmDialog(tr("Are you sure you want to power off?"), tr("Power Off"))
+    gui_app.set_modal_overlay(dialog, callback=self._perform_power_off)

  def _perform_power_off(self, result: int):
    if not ui_state.engaged and result == DialogResult.CONFIRM:
@@ -141,10 +198,13 @@ class DeviceLayout(Widget):

  def _on_regulatory(self):
    if not self._fcc_dialog:
-      self._fcc_dialog = HtmlRenderer(os.path.join(BASEDIR, "selfdrive/assets/offroad/fcc.html"))
+      self._fcc_dialog = HtmlModal(os.path.join(BASEDIR, "selfdrive/assets/offroad/fcc.html"))
+    gui_app.set_modal_overlay(self._fcc_dialog)

-    gui_app.set_modal_overlay(self._fcc_dialog,
-      callback=lambda result: setattr(self, '_fcc_dialog', None),
-    )
+  def _on_review_training_guide(self):
+    if not self._training_guide:
+      def completed_callback():
+        gui_app.set_modal_overlay(None)

-  def _on_review_training_guide(self): pass
+      self._training_guide = TrainingGuide(completed_callback=completed_callback)
+    gui_app.set_modal_overlay(self._training_guide)
@@ -7,21 +7,23 @@ from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.athena.registration import UNREGISTERED_DONGLE_ID
-from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.application import gui_app, FontWeight, FONT_SCALE
+from openpilot.system.ui.lib.multilang import tr, trn, tr_noop
+from openpilot.system.ui.lib.text_measure import measure_text_cached
 from openpilot.system.ui.lib.scroll_panel import GuiScrollPanel
 from openpilot.system.ui.lib.wrap_text import wrap_text
 from openpilot.system.ui.widgets import Widget
 from openpilot.selfdrive.ui.lib.api_helpers import get_token

-TITLE = "Firehose Mode"
-DESCRIPTION = (
+TITLE = tr_noop("Firehose Mode")
+DESCRIPTION = tr_noop(
  "openpilot learns to drive by watching humans, like you, drive.\n\n"
  + "Firehose Mode allows you to maximize your training data uploads to improve "
  + "openpilot's driving models. More data means bigger models, which means better Experimental Mode."
 )
-INSTRUCTIONS = (
+INSTRUCTIONS = tr_noop(
  "For maximum effectiveness, bring your device inside and connect to a good USB-C adapter and Wi-Fi weekly.\n\n"
-  + "Firehose Mode can also work while you're driving if connected to a hotspot or unlimited SIM card.\n\n"
+  + "Firehose Mode can also work while you're driving if connected to a hotspot or unlimited SIM card.\n\n\n"
  + "Frequently Asked Questions\n\n"
  + "Does it matter how or where I drive? Nope, just drive as you normally would.\n\n"
  + "Do all of my segments get pulled in Firehose Mode? No, we selectively pull a subset of your segments.\n\n"
@@ -43,12 +45,16 @@ class FirehoseLayout(Widget):
    self.params = Params()
    self.segment_count = self._get_segment_count()
    self.scroll_panel = GuiScrollPanel()
+    self._content_height = 0

    self.running = True
    self.update_thread = threading.Thread(target=self._update_loop, daemon=True)
    self.update_thread.start()
    self.last_update_time = 0

+  def show_event(self):
+    self.scroll_panel.set_offset(0)
+
  def _get_segment_count(self) -> int:
    stats = self.params.get(self.PARAM_KEY)
    if not stats:
@@ -66,97 +72,72 @@ class FirehoseLayout(Widget):

  def _render(self, rect: rl.Rectangle):
    # Calculate content dimensions
-    content_width = rect.width - 80
-    content_height = self._calculate_content_height(int(content_width))
-    content_rect = rl.Rectangle(rect.x, rect.y, rect.width, content_height)
+    content_rect = rl.Rectangle(rect.x, rect.y, rect.width, self._content_height)

    # Handle scrolling and render with clipping
-    scroll_offset = self.scroll_panel.handle_scroll(rect, content_rect)
+    scroll_offset = self.scroll_panel.update(rect, content_rect)
    rl.begin_scissor_mode(int(rect.x), int(rect.y), int(rect.width), int(rect.height))
-    self._render_content(rect, scroll_offset)
+    self._content_height = self._render_content(rect, scroll_offset)
    rl.end_scissor_mode()

-  def _calculate_content_height(self, content_width: int) -> int:
-    height = 80  # Top margin
-
-    # Title
-    height += 100 + 40
-
-    # Description
-    desc_font = gui_app.font(FontWeight.NORMAL)
-    desc_lines = wrap_text(desc_font, DESCRIPTION, 45, content_width)
-    height += len(desc_lines) * 45 + 40
-
-    # Status section
-    height += 32  # Separator
-    status_text, _ = self._get_status()
-    status_lines = wrap_text(gui_app.font(FontWeight.BOLD), status_text, 60, content_width)
-    height += len(status_lines) * 60 + 20
-
-    # Contribution count (if available)
-    if self.segment_count > 0:
-      contrib_text = f"{self.segment_count} segment(s) of your driving is in the training dataset so far."
-      contrib_lines = wrap_text(gui_app.font(FontWeight.BOLD), contrib_text, 52, content_width)
-      height += len(contrib_lines) * 52 + 20
-
-    # Instructions section
-    height += 32  # Separator
-    inst_lines = wrap_text(gui_app.font(FontWeight.NORMAL), INSTRUCTIONS, 40, content_width)
-    height += len(inst_lines) * 40 + 40  # Bottom margin
-
-    return height
-
-  def _render_content(self, rect: rl.Rectangle, scroll_offset: rl.Vector2):
+  def _render_content(self, rect: rl.Rectangle, scroll_offset: float) -> int:
    x = int(rect.x + 40)
-    y = int(rect.y + 40 + scroll_offset.y)
+    y = int(rect.y + 40 + scroll_offset)
    w = int(rect.width - 80)

-    # Title
+    # Title (centered)
+    title_text = tr(TITLE)  # live translate
    title_font = gui_app.font(FontWeight.MEDIUM)
-    rl.draw_text_ex(title_font, TITLE, rl.Vector2(x, y), 100, 0, rl.WHITE)
-    y += 140
+    text_width = measure_text_cached(title_font, title_text, 100).x
+    title_x = rect.x + (rect.width - text_width) / 2
+    rl.draw_text_ex(title_font, title_text, rl.Vector2(title_x, y), 100, 0, rl.WHITE)
+    y += 200

    # Description
-    y = self._draw_wrapped_text(x, y, w, DESCRIPTION, gui_app.font(FontWeight.NORMAL), 45, rl.WHITE)
-    y += 40
+    y = self._draw_wrapped_text(x, y, w, tr(DESCRIPTION), gui_app.font(FontWeight.NORMAL), 45, rl.WHITE)
+    y += 40 + 20

    # Separator
    rl.draw_rectangle(x, y, w, 2, self.GRAY)
-    y += 30
+    y += 30 + 20

    # Status
    status_text, status_color = self._get_status()
    y = self._draw_wrapped_text(x, y, w, status_text, gui_app.font(FontWeight.BOLD), 60, status_color)
-    y += 20
+    y += 20 + 20

    # Contribution count (if available)
    if self.segment_count > 0:
-      contrib_text = f"{self.segment_count} segment(s) of your driving is in the training dataset so far."
+      contrib_text = trn("{} segment of your driving is in the training dataset so far.",
+                         "{} segments of your driving is in the training dataset so far.", self.segment_count).format(self.segment_count)
      y = self._draw_wrapped_text(x, y, w, contrib_text, gui_app.font(FontWeight.BOLD), 52, rl.WHITE)
-      y += 20
+      y += 20 + 20

    # Separator
    rl.draw_rectangle(x, y, w, 2, self.GRAY)
-    y += 30
+    y += 30 + 20

    # Instructions
-    self._draw_wrapped_text(x, y, w, INSTRUCTIONS, gui_app.font(FontWeight.NORMAL), 40, self.LIGHT_GRAY)
+    y = self._draw_wrapped_text(x, y, w, tr(INSTRUCTIONS), gui_app.font(FontWeight.NORMAL), 40, self.LIGHT_GRAY)

-  def _draw_wrapped_text(self, x, y, width, text, font, size, color):
-    wrapped = wrap_text(font, text, size, width)
+    # bottom margin + remove effect of scroll offset
+    return int(round(y - self.scroll_panel.offset + 40))
+
+  def _draw_wrapped_text(self, x, y, width, text, font, font_size, color):
+    wrapped = wrap_text(font, text, font_size, width)
    for line in wrapped:
-      rl.draw_text_ex(font, line, rl.Vector2(x, y), size, 0, color)
-      y += size
-    return y
+      rl.draw_text_ex(font, line, rl.Vector2(x, y), font_size, 0, color)
+      y += font_size * FONT_SCALE
+    return round(y)

  def _get_status(self) -> tuple[str, rl.Color]:
    network_type = ui_state.sm["deviceState"].networkType
    network_metered = ui_state.sm["deviceState"].networkMetered

    if not network_metered and network_type != 0:  # Not metered and connected
-      return "ACTIVE", self.GREEN
+      return tr("ACTIVE"), self.GREEN
    else:
-      return "INACTIVE: connect to an unmetered network", self.RED
+      return tr("INACTIVE: connect to an unmetered network"), self.RED

  def _fetch_firehose_stats(self):
    try:
@@ -8,18 +8,16 @@ from openpilot.selfdrive.ui.layouts.settings.firehose import FirehoseLayout
 from openpilot.selfdrive.ui.layouts.settings.software import SoftwareLayout
 from openpilot.selfdrive.ui.layouts.settings.toggles import TogglesLayout
 from openpilot.system.ui.lib.application import gui_app, FontWeight, MousePos
+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.lib.wifi_manager import WifiManager
 from openpilot.system.ui.widgets import Widget
-from openpilot.system.ui.widgets.network import WifiManagerUI
-
-# Settings close button
-SETTINGS_CLOSE_TEXT = "×"
-SETTINGS_CLOSE_TEXT_Y_OFFSET = 8  # The '×' character isn't quite vertically centered in the font so we need to offset it a bit to fully center it
+from openpilot.system.ui.widgets.network import NetworkUI

 # Constants
 SIDEBAR_WIDTH = 500
 CLOSE_BTN_SIZE = 200
+CLOSE_ICON_SIZE = 70
 NAV_BTN_HEIGHT = 110
 PANEL_MARGIN = 50

@@ -58,15 +56,16 @@ class SettingsLayout(Widget):
    wifi_manager.set_active(False)

    self._panels = {
-      PanelType.DEVICE: PanelInfo("Device", DeviceLayout()),
-      PanelType.NETWORK: PanelInfo("Network", WifiManagerUI(wifi_manager)),
-      PanelType.TOGGLES: PanelInfo("Toggles", TogglesLayout()),
-      PanelType.SOFTWARE: PanelInfo("Software", SoftwareLayout()),
-      PanelType.FIREHOSE: PanelInfo("Firehose", FirehoseLayout()),
-      PanelType.DEVELOPER: PanelInfo("Developer", DeveloperLayout()),
+      PanelType.DEVICE: PanelInfo(tr_noop("Device"), DeviceLayout()),
+      PanelType.NETWORK: PanelInfo(tr_noop("Network"), NetworkUI(wifi_manager)),
+      PanelType.TOGGLES: PanelInfo(tr_noop("Toggles"), TogglesLayout()),
+      PanelType.SOFTWARE: PanelInfo(tr_noop("Software"), SoftwareLayout()),
+      PanelType.FIREHOSE: PanelInfo(tr_noop("Firehose"), FirehoseLayout()),
+      PanelType.DEVELOPER: PanelInfo(tr_noop("Developer"), DeveloperLayout()),
    }

    self._font_medium = gui_app.font(FontWeight.MEDIUM)
+    self._close_icon = gui_app.texture("icons/close2.png", CLOSE_ICON_SIZE, CLOSE_ICON_SIZE)

    # Callbacks
    self._close_callback: Callable | None = None
@@ -96,12 +95,21 @@ class SettingsLayout(Widget):
    close_color = CLOSE_BTN_PRESSED if pressed else CLOSE_BTN_COLOR
    rl.draw_rectangle_rounded(close_btn_rect, 1.0, 20, close_color)

-    close_text_size = measure_text_cached(self._font_medium, SETTINGS_CLOSE_TEXT, 140)
-    close_text_pos = rl.Vector2(
-      close_btn_rect.x + (close_btn_rect.width - close_text_size.x) / 2,
-      close_btn_rect.y + (close_btn_rect.height - close_text_size.y) / 2 - SETTINGS_CLOSE_TEXT_Y_OFFSET,
+    icon_color = rl.Color(255, 255, 255, 255) if not pressed else rl.Color(220, 220, 220, 255)
+    icon_dest = rl.Rectangle(
+      close_btn_rect.x + (close_btn_rect.width - self._close_icon.width) / 2,
+      close_btn_rect.y + (close_btn_rect.height - self._close_icon.height) / 2,
+      self._close_icon.width,
+      self._close_icon.height,
+    )
+    rl.draw_texture_pro(
+      self._close_icon,
+      rl.Rectangle(0, 0, self._close_icon.width, self._close_icon.height),
+      icon_dest,
+      rl.Vector2(0, 0),
+      0,
+      icon_color,
    )
-    rl.draw_text_ex(self._font_medium, SETTINGS_CLOSE_TEXT, close_text_pos, 140, 0, TEXT_SELECTED)

    # Store close button rect for click detection
    self._close_btn_rect = close_btn_rect
@@ -115,11 +123,12 @@ class SettingsLayout(Widget):
      is_selected = panel_type == self._current_panel
      text_color = TEXT_SELECTED if is_selected else TEXT_NORMAL
      # Draw button text (right-aligned)
-      text_size = measure_text_cached(self._font_medium, panel_info.name, 65)
+      panel_name = tr(panel_info.name)
+      text_size = measure_text_cached(self._font_medium, panel_name, 65)
      text_pos = rl.Vector2(
        button_rect.x + button_rect.width - text_size.x, button_rect.y + (button_rect.height - text_size.y) / 2
      )
-      rl.draw_text_ex(self._font_medium, panel_info.name, text_pos, 65, 0, text_color)
+      rl.draw_text_ex(self._font_medium, panel_name, text_pos, 65, 0, text_color)

      # Store button rect for click detection
      panel_info.button_rect = button_rect
@@ -1,42 +1,194 @@
-from openpilot.common.params import Params
+import os
+import time
+import datetime
+from openpilot.common.time_helpers import system_time_valid
+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, trn
 from openpilot.system.ui.widgets import Widget, DialogResult
-from openpilot.system.ui.widgets.confirm_dialog import confirm_dialog
-from openpilot.system.ui.widgets.list_view import button_item, text_item
+from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
+from openpilot.system.ui.widgets.list_view import button_item, text_item, ListItem
+from openpilot.system.ui.widgets.option_dialog import MultiOptionDialog
 from openpilot.system.ui.widgets.scroller import Scroller

+# TODO: remove this. updater fails to respond on startup if time is not correct
+UPDATED_TIMEOUT = 10  # seconds to wait for updated to respond
+
+
+def time_ago(date: datetime.datetime | None) -> str:
+  if not date:
+    return tr("never")
+
+  if not system_time_valid():
+    return date.strftime("%a %b %d %Y")
+
+  now = datetime.datetime.now(datetime.UTC)
+  if date.tzinfo is None:
+    date = date.replace(tzinfo=datetime.UTC)
+
+  diff_seconds = int((now - date).total_seconds())
+  if diff_seconds < 60:
+    return tr("now")
+  if diff_seconds < 3600:
+    m = diff_seconds // 60
+    return trn("{} minute ago", "{} minutes ago", m).format(m)
+  if diff_seconds < 86400:
+    h = diff_seconds // 3600
+    return trn("{} hour ago", "{} hours ago", h).format(h)
+  if diff_seconds < 604800:
+    d = diff_seconds // 86400
+    return trn("{} day ago", "{} days ago", d).format(d)
+  return date.strftime("%a %b %d %Y")
+

 class SoftwareLayout(Widget):
  def __init__(self):
    super().__init__()

-    self._params = Params()
-    items = self._init_items()
-    self._scroller = Scroller(items, line_separator=True, spacing=0)
+    self._onroad_label = ListItem(lambda: tr("Updates are only downloaded while the car is off."))
+    self._version_item = text_item(lambda: tr("Current Version"), ui_state.params.get("UpdaterCurrentDescription") or "")
+    self._download_btn = button_item(lambda: tr("Download"), lambda: tr("CHECK"), callback=self._on_download_update)

-  def _init_items(self):
-    items = [
-      text_item("Current Version", ""),
-      button_item("Download", "CHECK", callback=self._on_download_update),
-      button_item("Install Update", "INSTALL", callback=self._on_install_update),
-      button_item("Target Branch", "SELECT", callback=self._on_select_branch),
-      button_item("Uninstall", "UNINSTALL", callback=self._on_uninstall),
-    ]
-    return items
+    # Install button is initially hidden
+    self._install_btn = button_item(lambda: tr("Install Update"), lambda: tr("INSTALL"), callback=self._on_install_update)
+    self._install_btn.set_visible(False)
+
+    # Track waiting-for-updater transition to avoid brief re-enable while still idle
+    self._waiting_for_updater = False
+    self._waiting_start_ts: float = 0.0
+
+    # Branch switcher
+    self._branch_btn = button_item(lambda: tr("Target Branch"), lambda: tr("SELECT"), callback=self._on_select_branch)
+    self._branch_btn.set_visible(not ui_state.params.get_bool("IsTestedBranch"))
+    self._branch_btn.action_item.set_value(ui_state.params.get("UpdaterTargetBranch") or "")
+    self._branch_dialog: MultiOptionDialog | None = None
+
+    self._scroller = Scroller([
+      self._onroad_label,
+      self._version_item,
+      self._download_btn,
+      self._install_btn,
+      self._branch_btn,
+      button_item(lambda: tr("Uninstall"), lambda: tr("UNINSTALL"), callback=self._on_uninstall),
+    ], line_separator=True, spacing=0)
+
+  def show_event(self):
+    self._scroller.show_event()

  def _render(self, rect):
    self._scroller.render(rect)

-  def _on_download_update(self): pass
-  def _on_install_update(self): pass
-  def _on_select_branch(self): pass
+  def _update_state(self):
+    # Show/hide onroad warning
+    self._onroad_label.set_visible(ui_state.is_onroad())
+
+    # Update current version and release notes
+    current_desc = ui_state.params.get("UpdaterCurrentDescription") or ""
+    current_release_notes = (ui_state.params.get("UpdaterCurrentReleaseNotes") or b"").decode("utf-8", "replace")
+    self._version_item.action_item.set_text(current_desc)
+    self._version_item.set_description(current_release_notes)
+
+    # Update download button visibility and state
+    self._download_btn.set_visible(ui_state.is_offroad())
+
+    updater_state = ui_state.params.get("UpdaterState") or "idle"
+    failed_count = ui_state.params.get("UpdateFailedCount") or 0
+    fetch_available = ui_state.params.get_bool("UpdaterFetchAvailable")
+    update_available = ui_state.params.get_bool("UpdateAvailable")
+
+    if updater_state != "idle":
+      # Updater responded
+      self._waiting_for_updater = False
+      self._download_btn.action_item.set_enabled(False)
+      self._download_btn.action_item.set_value(updater_state)
+    else:
+      if failed_count > 0:
+        self._download_btn.action_item.set_value(tr("failed to check for update"))
+        self._download_btn.action_item.set_text(tr("CHECK"))
+      elif fetch_available:
+        self._download_btn.action_item.set_value(tr("update available"))
+        self._download_btn.action_item.set_text(tr("DOWNLOAD"))
+      else:
+        last_update = ui_state.params.get("LastUpdateTime")
+        if last_update:
+          formatted = time_ago(last_update)
+          self._download_btn.action_item.set_value(tr("up to date, last checked {}").format(formatted))
+        else:
+          self._download_btn.action_item.set_value(tr("up to date, last checked never"))
+        self._download_btn.action_item.set_text(tr("CHECK"))
+
+      # If we've been waiting too long without a state change, reset state
+      if self._waiting_for_updater and (time.monotonic() - self._waiting_start_ts > UPDATED_TIMEOUT):
+        self._waiting_for_updater = False
+
+      # Only enable if we're not waiting for updater to flip out of idle
+      self._download_btn.action_item.set_enabled(not self._waiting_for_updater)
+
+    # Update target branch button value
+    current_branch = ui_state.params.get("UpdaterTargetBranch") or ""
+    self._branch_btn.action_item.set_value(current_branch)
+
+    # Update install button
+    self._install_btn.set_visible(ui_state.is_offroad() and update_available)
+    if update_available:
+      new_desc = ui_state.params.get("UpdaterNewDescription") or ""
+      new_release_notes = (ui_state.params.get("UpdaterNewReleaseNotes") or b"").decode("utf-8", "replace")
+      self._install_btn.action_item.set_text(tr("INSTALL"))
+      self._install_btn.action_item.set_value(new_desc)
+      self._install_btn.set_description(new_release_notes)
+      # Enable install button for testing (like Qt showEvent)
+      self._install_btn.action_item.set_enabled(True)
+    else:
+      self._install_btn.set_visible(False)
+
+  def _on_download_update(self):
+    # Check if we should start checking or start downloading
+    self._download_btn.action_item.set_enabled(False)
+    if self._download_btn.action_item.text == tr("CHECK"):
+      # Start checking for updates
+      self._waiting_for_updater = True
+      self._waiting_start_ts = time.monotonic()
+      os.system("pkill -SIGUSR1 -f system.updated.updated")
+    else:
+      # Start downloading
+      self._waiting_for_updater = True
+      self._waiting_start_ts = time.monotonic()
+      os.system("pkill -SIGHUP -f system.updated.updated")

  def _on_uninstall(self):
    def handle_uninstall_confirmation(result):
      if result == DialogResult.CONFIRM:
-        self._params.put_bool("DoUninstall", True)
+        ui_state.params.put_bool("DoUninstall", True)

-    gui_app.set_modal_overlay(
-      lambda: confirm_dialog("Are you sure you want to uninstall?", "Uninstall"),
-      callback=handle_uninstall_confirmation,
-    )
+    dialog = ConfirmDialog(tr("Are you sure you want to uninstall?"), tr("Uninstall"))
+    gui_app.set_modal_overlay(dialog, callback=handle_uninstall_confirmation)
+
+  def _on_install_update(self):
+    # Trigger reboot to install update
+    self._install_btn.action_item.set_enabled(False)
+    ui_state.params.put_bool("DoReboot", True)
+
+  def _on_select_branch(self):
+    # Get available branches and order
+    current_git_branch = ui_state.params.get("GitBranch") or ""
+    branches_str = ui_state.params.get("UpdaterAvailableBranches") or ""
+    branches = [b for b in branches_str.split(",") if b]
+
+    for b in [current_git_branch, "devel-staging", "devel", "nightly", "nightly-dev", "master"]:
+      if b in branches:
+        branches.remove(b)
+        branches.insert(0, b)
+
+    current_target = ui_state.params.get("UpdaterTargetBranch") or ""
+    self._branch_dialog = MultiOptionDialog(tr("Select a branch"), branches, current_target)
+
+    def handle_selection(result):
+      # Confirmed selection
+      if result == DialogResult.CONFIRM and self._branch_dialog is not None and self._branch_dialog.selection:
+        selection = self._branch_dialog.selection
+        ui_state.params.put("UpdaterTargetBranch", selection)
+        self._branch_btn.action_item.set_value(selection)
+        os.system("pkill -SIGUSR1 -f system.updated.updated")
+      self._branch_dialog = None
+
+    gui_app.set_modal_overlay(self._branch_dialog, callback=handle_selection)
@@ -1,28 +1,36 @@
-from openpilot.common.params import Params
+from cereal import log
+from openpilot.common.params import Params, UnknownKeyName
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.list_view import multiple_button_item, toggle_item
 from openpilot.system.ui.widgets.scroller import Scroller
+from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
+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.selfdrive.ui.ui_state import ui_state
+
+PERSONALITY_TO_INT = log.LongitudinalPersonality.schema.enumerants

 # Description constants
 DESCRIPTIONS = {
-  "OpenpilotEnabledToggle": (
+  "OpenpilotEnabledToggle": tr_noop(
    "Use the openpilot system for adaptive cruise control and lane keep driver assistance. " +
    "Your attention is required at all times to use this feature."
  ),
-  "DisengageOnAccelerator": "When enabled, pressing the accelerator pedal will disengage openpilot.",
-  "LongitudinalPersonality": (
+  "DisengageOnAccelerator": tr_noop("When enabled, pressing the accelerator pedal will disengage openpilot."),
+  "LongitudinalPersonality": tr_noop(
    "Standard is recommended. In aggressive mode, openpilot will follow lead cars closer and be more aggressive with the gas and brake. " +
    "In relaxed mode openpilot will stay further away from lead cars. On supported cars, you can cycle through these personalities with " +
    "your steering wheel distance button."
  ),
-  "IsLdwEnabled": (
+  "IsLdwEnabled": tr_noop(
    "Receive alerts to steer back into the lane when your vehicle drifts over a detected lane line " +
    "without a turn signal activated while driving over 31 mph (50 km/h)."
  ),
-  "AlwaysOnDM": "Enable driver monitoring even when openpilot is not engaged.",
-  'RecordFront': "Upload data from the driver facing camera and help improve the driver monitoring algorithm.",
-  "IsMetric": "Display speed in km/h instead of mph.",
-  "RecordAudio": "Record and store microphone audio while driving. The audio will be included in the dashcam video in comma connect.",
+  "AlwaysOnDM": tr_noop("Enable driver monitoring even when openpilot is not engaged."),
+  'RecordFront': tr_noop("Upload data from the driver facing camera and help improve the driver monitoring algorithm."),
+  "IsMetric": tr_noop("Display speed in km/h instead of mph."),
+  "RecordAudio": tr_noop("Record and store microphone audio while driving. The audio will be included in the dashcam video in comma connect."),
 }


@@ -30,66 +38,207 @@ class TogglesLayout(Widget):
  def __init__(self):
    super().__init__()
    self._params = Params()
-    items = [
-      toggle_item(
-        "Enable openpilot",
-        DESCRIPTIONS["OpenpilotEnabledToggle"],
-        self._params.get_bool("OpenpilotEnabledToggle"),
-        icon="chffr_wheel.png",
-      ),
-      toggle_item(
-        "Experimental Mode",
-        initial_state=self._params.get_bool("ExperimentalMode"),
-        icon="experimental_white.png",
-      ),
-      toggle_item(
-        "Disengage on Accelerator Pedal",
-        DESCRIPTIONS["DisengageOnAccelerator"],
-        self._params.get_bool("DisengageOnAccelerator"),
-        icon="disengage_on_accelerator.png",
-      ),
-      multiple_button_item(
-        "Driving Personality",
-        DESCRIPTIONS["LongitudinalPersonality"],
-        buttons=["Aggressive", "Standard", "Relaxed"],
-        button_width=255,
-        callback=self._set_longitudinal_personality,
-        selected_index=self._params.get("LongitudinalPersonality", return_default=True),
-        icon="speed_limit.png"
-      ),
-      toggle_item(
-        "Enable Lane Departure Warnings",
-        DESCRIPTIONS["IsLdwEnabled"],
-        self._params.get_bool("IsLdwEnabled"),
-        icon="warning.png",
-      ),
-      toggle_item(
-        "Always-On Driver Monitoring",
-        DESCRIPTIONS["AlwaysOnDM"],
-        self._params.get_bool("AlwaysOnDM"),
-        icon="monitoring.png",
-      ),
-      toggle_item(
-        "Record and Upload Driver Camera",
-        DESCRIPTIONS["RecordFront"],
-        self._params.get_bool("RecordFront"),
-        icon="monitoring.png",
-      ),
-      toggle_item(
-        "Record Microphone Audio",
-        DESCRIPTIONS["RecordAudio"],
-        self._params.get_bool("RecordAudio"),
-        icon="microphone.png",
-      ),
-      toggle_item(
-        "Use Metric System", DESCRIPTIONS["IsMetric"], self._params.get_bool("IsMetric"), icon="metric.png"
-      ),
-    ]
+    self._is_release = self._params.get_bool("IsReleaseBranch")

-    self._scroller = Scroller(items, line_separator=True, spacing=0)
+    # param, title, desc, icon, needs_restart
+    self._toggle_defs = {
+      "OpenpilotEnabledToggle": (
+        lambda: tr("Enable openpilot"),
+        DESCRIPTIONS["OpenpilotEnabledToggle"],
+        "chffr_wheel.png",
+        True,
+      ),
+      "ExperimentalMode": (
+        lambda: tr("Experimental Mode"),
+        "",
+        "experimental_white.png",
+        False,
+      ),
+      "DisengageOnAccelerator": (
+        lambda: tr("Disengage on Accelerator Pedal"),
+        DESCRIPTIONS["DisengageOnAccelerator"],
+        "disengage_on_accelerator.png",
+        False,
+      ),
+      "IsLdwEnabled": (
+        lambda: tr("Enable Lane Departure Warnings"),
+        DESCRIPTIONS["IsLdwEnabled"],
+        "warning.png",
+        False,
+      ),
+      "AlwaysOnDM": (
+        lambda: tr("Always-On Driver Monitoring"),
+        DESCRIPTIONS["AlwaysOnDM"],
+        "monitoring.png",
+        False,
+      ),
+      "RecordFront": (
+        lambda: tr("Record and Upload Driver Camera"),
+        DESCRIPTIONS["RecordFront"],
+        "monitoring.png",
+        True,
+      ),
+      "RecordAudio": (
+        lambda: tr("Record and Upload Microphone Audio"),
+        DESCRIPTIONS["RecordAudio"],
+        "microphone.png",
+        True,
+      ),
+      "IsMetric": (
+        lambda: tr("Use Metric System"),
+        DESCRIPTIONS["IsMetric"],
+        "metric.png",
+        False,
+      ),
+    }
+
+    self._long_personality_setting = multiple_button_item(
+      lambda: tr("Driving Personality"),
+      lambda: tr(DESCRIPTIONS["LongitudinalPersonality"]),
+      buttons=[lambda: tr("Aggressive"), lambda: tr("Standard"), lambda: tr("Relaxed")],
+      button_width=255,
+      callback=self._set_longitudinal_personality,
+      selected_index=self._params.get("LongitudinalPersonality", return_default=True),
+      icon="speed_limit.png"
+    )
+
+    self._toggles = {}
+    self._locked_toggles = set()
+    for param, (title, desc, icon, needs_restart) in self._toggle_defs.items():
+      toggle = toggle_item(
+        title,
+        desc,
+        self._params.get_bool(param),
+        callback=lambda state, p=param: self._toggle_callback(state, p),
+        icon=icon,
+      )
+
+      try:
+        locked = self._params.get_bool(param + "Lock")
+      except UnknownKeyName:
+        locked = False
+      toggle.action_item.set_enabled(not locked)
+
+      # Make description callable for live translation
+      additional_desc = ""
+      if needs_restart and not locked:
+        additional_desc = tr("Changing this setting will restart openpilot if the car is powered on.")
+      toggle.set_description(lambda og_desc=toggle.description, add_desc=additional_desc: tr(og_desc) + (" " + tr(add_desc) if add_desc else ""))
+
+      # track for engaged state updates
+      if locked:
+        self._locked_toggles.add(param)
+
+      self._toggles[param] = toggle
+
+      # insert longitudinal personality after NDOG toggle
+      if param == "DisengageOnAccelerator":
+        self._toggles["LongitudinalPersonality"] = self._long_personality_setting
+
+    self._update_experimental_mode_icon()
+    self._scroller = Scroller(list(self._toggles.values()), line_separator=True, spacing=0)
+
+    ui_state.add_engaged_transition_callback(self._update_toggles)
+
+  def _update_state(self):
+    if ui_state.sm.updated["selfdriveState"]:
+      personality = PERSONALITY_TO_INT[ui_state.sm["selfdriveState"].personality]
+      if personality != ui_state.personality and ui_state.started:
+        self._long_personality_setting.action_item.set_selected_button(personality)
+      ui_state.personality = personality
+
+  def show_event(self):
+    self._scroller.show_event()
+    self._update_toggles()
+
+  def _update_toggles(self):
+    ui_state.update_params()
+
+    e2e_description = tr(
+      "openpilot defaults to driving in chill mode. Experimental mode enables alpha-level features that aren't ready for chill mode. " +
+      "Experimental features are listed below:<br>" +
+      "<h4>End-to-End Longitudinal Control</h4><br>" +
+      "Let the driving model control the gas and brakes. openpilot will drive as it thinks a human would, including stopping for red lights and stop signs. " +
+      "Since the driving model decides the speed to drive, the set speed will only act as an upper bound. This is an alpha quality feature; " +
+      "mistakes should be expected.<br>" +
+      "<h4>New Driving Visualization</h4><br>" +
+      "The driving visualization will transition to the road-facing wide-angle camera at low speeds to better show some turns. " +
+      "The Experimental mode logo will also be shown in the top right corner."
+    )
+
+    if ui_state.CP is not None:
+      if ui_state.has_longitudinal_control:
+        self._toggles["ExperimentalMode"].action_item.set_enabled(True)
+        self._toggles["ExperimentalMode"].set_description(e2e_description)
+        self._long_personality_setting.action_item.set_enabled(True)
+      else:
+        # no long for now
+        self._toggles["ExperimentalMode"].action_item.set_enabled(False)
+        self._toggles["ExperimentalMode"].action_item.set_state(False)
+        self._long_personality_setting.action_item.set_enabled(False)
+        self._params.remove("ExperimentalMode")
+
+        unavailable = tr("Experimental mode is currently unavailable on this car since the car's stock ACC is used for longitudinal control.")
+
+        long_desc = unavailable + " " + tr("openpilot longitudinal control may come in a future update.")
+        if ui_state.CP.alphaLongitudinalAvailable:
+          if self._is_release:
+            long_desc = unavailable + " " + tr("An alpha version of openpilot longitudinal control can be tested, along with " +
+                                               "Experimental mode, on non-release branches.")
+          else:
+            long_desc = tr("Enable the openpilot longitudinal control (alpha) toggle to allow Experimental mode.")
+
+        self._toggles["ExperimentalMode"].set_description("<b>" + long_desc + "</b><br><br>" + e2e_description)
+    else:
+      self._toggles["ExperimentalMode"].set_description(e2e_description)
+
+    self._update_experimental_mode_icon()
+
+    # TODO: make a param control list item so we don't need to manage internal state as much here
+    # refresh toggles from params to mirror external changes
+    for param in self._toggle_defs:
+      self._toggles[param].action_item.set_state(self._params.get_bool(param))
+
+    # these toggles need restart, block while engaged
+    for toggle_def in self._toggle_defs:
+      if self._toggle_defs[toggle_def][3] and toggle_def not in self._locked_toggles:
+        self._toggles[toggle_def].action_item.set_enabled(not ui_state.engaged)

  def _render(self, rect):
    self._scroller.render(rect)

+  def _update_experimental_mode_icon(self):
+    icon = "experimental.png" if self._toggles["ExperimentalMode"].action_item.get_state() else "experimental_white.png"
+    self._toggles["ExperimentalMode"].set_icon(icon)
+
+  def _handle_experimental_mode_toggle(self, state: bool):
+    confirmed = self._params.get_bool("ExperimentalModeConfirmed")
+    if state and not confirmed:
+      def confirm_callback(result: int):
+        if result == DialogResult.CONFIRM:
+          self._params.put_bool("ExperimentalMode", True)
+          self._params.put_bool("ExperimentalModeConfirmed", True)
+        else:
+          self._toggles["ExperimentalMode"].action_item.set_state(False)
+        self._update_experimental_mode_icon()
+
+      # show confirmation dialog
+      content = (f"<h1>{self._toggles['ExperimentalMode'].title}</h1><br>" +
+                 f"<p>{self._toggles['ExperimentalMode'].description}</p>")
+      dlg = ConfirmDialog(content, tr("Enable"), rich=True)
+      gui_app.set_modal_overlay(dlg, callback=confirm_callback)
+    else:
+      self._update_experimental_mode_icon()
+      self._params.put_bool("ExperimentalMode", state)
+
+  def _toggle_callback(self, state: bool, param: str):
+    if param == "ExperimentalMode":
+      self._handle_experimental_mode_toggle(state)
+      return
+
+    self._params.put_bool(param, state)
+    if self._toggle_defs[param][3]:
+      self._params.put_bool("OnroadCycleRequested", True)
+
  def _set_longitudinal_personality(self, button_index: int):
    self._params.put("LongitudinalPersonality", button_index)
@@ -4,7 +4,8 @@ from dataclasses import dataclass
 from collections.abc import Callable
 from cereal import log
 from openpilot.selfdrive.ui.ui_state import ui_state
-from openpilot.system.ui.lib.application import gui_app, FontWeight, MousePos
+from openpilot.system.ui.lib.application import gui_app, FontWeight, MousePos, FONT_SCALE
+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

@@ -23,7 +24,6 @@ NetworkType = log.DeviceState.NetworkType

 # Color scheme
 class Colors:
-  SIDEBAR_BG = rl.Color(57, 57, 57, 255)
  WHITE = rl.WHITE
  WHITE_DIM = rl.Color(255, 255, 255, 85)
  GRAY = rl.Color(84, 84, 84, 255)
@@ -40,13 +40,13 @@ class Colors:


 NETWORK_TYPES = {
-  NetworkType.none: "Offline",
-  NetworkType.wifi: "WiFi",
-  NetworkType.cell2G: "2G",
-  NetworkType.cell3G: "3G",
-  NetworkType.cell4G: "LTE",
-  NetworkType.cell5G: "5G",
-  NetworkType.ethernet: "Ethernet",
+  NetworkType.none: tr_noop("--"),
+  NetworkType.wifi: tr_noop("Wi-Fi"),
+  NetworkType.ethernet: tr_noop("ETH"),
+  NetworkType.cell2G: tr_noop("2G"),
+  NetworkType.cell3G: tr_noop("3G"),
+  NetworkType.cell4G: tr_noop("LTE"),
+  NetworkType.cell5G: tr_noop("5G"),
 }


@@ -68,27 +68,33 @@ class Sidebar(Widget):
    self._net_type = NETWORK_TYPES.get(NetworkType.none)
    self._net_strength = 0

-    self._temp_status = MetricData("TEMP", "GOOD", Colors.GOOD)
-    self._panda_status = MetricData("VEHICLE", "ONLINE", Colors.GOOD)
-    self._connect_status = MetricData("CONNECT", "OFFLINE", Colors.WARNING)
+    self._temp_status = MetricData(tr_noop("TEMP"), tr_noop("GOOD"), Colors.GOOD)
+    self._panda_status = MetricData(tr_noop("VEHICLE"), tr_noop("ONLINE"), Colors.GOOD)
+    self._connect_status = MetricData(tr_noop("CONNECT"), tr_noop("OFFLINE"), Colors.WARNING)
+    self._recording_audio = False

    self._home_img = gui_app.texture("images/button_home.png", HOME_BTN.width, HOME_BTN.height)
    self._flag_img = gui_app.texture("images/button_flag.png", HOME_BTN.width, HOME_BTN.height)
    self._settings_img = gui_app.texture("images/button_settings.png", SETTINGS_BTN.width, SETTINGS_BTN.height)
+    self._mic_img = gui_app.texture("icons/microphone.png", 30, 30)
+    self._mic_indicator_rect = rl.Rectangle(0, 0, 0, 0)
    self._font_regular = gui_app.font(FontWeight.NORMAL)
    self._font_bold = gui_app.font(FontWeight.SEMI_BOLD)

    # Callbacks
    self._on_settings_click: Callable | None = None
    self._on_flag_click: Callable | None = None
+    self._open_settings_callback: Callable | None = None

-  def set_callbacks(self, on_settings: Callable | None = None, on_flag: Callable | None = None):
+  def set_callbacks(self, on_settings: Callable | None = None, on_flag: Callable | None = None,
+                    open_settings: Callable | None = None):
    self._on_settings_click = on_settings
    self._on_flag_click = on_flag
+    self._open_settings_callback = open_settings

  def _render(self, rect: rl.Rectangle):
    # Background
-    rl.draw_rectangle_rec(rect, Colors.SIDEBAR_BG)
+    rl.draw_rectangle_rec(rect, rl.BLACK)

    self._draw_buttons(rect)
    self._draw_network_indicator(rect)
@@ -101,13 +107,14 @@ class Sidebar(Widget):

    device_state = sm['deviceState']

+    self._recording_audio = ui_state.recording_audio
    self._update_network_status(device_state)
    self._update_temperature_status(device_state)
    self._update_connection_status(device_state)
    self._update_panda_status()

  def _update_network_status(self, device_state):
-    self._net_type = NETWORK_TYPES.get(device_state.networkType.raw, "Unknown")
+    self._net_type = NETWORK_TYPES.get(device_state.networkType.raw, tr_noop("Unknown"))
    strength = device_state.networkStrength
    self._net_strength = max(0, min(5, strength.raw + 1)) if strength > 0 else 0

@@ -115,26 +122,26 @@ class Sidebar(Widget):
    thermal_status = device_state.thermalStatus

    if thermal_status == ThermalStatus.green:
-      self._temp_status.update("TEMP", "GOOD", Colors.GOOD)
+      self._temp_status.update(tr_noop("TEMP"), tr_noop("GOOD"), Colors.GOOD)
    elif thermal_status == ThermalStatus.yellow:
-      self._temp_status.update("TEMP", "OK", Colors.WARNING)
+      self._temp_status.update(tr_noop("TEMP"), tr_noop("OK"), Colors.WARNING)
    else:
-      self._temp_status.update("TEMP", "HIGH", Colors.DANGER)
+      self._temp_status.update(tr_noop("TEMP"), tr_noop("HIGH"), Colors.DANGER)

  def _update_connection_status(self, device_state):
    last_ping = device_state.lastAthenaPingTime
    if last_ping == 0:
-      self._connect_status.update("CONNECT", "OFFLINE", Colors.WARNING)
+      self._connect_status.update(tr_noop("CONNECT"), tr_noop("OFFLINE"), Colors.WARNING)
    elif time.monotonic_ns() - last_ping < 80_000_000_000:  # 80 seconds in nanoseconds
-      self._connect_status.update("CONNECT", "ONLINE", Colors.GOOD)
+      self._connect_status.update(tr_noop("CONNECT"), tr_noop("ONLINE"), Colors.GOOD)
    else:
-      self._connect_status.update("CONNECT", "ERROR", Colors.DANGER)
+      self._connect_status.update(tr_noop("CONNECT"), tr_noop("ERROR"), Colors.DANGER)

  def _update_panda_status(self):
    if ui_state.panda_type == log.PandaState.PandaType.unknown:
-      self._panda_status.update("NO", "PANDA", Colors.DANGER)
+      self._panda_status.update(tr_noop("NO"), tr_noop("PANDA"), Colors.DANGER)
    else:
-      self._panda_status.update("VEHICLE", "ONLINE", Colors.GOOD)
+      self._panda_status.update(tr_noop("VEHICLE"), tr_noop("ONLINE"), Colors.GOOD)

  def _handle_mouse_release(self, mouse_pos: MousePos):
    if rl.check_collision_point_rec(mouse_pos, SETTINGS_BTN):
@@ -143,6 +150,9 @@ class Sidebar(Widget):
    elif rl.check_collision_point_rec(mouse_pos, HOME_BTN) and ui_state.started:
      if self._on_flag_click:
        self._on_flag_click()
+    elif self._recording_audio and rl.check_collision_point_rec(mouse_pos, self._mic_indicator_rect):
+      if self._open_settings_callback:
+        self._open_settings_callback()

  def _draw_buttons(self, rect: rl.Rectangle):
    mouse_pos = rl.get_mouse_position()
@@ -160,6 +170,17 @@ class Sidebar(Widget):
    tint = Colors.BUTTON_PRESSED if (ui_state.started and flag_pressed) else Colors.BUTTON_NORMAL
    rl.draw_texture(button_img, int(HOME_BTN.x), int(HOME_BTN.y), tint)

+    # Microphone button
+    if self._recording_audio:
+      self._mic_indicator_rect = rl.Rectangle(rect.x + rect.width - 130, rect.y + 245, 75, 40)
+
+      mic_pressed = mouse_down and rl.check_collision_point_rec(mouse_pos, self._mic_indicator_rect)
+      bg_color = rl.Color(Colors.DANGER.r, Colors.DANGER.g, Colors.DANGER.b, int(255 * 0.65)) if mic_pressed else Colors.DANGER
+
+      rl.draw_rectangle_rounded(self._mic_indicator_rect, 1, 10, bg_color)
+      rl.draw_texture(self._mic_img, int(self._mic_indicator_rect.x + (self._mic_indicator_rect.width - self._mic_img.width) / 2),
+                      int(self._mic_indicator_rect.y + (self._mic_indicator_rect.height - self._mic_img.height) / 2), Colors.WHITE)
+
  def _draw_network_indicator(self, rect: rl.Rectangle):
    # Signal strength dots
    x_start = rect.x + 58
@@ -176,7 +197,7 @@ class Sidebar(Widget):
    # Network type text
    text_y = rect.y + 247
    text_pos = rl.Vector2(rect.x + 58, text_y)
-    rl.draw_text_ex(self._font_regular, self._net_type, text_pos, FONT_SIZE, 0, Colors.WHITE)
+    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):
    metrics = [(self._temp_status, 338), (self._panda_status, 496), (self._connect_status, 654)]
@@ -189,15 +210,15 @@ class Sidebar(Widget):
    # Draw colored left edge (clipped rounded rectangle)
    edge_rect = rl.Rectangle(metric_rect.x + 4, metric_rect.y + 4, 100, 118)
    rl.begin_scissor_mode(int(metric_rect.x + 4), int(metric_rect.y), 18, int(metric_rect.height))
-    rl.draw_rectangle_rounded(edge_rect, 0.18, 10, metric.color)
+    rl.draw_rectangle_rounded(edge_rect, 0.3, 10, metric.color)
    rl.end_scissor_mode()

    # Draw border
-    rl.draw_rectangle_rounded_lines_ex(metric_rect, 0.15, 10, 2, Colors.METRIC_BORDER)
+    rl.draw_rectangle_rounded_lines_ex(metric_rect, 0.3, 10, 2, Colors.METRIC_BORDER)

    # Draw label and value
-    labels = [metric.label, metric.value]
-    text_y = metric_rect.y + (metric_rect.height / 2 - len(labels) * FONT_SIZE)
+    labels = [tr(metric.label), tr(metric.value)]
+    text_y = metric_rect.y + (metric_rect.height / 2 - len(labels) * FONT_SIZE * FONT_SCALE)
    for text in labels:
      text_size = measure_text_cached(self._font_bold, text, FONT_SIZE)
      text_y += text_size.y
@@ -1,12 +1,16 @@
 import time
 from functools import lru_cache
 from openpilot.common.api import Api
+from openpilot.common.time_helpers import system_time_valid

 TOKEN_EXPIRY_HOURS = 2


@lru_cache(maxsize=1)
 def _get_token(dongle_id: str, t: int):
+  if not system_time_valid():
+    raise RuntimeError("System time is not valid, cannot generate token")
+
  return Api(dongle_id).get_token(expiry_hours=TOKEN_EXPIRY_HOURS)


@@ -11,14 +11,14 @@ from openpilot.selfdrive.ui.lib.api_helpers import get_token


 class PrimeType(IntEnum):
-  UNKNOWN = -2,
-  UNPAIRED = -1,
-  NONE = 0,
-  MAGENTA = 1,
-  LITE = 2,
-  BLUE = 3,
-  MAGENTA_NEW = 4,
-  PURPLE = 5,
+  UNKNOWN = -2
+  UNPAIRED = -1
+  NONE = 0
+  MAGENTA = 1
+  LITE = 2
+  BLUE = 3
+  MAGENTA_NEW = 4
+  PURPLE = 5


 class PrimeState:
@@ -33,7 +33,6 @@ class PrimeState:

    self._running = False
    self._thread = None
-    self.start()

  def _load_initial_state(self) -> PrimeType:
    prime_type_str = os.getenv("PRIME_TYPE") or self._params.get("PrimeType")
@@ -96,5 +95,9 @@ class PrimeState:
    with self._lock:
      return bool(self.prime_type > PrimeType.NONE)

+  def is_paired(self) -> bool:
+    with self._lock:
+      return self.prime_type > PrimeType.UNPAIRED
+
  def __del__(self):
    self.stop()
@@ -1,36 +0,0 @@
-#include <sys/resource.h>
-
-#include <QApplication>
-#include <QTranslator>
-
-#include "system/hardware/hw.h"
-#include "selfdrive/ui/qt/util.h"
-#include "selfdrive/ui/qt/window.h"
-
-#ifdef SUNNYPILOT
-#include "selfdrive/ui/sunnypilot/qt/window.h"
-#define MainWindow MainWindowSP
-#else
-#include "selfdrive/ui/qt/qt_window.h"
-#endif
-
-int main(int argc, char *argv[]) {
-  setpriority(PRIO_PROCESS, 0, -20);
-
-  qInstallMessageHandler(swagLogMessageHandler);
-  initApp(argc, argv);
-
-  QTranslator translator;
-  QString translation_file = QString::fromStdString(Params().get("LanguageSetting"));
-  if (!translator.load(QString(":/%1").arg(translation_file)) && translation_file.length()) {
-    qCritical() << "Failed to load translation file:" << translation_file;
-  }
-
-  QApplication a(argc, argv);
-  a.installTranslator(&translator);
-
-  MainWindow w;
-  setMainWindow(&w);
-  a.installEventFilter(&w);
-  return a.exec();
-}
@@ -4,10 +4,11 @@ from dataclasses import dataclass
 from cereal import messaging, log
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.hardware import TICI
-from openpilot.system.ui.lib.application import gui_app, FontWeight, DEFAULT_FPS
+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
-from openpilot.system.ui.widgets.label import gui_text_box
+from openpilot.system.ui.widgets.label import Label

 AlertSize = log.SelfdriveState.AlertSize
 AlertStatus = log.SelfdriveState.AlertStatus
@@ -21,14 +22,19 @@ ALERT_FONT_SMALL = 66
 ALERT_FONT_MEDIUM = 74
 ALERT_FONT_BIG = 88

+ALERT_HEIGHTS = {
+  AlertSize.small: 271,
+  AlertSize.mid: 420,
+}
+
 SELFDRIVE_STATE_TIMEOUT = 5  # Seconds
 SELFDRIVE_UNRESPONSIVE_TIMEOUT = 10  # Seconds

 # Constants
 ALERT_COLORS = {
-  AlertStatus.normal: rl.Color(0, 0, 0, 235),  # Black
-  AlertStatus.userPrompt: rl.Color(0xFE, 0x8C, 0x34, 235),  # Orange
-  AlertStatus.critical: rl.Color(0xC9, 0x22, 0x31, 235),  # Red
+  AlertStatus.normal: rl.Color(0x15, 0x15, 0x15, 0xF1),      # #151515 with alpha 0xF1
+  AlertStatus.userPrompt: rl.Color(0xDA, 0x6F, 0x25, 0xF1),  # #DA6F25 with alpha 0xF1
+  AlertStatus.critical: rl.Color(0xC9, 0x22, 0x31, 0xF1),    # #C92231 with alpha 0xF1
 }


@@ -42,24 +48,24 @@ class Alert:

 # Pre-defined alert instances
 ALERT_STARTUP_PENDING = Alert(
-  text1="openpilot Unavailable",
-  text2="Waiting to start",
+  text1=tr("openpilot Unavailable"),
+  text2=tr("Waiting to start"),
  size=AlertSize.mid,
  status=AlertStatus.normal,
 )

 ALERT_CRITICAL_TIMEOUT = Alert(
-  text1="TAKE CONTROL IMMEDIATELY",
-  text2="System Unresponsive",
+  text1=tr("TAKE CONTROL IMMEDIATELY"),
+  text2=tr("System Unresponsive"),
  size=AlertSize.full,
  status=AlertStatus.critical,
 )

 ALERT_CRITICAL_REBOOT = Alert(
-  text1="System Unresponsive",
-  text2="Reboot Device",
-  size=AlertSize.full,
-  status=AlertStatus.critical,
+  text1=tr("System Unresponsive"),
+  text2=tr("Reboot Device"),
+  size=AlertSize.mid,
+  status=AlertStatus.normal,
 )


@@ -69,14 +75,20 @@ class AlertRenderer(Widget):
    self.font_regular: rl.Font = gui_app.font(FontWeight.NORMAL)
    self.font_bold: rl.Font = gui_app.font(FontWeight.BOLD)

+    # font size is set dynamically
+    self._full_text1_label = Label("", font_size=0, font_weight=FontWeight.BOLD, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_CENTER,
+                                   text_alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_TOP)
+    self._full_text2_label = Label("", font_size=ALERT_FONT_BIG, text_alignment=rl.GuiTextAlignment.TEXT_ALIGN_CENTER,
+                                   text_alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_TOP)
+
  def get_alert(self, sm: messaging.SubMaster) -> Alert | None:
    """Generate the current alert based on selfdrive state."""
    ss = sm['selfdriveState']

    # Check if selfdriveState messages have stopped arriving
+    recv_frame = sm.recv_frame['selfdriveState']
    if not sm.updated['selfdriveState']:
-      recv_frame = sm.recv_frame['selfdriveState']
-      time_since_onroad = (sm.frame - ui_state.started_frame) / DEFAULT_FPS
+      time_since_onroad = time.monotonic() - ui_state.started_time

      # 1. Never received selfdriveState since going onroad
      waiting_for_startup = recv_frame < ui_state.started_frame
@@ -95,13 +107,17 @@ class AlertRenderer(Widget):
    if ss.alertSize == 0:
      return None

+    # Don't get old alert
+    if recv_frame < ui_state.started_frame:
+      return None
+
    # Return current alert
    return Alert(text1=ss.alertText1, text2=ss.alertText2, size=ss.alertSize.raw, status=ss.alertStatus.raw)

-  def _render(self, rect: rl.Rectangle) -> bool:
+  def _render(self, rect: rl.Rectangle):
    alert = self.get_alert(ui_state.sm)
    if not alert:
-      return False
+      return

    alert_rect = self._get_alert_rect(rect, alert.size)
    self._draw_background(alert_rect, alert)
@@ -113,21 +129,14 @@ class AlertRenderer(Widget):
      alert_rect.height - 2 * ALERT_PADDING
    )
    self._draw_text(text_rect, alert)
-    return True

  def _get_alert_rect(self, rect: rl.Rectangle, size: int) -> rl.Rectangle:
    if size == AlertSize.full:
      return rect

-    height = (ALERT_FONT_MEDIUM + 2 * ALERT_PADDING if size == AlertSize.small else
-              ALERT_FONT_BIG + ALERT_LINE_SPACING + ALERT_FONT_SMALL + 2 * ALERT_PADDING)
-
-    return rl.Rectangle(
-      rect.x + ALERT_MARGIN,
-      rect.y + rect.height - ALERT_MARGIN - height,
-      rect.width - 2 * ALERT_MARGIN,
-      height
-    )
+    h = ALERT_HEIGHTS.get(size, rect.height)
+    return rl.Rectangle(rect.x + ALERT_MARGIN, rect.y + rect.height - h + ALERT_MARGIN,
+                        rect.width - ALERT_MARGIN * 2, h - ALERT_MARGIN * 2)

  def _draw_background(self, rect: rl.Rectangle, alert: Alert) -> None:
    color = ALERT_COLORS.get(alert.status, ALERT_COLORS[AlertStatus.normal])
@@ -150,13 +159,17 @@ class AlertRenderer(Widget):
    else:
      is_long = len(alert.text1) > 15
      font_size1 = 132 if is_long else 177
-      align_ment = rl.GuiTextAlignment.TEXT_ALIGN_CENTER
-      vertical_align = rl.GuiTextAlignmentVertical.TEXT_ALIGN_MIDDLE
-      text_rect = rl.Rectangle(rect.x, rect.y, rect.width, rect.height // 2)

-      gui_text_box(text_rect, alert.text1, font_size1, alignment=align_ment, alignment_vertical=vertical_align, font_weight=FontWeight.BOLD)
-      text_rect.y = rect.y + rect.height // 2
-      gui_text_box(text_rect, alert.text2, ALERT_FONT_BIG, alignment=align_ment)
+      top_offset = 200 if is_long or '\n' in alert.text1 else 270
+      title_rect = rl.Rectangle(rect.x, rect.y + top_offset, rect.width, 600)
+      self._full_text1_label.set_font_size(font_size1)
+      self._full_text1_label.set_text(alert.text1)
+      self._full_text1_label.render(title_rect)
+
+      bottom_offset = 361 if is_long else 420
+      subtitle_rect = rl.Rectangle(rect.x, rect.y + rect.height - bottom_offset, rect.width, 300)
+      self._full_text2_label.set_text(alert.text2)
+      self._full_text2_label.render(subtitle_rect)

  def _draw_centered(self, text, rect, font, font_size, center_y=True, color=rl.WHITE) -> None:
    text_size = measure_text_cached(font, text, font_size)
@@ -1,9 +1,10 @@
+import time
 import numpy as np
 import pyray as rl
-from collections.abc import Callable
-from cereal import log
+from cereal import log, messaging
 from msgq.visionipc import VisionStreamType
-from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus, UI_BORDER_SIZE
+from openpilot.selfdrive.ui import UI_BORDER_SIZE
+from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus
 from openpilot.selfdrive.ui.onroad.alert_renderer import AlertRenderer
 from openpilot.selfdrive.ui.onroad.driver_state import DriverStateRenderer
 from openpilot.selfdrive.ui.onroad.hud_renderer import HudRenderer
@@ -20,13 +21,14 @@ WIDE_CAM = VisionStreamType.VISION_STREAM_WIDE_ROAD
 DEFAULT_DEVICE_CAMERA = DEVICE_CAMERAS["tici", "ar0231"]

 BORDER_COLORS = {
-  UIStatus.DISENGAGED: rl.Color(0x17, 0x33, 0x49, 0xC8),   # Blue for disengaged state
-  UIStatus.OVERRIDE: rl.Color(0x91, 0x9B, 0x95, 0xF1),     # Gray for override state
-  UIStatus.ENGAGED: rl.Color(0x17, 0x86, 0x44, 0xF1),      # Green for engaged state
+  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
 }

 WIDE_CAM_MAX_SPEED = 10.0  # m/s (22 mph)
 ROAD_CAM_MIN_SPEED = 15.0  # m/s (34 mph)
+INF_POINT = np.array([1000.0, 0.0, 0.0])


 class AugmentedRoadView(CameraView):
@@ -38,9 +40,7 @@ class AugmentedRoadView(CameraView):
    self.view_from_calib = view_frame_from_device_frame.copy()
    self.view_from_wide_calib = view_frame_from_device_frame.copy()

-    self._last_calib_time: float = 0
-    self._last_rect_dims = (0.0, 0.0)
-    self._last_stream_type = stream_type
+    self._matrix_cache_key = (0, 0.0, 0.0, stream_type)
    self._cached_matrix: np.ndarray | None = None
    self._content_rect = rl.Rectangle()

@@ -49,14 +49,12 @@ class AugmentedRoadView(CameraView):
    self.alert_renderer = AlertRenderer()
    self.driver_state_renderer = DriverStateRenderer()

-    # Callbacks
-    self._click_callback: Callable | None = None
-
-  def set_callbacks(self, on_click: Callable | None = None):
-    self._click_callback = on_click
+    # debug
+    self._pm = messaging.PubMaster(['uiDebug'])

  def _render(self, rect):
    # Only render when system is started to avoid invalid data access
+    start_draw = time.monotonic()
    if not ui_state.started:
      return

@@ -73,9 +71,6 @@ class AugmentedRoadView(CameraView):
      rect.height - 2 * UI_BORDER_SIZE,
    )

-    # Draw colored border based on driving state
-    self._draw_border(rect)
-
    # Enable scissor mode to clip all rendering within content rectangle boundaries
    # This creates a rendering viewport that prevents graphics from drawing outside the border
    rl.begin_scissor_mode(
@@ -91,8 +86,8 @@ class AugmentedRoadView(CameraView):
    # Draw all UI overlays
    self.model_renderer.render(self._content_rect)
    self._hud_renderer.render(self._content_rect)
-    if not self.alert_renderer.render(self._content_rect):
-      self.driver_state_renderer.render(self._content_rect)
+    self.alert_renderer.render(self._content_rect)
+    self.driver_state_renderer.render(self._content_rect)

    # Custom UI extension point - add custom overlays here
    # Use self._content_rect for positioning within camera bounds
@@ -100,15 +95,29 @@ class AugmentedRoadView(CameraView):
    # End clipping region
    rl.end_scissor_mode()

-    # Handle click events if no HUD interaction occurred
-    if not self._hud_renderer.handle_mouse_event():
-      if self._click_callback and rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT):
-        if rl.check_collision_point_rec(rl.get_mouse_position(), self._content_rect):
-          self._click_callback()
+    # Draw colored border based on driving state
+    self._draw_border(rect)
+
+    # publish uiDebug
+    msg = messaging.new_message('uiDebug')
+    msg.uiDebug.drawTimeMillis = (time.monotonic() - start_draw) * 1000
+    self._pm.send('uiDebug', msg)
+
+  def _handle_mouse_press(self, _):
+    if not self._hud_renderer.user_interacting() and self._click_callback is not None:
+      self._click_callback()
+
+  def _handle_mouse_release(self, _):
+    # We only call click callback on press if not interacting with HUD
+    pass

  def _draw_border(self, rect: rl.Rectangle):
+    rl.draw_rectangle_lines_ex(rect, UI_BORDER_SIZE, rl.BLACK)
+    border_roundness = 0.12
    border_color = BORDER_COLORS.get(ui_state.status, BORDER_COLORS[UIStatus.DISENGAGED])
-    rl.draw_rectangle_lines_ex(rect, UI_BORDER_SIZE, border_color)
+    border_rect = rl.Rectangle(rect.x + UI_BORDER_SIZE, rect.y + UI_BORDER_SIZE,
+                               rect.width - 2 * UI_BORDER_SIZE, rect.height - 2 * UI_BORDER_SIZE)
+    rl.draw_rectangle_rounded_lines_ex(border_rect, border_roundness, 10, UI_BORDER_SIZE, border_color)

  def _switch_stream_if_needed(self, sm):
    if sm['selfdriveState'].experimentalMode and WIDE_CAM in self.available_streams:
@@ -151,12 +160,13 @@ class AugmentedRoadView(CameraView):

  def _calc_frame_matrix(self, rect: rl.Rectangle) -> np.ndarray:
    # Check if we can use cached matrix
-    calib_time = ui_state.sm.recv_frame['liveCalibration']
-    current_dims = (self._content_rect.width, self._content_rect.height)
-    if (self._last_calib_time == calib_time and
-        self._last_rect_dims == current_dims and
-        self._last_stream_type == self.stream_type and
-        self._cached_matrix is not None):
+    cache_key = (
+      ui_state.sm.recv_frame['liveCalibration'],
+      self._content_rect.width,
+      self._content_rect.height,
+      self.stream_type
+    )
+    if cache_key == self._matrix_cache_key and self._cached_matrix is not None:
      return self._cached_matrix

    # Get camera configuration
@@ -167,9 +177,8 @@ class AugmentedRoadView(CameraView):
    zoom = 2.0 if is_wide_camera else 1.1

    # Calculate transforms for vanishing point
-    inf_point = np.array([1000.0, 0.0, 0.0])
    calib_transform = intrinsic @ calibration
-    kep = calib_transform @ inf_point
+    kep = calib_transform @ INF_POINT

    # Calculate center points and dimensions
    x, y = self._content_rect.x, self._content_rect.y
@@ -192,9 +201,7 @@ class AugmentedRoadView(CameraView):
      x_offset, y_offset = 0, 0

    # Cache the computed transformation matrix to avoid recalculations
-    self._last_calib_time = calib_time
-    self._last_rect_dims = current_dims
-    self._last_stream_type = self.stream_type
+    self._matrix_cache_key = cache_key
    self._cached_matrix = np.array([
      [zoom * 2 * cx / w, 0, -x_offset / w * 2],
      [0, zoom * 2 * cy / h, -y_offset / h * 2],
@@ -8,6 +8,7 @@ from openpilot.system.hardware import TICI
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.lib.egl import init_egl, create_egl_image, destroy_egl_image, bind_egl_image_to_texture, EGLImage
 from openpilot.system.ui.widgets import Widget
+from openpilot.selfdrive.ui.ui_state import ui_state

 CONNECTION_RETRY_INTERVAL = 0.2  # seconds between connection attempts

@@ -67,6 +68,7 @@ else:
 class CameraView(Widget):
  def __init__(self, name: str, stream_type: VisionStreamType):
    super().__init__()
+    # TODO: implement a receiver and connect thread
    self._name = name
    # Primary stream
    self.client = VisionIpcClient(name, stream_type, conflate=True)
@@ -103,6 +105,20 @@ class CameraView(Widget):
      self.egl_texture = rl.load_texture_from_image(temp_image)
      rl.unload_image(temp_image)

+    ui_state.add_offroad_transition_callback(self._offroad_transition)
+
+  def _offroad_transition(self):
+    # Reconnect if not first time going onroad
+    if ui_state.is_onroad() and self.frame is not None:
+      # Prevent old frames from showing when going onroad. Qt has a separate thread
+      # which drains the VisionIpcClient SubSocket for us. Re-connecting is not enough
+      # and only clears internal buffers, not the message queue.
+      self.frame = None
+      self.available_streams.clear()
+      if self.client:
+        del self.client
+      self.client = VisionIpcClient(self._name, self._stream_type, conflate=True)
+
  def _set_placeholder_color(self, color: rl.Color):
    """Set a placeholder color to be drawn when no frame is available."""
    self._placeholder_color = color
@@ -139,6 +155,8 @@ class CameraView(Widget):
    if self.shader and self.shader.id:
      rl.unload_shader(self.shader)

+    self.frame = None
+    self.available_streams.clear()
    self.client = None

  def __del__(self):
@@ -175,6 +193,9 @@ class CameraView(Widget):
    if buffer:
      self._texture_needs_update = True
      self.frame = buffer
+    elif not self.client.is_connected():
+      # ensure we clear the displayed frame when the connection is lost
+      self.frame = None

    if not self.frame:
      self._draw_placeholder(rect)
--- a/Show More
+++ b/Show More