OpenBot: turning an Android phone into the brain of a $50 robot
OpenBot leverages smartphones as brains for low-cost robots. We have designed a small electric vehicle that costs about $50 and serves as a robot body. Our software stack for Android smartphones supports advanced robotics workloads such as person following and real-time autonomous navigation.
At a glance
- What is it?
- OpenBot pairs a printed or cardboard robot body with an Android app and an Arduino firmware board, using the phone for perception and control. It is a research and teaching platform first, and the build steps are the price of entry.
- Who is it for?
- Adopt OpenBot if you want a phone-based robot for teaching, a paper reproduction, or a person-following demo, and you are willing to 3D print or assemble a body and flash an Arduino board. Skip it if you need a warehouse-grade navigation stack, a supported commercial product, or anything that runs without an Android device attached.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 5 days ago.
- What is it written in?
- Mainly Swift, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 29, 2026, and from our analysis. They are not legal advice.
Editorial analysis
What OpenBot actually solves, and for whom
Building a mobile robot usually starts with the expensive part: the compute. Lidar, a GPU board, depth cameras and a battery to feed them can cost more than the chassis. OpenBot inverts that. The phone in your pocket already has a camera, an IMU, a screen, radios and a battery, so the project treats it as the robot's brain and reduces the body to motors, a microcontroller and a frame. The README describes a small electric vehicle that costs about $50 and serves as a robot body, with an Android software stack that supports workloads such as person following and real-time autonomous navigation.
The audience is therefore narrow and specific. It is a research and education platform: the citation block points at an ICRA 2021 paper by Matthias Müller and Vladlen Koltun, and the repository ships translated READMEs, disclaimers and contribution guides in Chinese, German, French, Spanish and Korean. That is the shape of a project built for classrooms, university labs and hobbyists who want to reproduce a paper rather than deploy a fleet. If you need a robot that works out of the box, the build steps are not incidental; they are the product.
Phone as brain, Arduino as spinal cord
The architecture splits cleanly along the USB or Bluetooth link between the phone and the vehicle. The phone runs the Android app, reads the camera, and decides what the motors should do. The Arduino firmware on the body receives those commands and drives the motor controller. The README's navigation path makes this explicit: build the robot body, flash the Arduino firmware, install the Android apps, then drive the robot via a controller.
Everything above that link is optional and modular. The controller/ directory holds a driving interface, open-code/ holds a programming playground, and policy/ holds training code for a driving policy. The repository also carries a python/ directory and an ios/ directory, so the Swift label on the repository is not the whole story: the primary Android experience lives under android/, while ios/ is a separate client. The practical consequence is that the phone is not a thin remote control. It is where the perception and the learned policy run, which is why the project can advertise person following and autonomous navigation at this price point.
Installing OpenBot and driving it once
There is no single installer. The README routes you through separate guides for each component, and the first step it asks for is reading DISCLAIMER.md. After that, the order is body, firmware, apps.
The repository itself is fetched by clone, which is also what the README recommends if you want to contribute, suggesting a fork first.
git clone https://github.com/ob-f/OpenBot.gitIf you only want the files without git history, the README also offers the repository as a zip archive from the master branch, which you extract into a folder of your choice. Once you have the tree, the firmware step is separate: the README points at firmware/README.md for flashing the Arduino. The Android side is documented in android/README.md, and the driving interface in controller/README.md. The README does not give the exact flash command or the app's package name in the top-level file, so follow those sub-READMEs rather than improvising.
For a first real use, the sequence the README implies is: assemble or print the body from body/, flash the board, install the Android app on the phone, mount the phone on the vehicle, and connect the controller. If you want to write behaviour rather than drive manually, open-code/README.md is the entry point for programming the robot, and policy/README.md covers training your own driving policy.
Where OpenBot stops being the right tool
The phone is the constraint as much as the selling point. Anything that requires a deterministic real-time loop, a hard real-time OS, or a compute module that stays with the robot will fight this design. When the phone leaves the body, the robot loses its perception and its policy; the Arduino alone can drive motors but does not see. For a research demo that is fine. For a deployed system it is a single point of failure that you cannot engineer around without replacing the architecture.
The documentation structure is the second limitation. The top-level README is an index, not a manual: it defers to body/README.md, firmware/README.md, android/README.md, controller/README.md, open-code/README.md and policy/README.md, and none of those files are summarized at the top level. The README does not document rollback, version compatibility between app and firmware, or a recovery path if a flash fails. Release history is uneven as well: v0.8.0 is dated 2025-03-03, while the two releases before it, v0.7.1 and v0.7.0, are from May 2023. Anyone expecting a steady cadence should plan around that gap.
How OpenBot compares with a Raspberry Pi robot
The obvious alternative in the same price bracket is a Raspberry Pi based rover, where a single-board computer is bolted to the chassis and owns the camera and the motors. The difference is not cost, it is where the compute lives and what you can upgrade. A Pi robot has a fixed camera and a fixed SoC; you choose them once. OpenBot's brain is a phone, so upgrading the robot means upgrading the phone, and the sensor suite improves with it. The trade is that you inherit Android's scheduling, its permission model and its battery behaviour, and you must write against the Android app rather than a Linux userspace.
A second alternative is a commercial educational robot with a closed stack. Those remove the build entirely, which is exactly the part OpenBot keeps. The project is MIT licensed, so the code and the design files are yours to modify, but the README's own framing is that you build the body, flash the firmware and install the apps. Choosing OpenBot means choosing to do that work.
Licence, maintenance and what an upgrade costs you
The repository is MIT licensed, and the README carries a separate DISCLAIMER.md plus translated disclaimers in five other languages. MIT is permissive: it lets you reuse and modify the code with attribution and without a copyleft obligation on your own work. The disclaimer is the part to read before you build, since it is the project's own statement of what it does not promise. This is not legal advice; if you plan to ship something derived from OpenBot, read LICENSE and DISCLAIMER.md yourself.
On maintenance: the last push to the default branch was on 2026-08-26, and the repository is not archived, so the tree is being touched. The release cadence tells a different story, with v0.8.0 in March 2025 and nothing tagged since. Upgrading therefore means tracking master, not a release. Because the Android app and the Arduino firmware are versioned separately in separate directories, an upgrade is a two-sided operation: pull the repository, then check whether the app and the firmware still agree on the link protocol. The README does not state a compatibility matrix, so that check falls to you.
Who should build an OpenBot
Build one if the point is to learn or to reproduce. A robotics course that wants students to touch perception, control and a learned policy without a hardware budget is the clearest fit, and the ICRA 2021 paper gives it a citable basis. A hobbyist who enjoys printing a chassis and flashing a board will get a person-following robot for roughly the price of the phone they already own. A lab that needs a cheap platform for collecting driving data, with policy/ for training, has a plausible reason too.
Do not build one if you need a supported product, a maintenance contract, or a robot that keeps working when the phone is removed. Do not start here if you have never flashed a microcontroller and do not want to; the README's first instruction is to read the disclaimer, and the rest is a build. The honest summary is that OpenBot is a well-documented research platform with an uneven release history, and its value to you depends entirely on whether the build is the thing you want or the thing you want to avoid.
Editorial conclusion
Adopt OpenBot if you want a phone-based robot for teaching, a paper reproduction, or a person-following demo, and you are willing to 3D print or assemble a body and flash an Arduino board. Skip it if you need a warehouse-grade navigation stack, a supported commercial product, or anything that runs without an Android device attached. Before buying parts, read DISCLAIMER.md, check the firmware README for the board it expects, and confirm the Android app builds against your phone's API level; the repository splits its guidance across body/, firmware/, android/, controller/, open-code/ and policy/, and none of those sub-READMEs are reproduced here.
Frequently asked questions
What is OpenBot?
OpenBot is a project that uses an Android smartphone as the brain of a low-cost robot. The README describes a small electric vehicle costing about $50 as the robot body, with a software stack for Android that supports person following and real-time autonomous navigation.
How do I install OpenBot?
There is no single installer. The README says to read the disclaimer, build the robot body, flash the Arduino firmware, install the Android apps, and then drive the robot via a controller, with each step documented in its own subdirectory README.
What are the alternatives to OpenBot?
The closest alternative in the same price range is a rover built around a single-board computer such as a Raspberry Pi, where the compute is fixed to the chassis instead of being a phone you can replace. OpenBot is MIT licensed, so its code and design are available to modify rather than being a closed product.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/ob-f-openbot)