ob-f/OpenBot

This system is an open-source, multi-platform remote control and machine learning infrastructure for the OpenBot vehicle. It provides diverse control interfaces—including native Android and iOS apps, web browsers, and Python scripts—enabling users to drive the robot via keyboard, touch, or accelerometer inputs with live video streaming. Additionally, it features a comprehensive policy training suite that allows users to collect driving data, train neural network models, and deploy them to the robot for autonomous behaviors like autopilot and object tracking.

18 changes.

This period focused on launching the OpenBot policy training ecosystem, introducing a Python backend, a React-based web frontend, and an Android controller app for managing robot behavior. The work included establishing the core infrastructure for dataset management, model training, and real-time monitoring, alongside comprehensive localization of documentation and build systems across multiple languages.

10 changes.

This period established the foundational software stack for OpenBot, introducing the core Arduino firmware alongside initial native support for iOS and Android platforms. It also delivered the first versions of web-based control interfaces, including a Node.js server-client architecture and a Flutter-based mobile app, while launching the Blockly-driven Playground for visual programming.

Added the public assets for the OpenBot Driving Policy Trainer web application, including the main HTML entry point, a web app manifest for mobile/desktop installation support, and standard configuration files. This change introduces the foundational frontend structure for the policy training interface.

policy/frontend/public · high confidence

The web-server component now includes README documentation in German, Spanish, French, Korean, and Simplified Chinese to support international users. Additionally, the build tooling has been updated from Snowpack to Vite for development and production builds.

controller/web-server · high confidence

The Android robot module now includes an OverlayView component that allows client classes to register draw callbacks for custom rendering on top of the camera feed, and a Size utility class to manage, parse, and rotate camera frame dimensions. These additions provide the underlying infrastructure for displaying visual overlays and handling resolution data within the robot control interface.

robot · high confidence

Added two new shell scripts, checkStyle.sh and applyStyle.sh, to the android/utils directory. These scripts use the google-java-format tool to enforce consistent Java code style across the app source files, allowing developers to automatically apply formatting or check for violations.

android/utils · high confidence

The Android directory now includes localized README files (German, Spanish, French, Korean, and Chinese) alongside the English version, providing installation instructions via QR codes and build steps for the Robot and Controller apps. A .gitignore file has been added to exclude build artifacts and IDE files, and Gradle wrapper scripts (gradlew and gradlew.bat) are included to standardize the build environment.

android · high confidence

The \controller/flutter\ directory now contains the initial project structure for the OpenBot remote controller application, supporting both Android and iOS platforms. This includes the necessary configuration files (such as \AndroidManifest.xml\, \Info.plist\, and \analysis\_options.yaml\), platform-specific assets (launch screens, app icons), and localized README documentation in English, German, Spanish, French, Korean, and Chinese to guide users through setup and operation.

controller/flutter · high confidence

Adds a new React-based web interface for the OpenBot Driving Policy Trainer, providing navigation to Datasets, Models, Uploaded sessions, and Training pages. The frontend includes routing configuration, basic styling via App.css, a proxy setup for local development to connect to the backend at localhost:8000, and initial test coverage for the main application component.

policy/frontend/src · high confidence

This change introduces the primary Arduino sketch (openbot.ino) for the OpenBot project, establishing the baseline firmware for various hardware configurations including DIY, PCB V1/V2, RTR\_TT, and ESP32-based models. The firmware enables core functionalities such as receiving control commands via USB serial, generating PWM motor controls, processing sensor data (sonar, speed sensors, battery voltage), and displaying status on an OLED screen, serving as the foundation for subsequent bug fixes and feature additions.

firmware/openbot · high confidence

The OpenBot iOS application is now available, providing native support for iPhone and iPad devices. This release includes the core app structure with Firebase and Google Sign-In integration, a comprehensive theming system with light and dark mode support, and localization for English, Spanish, French, German, Korean, and Hindi.

ios · high confidence

The Android controller application is now available, allowing users to operate the OpenBot vehicle from a second Android device. The app supports two control modes: on-screen dual-drive sliders and tilt-to-drive using the device's accelerometer, with accelerator and brake pedals for the latter. It establishes a connection to the robot via Wi-Fi (using Network Service Discovery) or Bluetooth (using Nearby Connections) and displays the robot's video feed using WebRTC. The app includes localized documentation in English, German, Spanish, French, Korean, and Chinese.

android/controller · high confidence

The OpenBot Playground is now available as a web-based drag-and-drop platform for building robot instructions. This release introduces the core application shell, including theme management (light/dark mode), Firebase authentication, and session handling. It features a Blockly-based visual programming interface with a comprehensive set of blocks for controlling the OpenBot robot, including movement, sensors, lights, sound, and advanced AI capabilities like object tracking and autopilot. The application also includes project management via Firebase Firestore, auto-sync with Google Drive, and multi-language documentation support.

open-code/src · high confidence

The OpenBot Policy Frontend is now available as a distributable Python package (version 0.7.0) on PyPI, allowing users to install and deploy the React-based interface via standard Python tooling. This change introduces the packaging infrastructure, including a \setup.py\ manifest, a \MANIFEST.in\ to include frontend assets, and a \release.sh\ script to automate the build and upload process. Additionally, the project now includes comprehensive internationalization support with README documentation in English, German, Spanish, French, Chinese, and Korean, alongside standard TypeScript configuration for the React application.

policy/frontend · high confidence

This change introduces the core server application for the OpenBot policy system, providing a web-based interface and API for managing robot training workflows. The server exposes endpoints for uploading dataset sessions, managing trained models (including publishing and deletion), and initiating or stopping training jobs. It supports real-time status updates via JSON-RPC over WebSockets and includes features for previewing session data as GIFs and running predictions against loaded TFLite models. Additionally, the server automatically registers itself on the local network using Zeroconf for easy discovery.

policy/openbot/server · high confidence

This change adds a new Node.js-based server controller that enables remote robot control via a web browser. The server establishes a WebSocket connection on port 7071 for browser input and a TCP connection on port 19400 to communicate with the robot. It features a remote keyboard interface that maps keys (WASD, arrows, etc.) to drive commands, speed adjustments, and system actions like logs or noise. The controller also includes DNS-SD service advertisement for automatic discovery by the Android app, a command reducer to minimize network traffic, and graceful shutdown handling.

controller/node-js/server · high confidence

The \policy/openbot\ directory is now a structured Python package containing the core components for training driving policies. This includes utilities for associating sensor frames with control signals, a dataloader for handling datasets, and support for generating and parsing TFRecord files. The package provides configurable Keras callbacks for checkpointing and logging, various loss and metric functions, and model definitions for both 'autopilot' and 'point\_goal\_nav' policies (such as pilot\_net and cil\_mobile).

policy/openbot · high confidence

This change introduces a new Python module for the OpenBot vehicle, providing an embedded Linux alternative to smartphone control. It includes a training pipeline (policy/openbot/train.py) for neural network policies using TensorFlow, supporting data loading from directories or TensorFlow records, hyperparameter configuration, and optional Weights & Biases logging. The module also provides runtime scripts for inference (using OpenVINO, TensorFlow, or TFLite backends), joystick control, and debug modes, along with utilities to generate training data from logs and export models to OpenVINO for optimized performance on Intel hardware. Documentation is added in multiple languages.

python · high confidence

Users can now control the robot using a Python script on a computer connected to the same network. The controller supports two modes: a Pygame-based interface for dynamic driving with live video streaming from the robot's camera, and a Click-based interface for step-by-step control. Both modes allow keyboard input for movement, turning, and toggling features like noise and logging, and register the controller service on port 8081 for connection.

controller/python · high confidence

The policy frontend now includes dedicated pages for managing the machine learning workflow. The Home page allows users to view and manage train and test datasets. The Train page provides a UI for configuring hyperparameters, monitoring training progress with real-time metrics and previews, and stopping or clearing training jobs (including preventing device sleep during training). The Models page lists trained models and published files, allowing users to view model details, metrics, and publish or delete models. The Session pages enable users to browse sessions, preview recorded data, and test models against sessions with features like frame-by-frame playback, redoing matching, and selecting models/indicators.

policy/frontend/src/pages · high confidence

The frontend now includes four new modal components to manage policy assets directly from the UI. Users can create or rename datasets via DatasetModal, delete datasets, sessions, or model files through DeleteModal (which shows a preview for sessions), move sessions to different folders using MoveModal with a tree selector, and publish trained models to local devices via PublishModal by selecting a checkpoint and specifying a filename.

policy/frontend/src/modals · high confidence

The frontend now includes a set of new components to support model training workflows. Users can configure hyperparameters (such as model type, learning rate, batch size, and epochs) via the HyperparametersForm, which integrates with the backend to start training sessions. Visual feedback is provided through the Plot component for displaying training metrics, the Direction component for visualizing control outputs, and the DatasetInfo component for session statistics. Additional UI utilities like BoolParam, NumberParam, ButtonBar, GridView, and ConnectionAlert enhance the interface for parameter input, layout, and WebSocket connection status.

policy/frontend/src/components · high confidence

The frontend now includes a dedicated utilities package in \policy/frontend/src/utils\ that enables real-time interaction with the policy server. This introduces a JSON-RPC over WebSocket layer (\ws.ts\, \useRpc.ts\) for fetching datasets, models, and model files, alongside a \useProgress\ hook that subscribes to live training events (start, progress, logs, completion) to update the UI. A \formatTime\ helper is also added to display training durations in seconds or minutes.

policy/frontend/src/utils · high confidence

The robot body assembly and build instructions are now available in five additional languages (German, Spanish, French, Korean, and Chinese). This covers the main body overview as well as the detailed DIY chassis construction guide, including component lists, 3D printing options, and wiring diagrams, making the hardware build process accessible to non-English speakers.

body · high confidence

The Node.js web controller client has been rewritten to provide a modern browser-based interface for controlling the robot. This update introduces a live video feed via WebRTC, replacing previous protocols, and adds a toolbar with buttons to toggle video mirroring, mute/unmute audio, switch cameras, and enter fullscreen mode. Users can also control the robot using keyboard shortcuts (WASD for movement, Q/E for speed, etc.) which are displayed in a sidebar, and can quit the session by pressing Escape. The client now connects to the server via WebSocket on port 7071 and includes a dedicated error display for connection status.

controller/node-js/client · high confidence

The policy training guide now includes comprehensive setup instructions for Linux, macOS, and Windows, featuring dedicated conda environment files (environment\_linux.yml, environment\_mac.yml, environment\_win.yml) that specify dependencies like TensorFlow 2.9 and CUDA toolkits. The documentation has been localized into German, Spanish, French, Korean, and Simplified Chinese, and a new dev.sh script is provided to streamline the development server startup.

policy · high confidence

Added unit tests for the OpenBot node-js controller command logic, covering the pure server-side command mapping that drives the robot's left and right motors. The new test suite in controller/node-js/test/commands.test.js verifies correct behavior for movement commands (goForward, goBackward, forwardLeft, forwardRight, rotateLeft, rotateRight, reset), command de-duplication, and raw command forwarding. It also includes specific tests for the DriveValue class, ensuring it clamps values to the \[-1, 1\] range and correctly rounds read() output to three decimal places, addressing a previously identified rounding issue.

controller/node-js/test · high confidence

The Android build system has been restructured with new Gradle configurations for the robot and controller modules, upgrading the Android SDK and build tools to version 36 and setting the Java/Kotlin target to version 17. The robot app now integrates the LiteRT library (TensorFlow Lite successor) for model inference and downloads network assets automatically during the build process. The controller app utilizes a shared local library module (comlib) to manage dependencies like USB serial and Wroup via downloaded AAR files, and both apps filter x86 ABIs to reduce APK size while adopting WebRTC SDK version 150.7871.01 for video streaming.

(dependencies) · high confidence

The Android build system now uses Gradle 8.9 (via the wrapper configuration) instead of the previous version, ensuring consistent build environments and leveraging updates in the Gradle build toolchain.

android/gradle · high confidence

The android/robot module now includes a .gitignore file to exclude build artifacts, a ContributionGuide.md detailing the single-activity architecture and how to add new features, and localized README files in German, Spanish, French, and Korean to support international users.

android/robot · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 35 → 37 (+1.9)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 67 → 67 (-0.3)
• Architecture 75 → 68 (-6.5)
• Maturity 69 → 70 (+1.5)
• Readiness 22 → 21 (-1.2)
• Security 50 → 68 (+18.3)
• Accessibility 34 → 32 (-1.7)
• Performance 82 (new)

• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [CVE redacted] (policy/frontend/yarn.lock)
• Critical CVE: [GHSA redacted] (policy/frontend/yarn.lock)
• Critical vulnerability: [GHSA redacted] (policy/frontend/yarn.lock)
• Documentation: no installation or build instructions (README.md)
• …and 193 more

• CVPixelBuffer.resized (cognitive 32) (ios/OpenBot/OpenBot/Utils/BlueDress/CVPixelBuffer+.swift)
• CVPixelBuffer.resized (cyclomatic 21) (ios/OpenBot/OpenBot/Utils/BlueDress/CVPixelBuffer+.swift)
• Critical vulnerability: [GHSA redacted] (policy/frontend/yarn.lock)
• Documentation: no contributor guidance (README.md)
• Documentation: no project overview (controller/web-server/README.md)
• Duplicated block (10 lines × 2) (android/robot/src/main/java/org/openbot/app/robot/tflite/Autopilot.java)
• Duplicated block (10 lines × 2) (android/robot/src/main/java/org/openbot/app/robot/tflite/Detector.java)
• Duplicated block (10 lines × 2) (android/robot/src/main/java/org/openbot/app/robot/tflite/Detector.java)
• Duplicated block (10 lines × 2) (policy/openbot/callbacks.py)
• Duplicated block (10 lines × 2) (policy/openbot/callbacks.py)
• Duplicated block (10 lines × 3) (policy/openbot/models.py)
• Duplicated block (10 lines × 4) (android/robot/src/main/java/org/openbot/app/robot/projects/BlocklyExecutingFragment.java)
• Duplicated block (11 lines × 2) (android/robot/src/main/java/org/openbot/app/robot/autopilot/AutopilotFragment.java)
• Duplicated block (11 lines × 2) (android/robot/src/main/java/org/openbot/app/robot/autopilot/AutopilotFragment.java)
• Duplicated block (11 lines × 2) (android/robot/src/main/java/org/openbot/app/robot/objectNav/ObjectNavFragment.java)
• Duplicated block (11 lines × 2) (android/robot/src/main/java/org/openbot/app/robot/pointGoalNavigation/PointGoalNavigationFragment.java)
• Duplicated block (11 lines × 2) (ios/OpenBot/OpenBot/Controllers/Project/ProjectFragement.swift)
• Duplicated block (11 lines × 3) (android/robot/src/main/java/org/openbot/app/robot/autopilot/AutopilotFragment.java)
• Duplicated block (11 lines × 3) (policy/openbot/models.py)
• Duplicated block (12 lines × 2) (android/robot/src/main/java/org/openbot/app/robot/env/ImageUtils.java)
• …and 150 more

• 2 commits — 1 feature/other, 1 fixes

• android/comlib — 1 commit
• android/robot — 1 commit

• fix: Fixed app crash issue in ponitgoal navigation (#542)
• change: Updated Android releases.yml for keystore and google-services secrets, along with 16 KB device compatibility. (#538)

• Containers 0 added · 0 removed · contexts 1 added · 2 removed · edges 0 added · 0 removed

• robot

• android
• repository

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

ob-f/OpenBot was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.