zhouxiyu1997/friendmaker: an ESP32 workbench for scripted drawing on Nintendo Switch

What Friend Maker actually connects together

Friend Maker is a local automatic drawing workspace for Nintendo Switch Tomodachi Life. Its subject is a hardware chain rather than a piece of software: an ESP32 board that emulates a Switch Pro Controller, a desktop application that produces the drawing script, and the game that receives the button presses.

The project describes itself as a workbench for the real device loop, with four concerns wired together: ESP32 firmware flashing, serial ACK transport, Switch controller connection testing, and image-driven drawing. The desktop interface is organised as four pages that map onto that chain, labelled Firmware Flash, Controller Test, Timing Tune and Benchmark, and Script Studio. The order is the workflow: flash the board, prove the controller link works, tune the timing, then generate and run the script.

Images are imported as PNG, JPG, WEBP or SVG and turned into a pixel preview, statistics and an action script. Three drawing modes are supported, mono drawing, official palette drawing and custom multicolor. The board recommended is an ESP32-WROOM-32 or an ESP-32S, with ESP32 DevKitC and NodeMCU-32S named as common compatible boards, and the project advises choosing a version with a USB serial port that can be flashed directly.

The status badge in the project header says alpha, and the surrounding text agrees: the first priority is input stability rather than speed, and the four-page flow is explicitly aimed at people who already have the hardware and want to debug it rather than at a consumer one-click experience.

The two ways in: an installer package or the source tree

The project documents two entry routes that differ in installation but converge on the same four-page flow. The desktop package route is the fastest for a first try, with a macOS `.dmg` and a Windows x64 `.exe`. The source route is for running from source, debugging, or developing further.

The source route needs Node.js 20 or newer, npm 10 or newer, and PlatformIO Core 6 or newer, plus a working Python 3 when PlatformIO is installed by hand on Windows. The commands are short:

cd /path/to/friendmaker
npm install
npm run check
npm run ui:dev

`npm run check` runs the TypeScript compiler in no-emit mode over the project, so it is the quickest way to find out whether the tree is intact, and `npm run ui:dev` starts the web interface server. The package manifest names the project `switch-auto-draw` at version 1.0.0, marks it private, and lists a set of scripts that show the shape of the project: a desktop entry point, an electron main process, an end to end style desktop test target, local CI scripts that can skip the firmware step, and the packaging targets.

"check": "tsc -p tsconfig.json --noEmit",
"build": "tsc -p tsconfig.json && node scripts/copy-web-static.mjs",
"electron:dev": "npm run build && electron .",

The desktop application is an Electron application built with electron-builder, with separate targets for macOS and for Windows x64, and the build ships the firmware directory as an extra resource so that the installer carries the ESP32 sources needed for flashing. The repository also holds `Install Friend Maker.cmd` and `Start Friend Maker.command` launchers for Windows and macOS.

Firmware flashing and the Switch model you must choose

The Firmware Flash page does more than upload a binary, because the board and the console have to agree on the protocol. On first entry the page asks which Switch model you have, offering a Switch1 and Lite firmware and a Switch 2 firmware, and the dedicated builds for both of those exist only for the ESP32-WROOM-32 and ESP-32S mainline boards. The older standard Switch firmware is hidden from the interface and kept only as a command line fallback.

The source route flashes the same three environments through PlatformIO from the `firmware/esp32` directory:

pio run -e esp32dev_wireless -t upload
pio run -e esp32dev_wireless_switch2 -t upload
pio run -e esp32dev_wireless_switch_lite -t upload

If `pio` is not on the PATH, the project gives the full paths, `~/.platformio/penv/bin/pio` on macOS and `%USERPROFILE%\.platformio\penv\Scripts\pio.exe` on Windows.

There is a browser based alternative to the desktop flasher, an online flasher published on GitHub Pages, and the instruction there is to flash the build matching the Switch model you selected, then return to the Controller Test page in the desktop application. The application also handles the toolchain side of it: if PlatformIO is missing, the interface offers to prepare it, and if Python is missing it offers to download a local runtime for its own use. The documentation is explicit that the first preparation of PlatformIO, the toolchain download and some dependencies need a stable internet connection.

On Windows there is a specific path when PlatformIO is ready but no serial port appears, namely installing the CP210x driver first and then trying CH340 or CH341.

Timing, brushes and how a drawing actually runs

The Timing Tune page exists because the drawing is only as good as the input timing. The recommended order is to adjust `inputDelay` first and then fine tune `buttonPressDuration`. That sequence matters, because the delay governs when a press is sent and the duration governs how long it is held, and changing both at once makes it impossible to tell which one produced a mis-drawn pixel.

The Script Studio page imports an image, shows a pixel preview with statistics, and produces the action script. Six square pixel brush sizes are available, 1, 3, 7, 13, 19 and 27, while a round pixel brush is still reserved in the interface as a future calibration option. The canvas is modelled as 256 by 256 and the drawing run starts from the centre of the canvas, with template cropping, guide line previews and automatic background removal available before the run. Before the real drawing starts, the application switches to the selected pixel brush itself, so the brush does not have to be chosen in the game by hand.

A run can be paused, continued or interrupted, and a recovery point is saved, so a task can be resumed from the local state after a crash or a restart. The action script reaches the board over a serial ACK transport, which is why the page shows a connection status and why the Controller Test page comes before the studio in the workflow.

The three drawing modes carry different constraints. Official palette drawing depends on the game's default state of nine colour slots, so it inherits whatever the game currently has loaded. Custom multicolor needs a palette the user sets up. Mono drawing is the mode the project suggests for a first trial, with a structurally simple image, because it isolates the transport and timing from the colour logic.

The limits the project states about itself

The documentation is unusually direct about what is not supported, and that list is the best guide to whether the tool fits a setup.

On platform support, desktop installers exist for macOS and Windows x64. Windows ARM64 is listed as not supported and Linux as not officially supported yet. On hardware, ESP32-C3, ESP32-S3 and ESP32-C6 are advised against as mainline boards, and a data-capable USB cable is required.

On behaviour, the current drawing and recovery flows assume a single starting point, resuming from the centre of the canvas after returning to the drawing page, and the main canvas is not treated as a bounded plane that can be reliably aligned to the top left. The automatic background removal is described as suited to white, light grey and checkerboard fake transparency material, explicitly not as an AI cutout. Continuing to use the controller or touching the screen after drawing starts can cause misalignment.

Stability is a hardware question as much as a software one. The project notes that some ESP32 compatible boards differ individually, that frequent disconnects, stuck keys or unexpected repeated presses call for checking the cable, the power supply and the board quality, that a clean Bluetooth environment with fewer nearby active devices helps, and that some boards degrade when running for a long time or running hot.

None of this is hidden, and the first use guidance is to work through the steps in order rather than expecting a working drawing in the first ten minutes.

Licence, attribution and the state of the project

The project is released under GPL-3.0-or-later, with the full text in the LICENSE file. The reason for that choice is stated in the same place: the Switch Bluetooth implementation in `firmware/esp32` is introduced and rewritten from the ideas and code paths of UARTSwitchCon, so the repository keeps the GPL to stay consistent with the original work. The source author is credited by name, and the request is that anyone reposting or sharing the project credits that name and includes the original release address.

That attribution detail is a practical one for anyone who distributes the firmware, since the derived implementation is what makes the licence obligation apply in the first place. Whether a particular distribution obliges you to do anything is a question for whoever handles compliance.

On the state of the work, the recent releases are v1.0.0 on 2026-09-08, v0.7.2 on 2026-07-27 and v0.7.1 on 2026-05-19, and the last push was on 2026-09-08. The header badge still says alpha, and the version numbering tells the same story, a 1.0.0 release for the desktop workbench after a run of 0.7.x builds.

The repository structure reflects the split of concerns in the project: `firmware/` for the ESP32 side, `apps/` for the desktop application, `build/` for packaging assets, `drivers/` for the Windows serial drivers, `patches/` and `profiles/` for the packaging and configuration work, `examples/` with a demo SVG and command lists, `site/` for the GitHub Pages content including the browser flasher, `scripts/` for the launch and CI scripts, and `docs/` for the guides the Chinese navigation links to, covering the trial guide, troubleshooting, wiring, the platform notes for Windows and macOS, the development manual and the product requirements document.

Editorial conclusion

Adopt Friend Maker if you own a Nintendo Switch and an ESP32-WROOM-32 or ESP-32S board, and you want firmware flashing, controller pairing, timing tuning and script generation in one local desktop tool rather than a pile of serial scripts. Do not adopt it if you need Linux support, if your board is an ESP32-C3, S3 or C6, or if you need drawing that starts from a corner rather than the centre of the canvas, because the current model assumes a centre start. Before the first run, confirm the Switch model matches the firmware build you flash, keep a stable network connection for the initial PlatformIO and toolchain download, and expect a calibration and timing pass before the first acceptable drawing.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. Project website
3. README
4. Releases
5. zhouxiyu1997/friendmaker on GitHub