Go Marker: A DIY Navigation Display for Your Bike

What It Is and How to Build It

Go Marker is a small round display for your bike. It shows turn-by-turn directions from your iPhone: the next turn, how far away it is, the street name, and a map with your route on it. Swipe and you get weather, trip stats, a compass with your elevation, and a clock.

The display is dumb on purpose. Your phone does the routing, the GPS, the map data, and the weather, then sends the results over Bluetooth. The display only draws them. That keeps the hardware down to one inexpensive board and a USB cable.

The Go Marker iPhone app is not part of the download. I am preparing it for the App Store. This guide builds the display: the firmware, the screens, and the desktop simulator. The Bluetooth messages between the phone and the display are written down in proto/nav_protocol.h, in case you want to write your own app.

What it does

• Map page. A big arrow for the next turn, the distance, the street, and a map that turns with you showing your route, nearby streets, parks, and water. It also shows miles left and arrival time. The map zooms in as a turn gets close and zooms out at highway speed. With no route running, it shows a map around you with your speed and the temperature.
• Turn arrows for turns, forks, highway exits, merges, and roundabouts. A roundabout shows its real exits and which one to take.
• Weather page. Current conditions, the wind relative to the way you are riding, chance of rain, and the next four hours.
• Trip page. Distance, moving time, average and top speed, total time, and stopped time. It is saved to the board’s flash every 10 seconds while you ride and 2 seconds after you stop, so switching the bike off loses nothing. Hold to reset.
• Compass page. A rotating compass ring with your elevation and climb rate. It uses the phone’s compass, so it works when you are stopped.
• Clock page.
• Themes. Standard, Vintage (green, like an old gauge cluster), and Tripper (black and gold, like a modern dash). Each comes as a day, a night, or an auto version. Auto follows sunrise and sunset where you are. There is a brightness setting for day and night.
• In the phone app (coming soon): search for a place, choose between alternate routes, add stops, and it reroutes if you leave the route. You can also change the order of the display’s pages, and turn the display’s optional spoken “Power on” and “Connected” on or off.
• Units are miles, feet, mph, and °F by default. A switch in the app changes everything to kilometers, meters, km/h, and °C. A second switch changes the clock between 12-hour and 24-hour.

How it works

Two devices share the job and talk over Bluetooth.

Your iPhone works everything out:

• Where you are, from its GPS and compass.
• The route and each turn, from Apple Maps.
• The map streets, parks, and water, from OpenStreetMap.
• The weather, from Apple Weather.

The display only shows it. It takes what the phone sends and draws it on the screen. It has no GPS and no internet of its own, so it needs the phone to work.

About once a second the phone sends a small status message: position, speed, heading, the next turn, its distance, the street name, and time left. Less often it sends the next few miles of route, the streets, parks, and water around you, and the weather. Every message is a small fixed-size packet. They are all defined in one header file, proto/nav_protocol.h, which the display firmware and the simulator share, and which any phone app has to follow.

The code is in three folders:

• firmware/ is the ESP-IDF project for the board.
• ui/ and proto/ are the screen drawing code (written with LVGL 9) and the packet definitions. The board and the simulator both build them.
• sim/ is a desktop simulator that draws the same screens on your computer, so you can try the interface before you touch any hardware.

What you need

The hardware is in the parts list below. For software:

• A Mac. These steps are for macOS. The ESP32 tools also run on Linux and Windows, but I have not tried them.
• ESP-IDF 5.3.2, Espressif’s toolkit for the ESP32. Step 3 installs it, along with Python 3.11 from Homebrew.
• Homebrew, a free tool for installing programs from Terminal (install it from brew.sh). With it you install cmake and sdl2 if you want the simulator.

I built and tested all of this on a Mac with ESP-IDF 5.3.2.

Before you start

Do these once, before step 1. Each one heads off a confusing error later.

• Install Homebrew. Go to brew.sh, copy the install command from the top of the page into Terminal, and press Return. When it finishes it prints a “Next steps” section with a couple of commands. Run those too, so that Terminal can find brew. The installer also sets up Apple’s command line tools if you don’t have them, and those include the git command the steps use.
• Have about 4 GB of free disk space, ESP-IDF and its tools take about 2.7 GB. The firmware and simulator builds take most of the rest.
• Have a good internet connection. The first time through, several steps download large files, and the ESP-IDF download is the biggest. A slow connection just means waiting. Nothing is frozen unless a line prints an error.
• Have a USB-C cable that carries data for the display.
• If a line prints an error, stop there. Don’t run the next line. Copy the whole message and give it to Claude, or search for it.

Build it

NOTE: If you have trouble with the instructions, just have Claude do it for you.

The command-line steps are typed into Terminal. Terminal is the command-line app that comes with your Mac. To open it, press Command-Space, type Terminal, and press Return. Every dark box below with commands in it is meant for Terminal: type or paste one line, press Return, and wait for it to finish before the next line.

1. Get the code

Download the Go Marker source code (zip). Unzip it by double-clicking the file. You get a folder called go-marker. The commands below assume it is in your Downloads folder. If you put it somewhere else, use that path in the cd line at the top of each box. It is released under the Apache License 2.0, and the readme in the zip has a one-page summary of these steps.

2. Try it on your computer (optional)

The simulator shows the real screens riding a made-up route. In Terminal:

cd ~/Downloads/go-marker
brew install cmake sdl2
git clone --depth 1 --branch v9.4.0 https://github.com/lvgl/lvgl.git lvgl
cd sim
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j8
./build/nav_sim

Drag left or right in the window to swipe between pages. Close the window when you are done; Terminal then gives you its prompt back.

3. Flash the display

First, install ESP-IDF 5.3.2, the toolkit that builds the display’s software. You only do this once. In Terminal:

brew install python@3.11 cmake ninja dfu-util
export PATH="/opt/homebrew/opt/python@3.11/libexec/bin:$PATH"
mkdir -p ~/esp
cd ~/esp
git clone -b v5.3.2 --recursive https://github.com/espressif/esp-idf.git
cd esp-idf
./install.sh esp32s3

• The export PATH line makes Terminal use Python 3.11. ESP-IDF needs it. The Python that comes with macOS (3.9) gave me trouble.
• The git clone line downloads over a gigabyte, so it takes a while. install.sh then downloads the ESP32 compiler.
• On an Intel Mac, change /opt/homebrew to /usr/local.
• Espressif’s own getting-started guide covers the same steps if you want more detail.

Then build the software and put it on the display. Do this in every new Terminal window, starting with the first two lines. Plug the display into your Mac with the USB-C cable first:

export PATH="/opt/homebrew/opt/python@3.11/libexec/bin:$PATH"
source ~/esp/esp-idf/export.sh
cd ~/Downloads/go-marker/firmware
idf.py set-target esp32s3
idf.py build
ls /dev/cu.usbmodem*

The ls line prints the display’s port name, something like /dev/cu.usbmodem101. Use that name in the last line, in place of /dev/cu.usbmodemXXXX:

idf.py -p /dev/cu.usbmodemXXXX flash

• set-target is needed the first time only.
• The first build downloads LVGL (the screen library), so it needs internet, and it takes a few minutes.
• If your Mac doesn’t show a port, flip the USB-C plug. One orientation reaches the ESP32-S3 and the other reaches a second chip on the board.
• If a board gets stuck, hold the BOOT button while you plug it in.
• When it starts you will see the splash screen. It stays up until your phone connects.
• Optional, the spoken phrases. The display can say “Power on” and “Connected”. The recordings are not in the download. To make them on a Mac, run python3 main/voices/make_voices.py in the same firmware folder, then run the idf.py build and flash lines again. Without them the display just stays quiet.

4. The phone app

The phone app is not in the download yet, and I am preparing it for the App Store. Until it is out, the display shows its splash screen and waits for a phone. You can still see all of its screens in the simulator from step 2.

5. Power it from the bike

The display runs on 5 V over USB-C. Feed it from a 12 V to 5 V USB adapter on switched power, so it comes on with the ignition.

I run it without a battery. The board has a battery connector and I left it empty. A lithium cell in a closed case sitting in the sun is a bad idea, and the trip stats are already safe without one.

If something goes wrong

• The Mac doesn’t see the display. Flip the USB-C plug. Try another cable, because some only charge. Hold BOOT while plugging in.

Limits

• Apple Maps has no motorcycle mode. Routes use the driving profile, with highway and toll avoidance. It will not look for twisty roads.
• iPhone only. An Android app would be new work, but the display would not change. It only listens for Bluetooth packets.
• Roundabouts assume right-hand traffic.
• Street names and turns come from Apple Maps. Roundabout exits and merge sides come from OpenStreetMap. They are only as good as that data. I check my own routes against Apple’s raw data and fix what I find, but read the road too.
• About 11 frames a second on the map page. That looks smooth on a bike.
• Sun and weather. Waveshare does not publish the screen’s brightness, but it seems to work in full sun. The board is not waterproof.

License and safety

The display firmware, the screens, the simulator, and the Bluetooth packet definitions are released under the Apache License 2.0. The phone app is not part of that release. You can use the released code, change it, and share it, and the license has the usual “as is, no warranty” terms. The No Marker name and logo are not part of the license, so use your own splash picture. The readme lists the other people’s code and data it relies on.

This is a hobby project, not a safety device. Do not let it take your attention off the road. Set your route before you ride. Check the directions against the road and the signs yourself, and ride within your abilities and the law.

What’s next

• The iPhone app on the App Store.
• A weatherproof case with a mount (TBD).
• A version for a bigger 1.85-inch round screen. The layout already scales to its 360 by 360 pixels. The display and touch drivers are the work that is left.

Version history

The version number of your download is in the file VERSION in the top folder.

1.2, October 12, 2026

• The iPhone app is no longer part of the download. The download is now the display firmware, the screens, the simulator, and the Bluetooth packet definitions. The app is being prepared for the App Store, and this guide no longer has the steps for building it.
• Themes. The display now has Standard, Vintage, and Tripper looks, each as a day, a night, or an auto version. The phone chooses one over Bluetooth, and the display remembers it. The settings message grew from 6 to 7 bytes, and older phones that send the short form still work.
• The simulator has new options to show them: --vintage, --vintage-day, --vintage-auto, --tripper, --tripper-night, --tripper-auto, --standard-day, and --standard-night.
• The fade at the top and bottom of the map is smooth now, instead of a few visible bands.
• This guide no longer links to GitHub.

1.1, October 3, 2026

• The marker, the route line, and the streets are 25% bigger, in every view.
• With no route running, the map also zooms in 25% closer. While navigating, the turn corner stays where it was, just below the top panel.
• The simulator has a new --free option that shows the view you get with no route running.
• This guide now describes that view, and has this version history.

1.0, October 2, 2026

• First public release: the map, weather, trip, compass, and clock pages, turn arrows for turns, forks, exits, merges, and roundabouts, alternate routes and stops in the phone app, miles or kilometers, a 12-hour or 24-hour clock, and the build guide.