Post cover image

July 4, 2026

Turn ESP32 to a hacking gadget using esp32 marauder

Using an ESP32 Marauder Without a Screen: A Phone and Desktop Controller Over USB

By Developer Hacker

4 min read

Using an ESP32 Marauder Without a Screen: A Phone and Desktop Controller Over USB

The ESP32 Marauder is a well-known open-source project, but building one usually means adding a display and doing some wiring. This article describes a companion app I built that removes that requirement: it lets you drive a Marauder from an Android phone or a desktop computer over a plain USB cable, so a bare ESP32 board with no screen and no soldering becomes fully usable.

What the ESP32 Marauder is

The ESP32 Marauder, by justcallmekoko, is a suite of WiFi and Bluetooth offensive and defensive tools that runs on the ESP32 microcontroller. It can scan for access points and stations, capture and analyze probe requests, sniff Bluetooth and detect trackers such as AirTags, read GPS data, and run various test and attack functions. It is widely used for wireless security testing and education.

Most Marauder builds are designed around a small touchscreen. The firmware has an on-device menu system, and boards are commonly sold or built with a TFT display so the whole thing works as a standalone handheld: you navigate the menus by touch and read results on the screen.

That screen is convenient, but it is also the part of the build that adds the most cost and effort.

The idea: let the phone or computer be the screen

The premise of the app is simple. The board already talks over USB serial for flashing and for its command-line interface. If the host on the other end of that cable can both display results and send commands, then the board does not need its own screen. The phone or the computer becomes the display and the input surface.

Concretely, you connect a bare ESP32 running the Marauder firmware to an Android phone with a USB-OTG cable, or to a Linux or Windows computer with an ordinary USB cable, and the app gives you the full menu system, live results, and controls. Nothing else is required: no PC-side server, no second device, no extra hardware beyond the board and the cable.

Making the firmware speak a clean protocol

To make this reliable, I did not want the app to scrape the human-readable command-line text, which is formatted for people and changes shape depending on context. Instead I added a small, machine-readable layer to the firmware: a JSON serial interface.

The design goals were deliberately conservative:

  • Additive and low-risk. The scanning internals are untouched. The new commands only read the data structures the firmware already maintains, and existing CLI behavior is unchanged.
  • Parser-friendly. Every machine-readable line is prefixed with [@J](http://twitter.com/J) followed by a single self-contained JSON object with a type tag, so a host can cleanly separate structured data from ordinary console text.
  • Board-neutral. It compiles and behaves identically on every board, with a screen or without one.
  • Quiet by default. Continuous streaming output is opt-in, so a plain serial monitor is never flooded.

The host connects, sends jsoninfo to handshake and learn the board's capabilities, polls jsonstatus for live state, and reads structured lists such as access points, stations, SSIDs, IPs, probe requests, and AirTags with jsonlist. Each list ends with an explicit terminator line stating how many rows were sent, so the app always knows when a list is complete.

Importantly, this layer also brought the graphical analyzers out from behind the screen. The Channel Analyzer, Bluetooth Analyzer, and Channel Activity views were refactored so that the sample computation and the data emit run unconditionally, while only the on-device chart drawing remains tied to the display. A new analyzer command starts them with no screen interaction. The result is that a screen-free board can now stream the same analyzer data that previously required a touchscreen.

This firmware work was submitted upstream as a pull request to the original project, and is available in the meantime from a public fork.

Why this lowers the barrier to building one

Put together, the effect is that the display stops being part of the build. To have a working Marauder you now need:

  • A bare ESP32 development board, off the shelf.
  • A USB cable.
  • The app on a phone or computer.

There is no screen to source, no display pins to wire, and no soldering required for the display. Flashing the firmware is done over the same USB port you already have connected. For anyone who wants the tooling without committing to a hardware assembly project, this is a meaningfully lower barrier to entry, and it also makes cheap, minimal boards genuinely useful rather than half-featured.

It is worth being precise about scope: this does not change what the firmware can do, and it does not remove the need to flash the board or connect a serial adapter. What it removes is the display and its wiring.

The app itself

The controller exists in two forms that share the same interface and behavior:

  • Marauder Mobile — a native Kotlin and Jetpack Compose app for Android 8.0 and above, using USB-OTG serial. It supports the common serial bridges (CP210x, CH340/CH9102, FTDI, PL2303) as well as the ESP32's native USB, and it can auto-connect when the board is plugged in.
  • Marauder Desktop — a Compose for Desktop port that runs on Linux and Windows over ordinary USB serial. It is distributed as a self-contained build with its own bundled runtime, so there is nothing else to install.

Both mirror the firmware's own menu titles and ordering, so the layout is familiar to anyone who has used the device: WiFi with its sniffers, scanners, attacks, and general tools; Bluetooth sniffers and attacks; GPS; and device functions.

None

Summary

The ESP32 Marauder is a capable wireless testing platform, but its usual dependence on a touchscreen adds cost and assembly work to a DIY build. By adding a clean JSON serial interface to the firmware and building a phone and desktop controller around it, the display becomes optional. A bare ESP32 board and a USB cable are enough for a fully interactive experience, with live results and analyzers that previously required a screen. The firmware change is additive and has been offered back to the upstream project, so the same board keeps working exactly as before for everyone who does have a screen.

None