Hand-written assembly doubles corner detection speed on a $2 ESP32-S3

BUILD

What it is

shraiwi wrote a FAST (Features from Accelerated Segment Test) corner detector for the ESP32-S3 that uses the chip’s 128-bit SIMD instructions. According to his own write-up, it runs at roughly double the speed of the reference implementation and processes a QVGA (320×240) frame in about 6 ms. Hackaday (Maya Posch, Oct 27, 2026) featured the project this week, but it isn’t new. Hackaday first covered it on July 1, 2024, and the Oct 27, 2026 article, titled “SIMD-accelerated Machine Vision On An ESP32-S3,” is its second look at the project. Think of this as a good project getting a second round of attention.

How it works

Board and chip. The only silicon involved is the ESP32-S3, a dual-core Xtensa LX7 microcontroller that runs at up to 240 MHz and has WiFi and BLE. Espressif’s developer portal lists 128-bit SIMD vector instructions among its features and aims the chip at edge-AI vision. The repository includes an sdkconfig for the Seeed XIAO ESP32S3, which suggests that was the development board.

Sensors and motors. There are none. This is a software and firmware project. The write-up doesn’t list external sensors, motors, or a bill of materials.

The speedup, in numbers. The GitHub README (shraiwi/simd-fast-esp32s3) reports about 11.2 megapixels per second on an ESP32-S3 at 240 MHz, roughly 2× a naive implementation. Hackaday repeats the ~2× figure. The README says that rate is enough for a VGA (640×480) stream at 30 fps. The arithmetic supports it: 640 × 480 × 30 = about 9.2 MP/s, which is under 11.2. The throughput figure covers the detector itself. Camera capture and any processing you do on the corners afterwards add to that time.

A note on “220%” vs “120%”. Coverage disagrees on the percentage, but every outlet is describing the same result. Hackaday’s 2024 post and the maker’s blog cite a jump from 5.1 to 11.2 MP/s as “220%.” Hackster calls it a 120% gain. 11.2 ÷ 5.1 ≈ 2.2, so the new speed is about 220% of the old one, which is a 120% increase. Either way, the detector got about twice as fast.

The code. FAST decides whether a pixel is a corner by comparing it to a ring of neighbouring pixels. A quick pre-test rejects most pixels early, before the full check runs. shraiwi found the SIMD instructions in the ESP32-S3 technical reference manual and wrote a SIMD version of that pre-test that handles 16 eight-bit pixels per vector register at once. Key details from the write-up and repo:

• Written in a mix of assembly and C.
• He wrote his own basic register allocator, “basm” (basm.py in the repo), to make the assembly easier to manage.
• It builds as a PlatformIO / ESP-IDF project (platformio.ini and CMakeLists.txt are in the repo).

Working around gaps in the instruction set. Both the maker and Hackaday note two missing features in the ESP32-S3 SIMD ISA:

1. No direct misaligned reads. Vector loads have to be worked around when pixel data doesn’t sit on aligned boundaries.
2. No unsigned 8-bit comparisons. Pixel brightness runs from 0–255 (unsigned), but the comparisons are signed. His fix is to XOR each byte with 0x80 on load. That maps 0–255 onto −128…127 and keeps the order intact, so signed arithmetic and comparisons give the correct answers.

What a cheap ESP32 can do with this. FAST corners are a common first step in feature-based vision, such as tracking points between frames, motion estimation, and image alignment. At this speed, the corner-finding stage fits inside a VGA, 30 fps budget on a microcontroller. The project itself is the detector and a benchmark. Building tracking or odometry on top of it would be your own work.

Parts list

Part	Role	Rough price
ESP32-S3 microcontroller	Runs the SIMD-accelerated FAST detector	~$2 for the chip (the only cost figure given, from the maker’s title)
Seeed XIAO ESP32S3 (or another ESP32-S3 board)	Development board; the repo ships an sdkconfig for it	Not listed in the write-up
USB cable and a computer with PlatformIO	Building and flashing	Not listed in the write-up

The “$2” in the headline refers to the bare chip. A ready-made dev board costs more.

How to build your own

• Difficulty: Advanced. This is our assessment based on the sources. To use the library you only need to be comfortable with PlatformIO. To extend it you need to write Xtensa LX7 SIMD assembly and handle the ISA gaps above by hand. The maker does say assembly on the ESP32-S3 “isn’t that bad” once you’ve studied some examples.
• Time (our estimate): An afternoon to build, flash, and run the benchmark if you already have a PlatformIO setup. Writing new SIMD routines in the same style will take much longer.
• Skills: ESP-IDF/PlatformIO workflow, C, reading a technical reference manual, and some assembly if you plan to change the kernels.
• Wiring or mechanical work: None.

Steps, at a high level:

1. Get an ESP32-S3 board. The XIAO ESP32S3 matches the config in the repo.
2. Install PlatformIO, then clone shraiwi/simd-fast-esp32s3 from GitHub.
3. Build and flash the project, then run the benchmark to check throughput on your hardware.
4. Hook the detector into your own image pipeline and feed it frames.
5. If you want to go deeper, read basm.py and the assembly alongside the ESP32-S3 TRM, Larry Bank’s blog, and Espressif’s esp-dsp and esp-dl libraries, which are the references the maker credits.

Check the license first. Hackster describes the code as published under an unspecified license. Look at the repo before you use it in anything you plan to share or sell.

What we would change

• A clear license. Adding one would make the library much easier to adopt.
• End-to-end numbers. We’d like to see a camera-to-corners pipeline benchmarked on real hardware, so builders know how much of the 30 fps VGA budget remains once capture runs too.
• A short guide to the workarounds. The XOR-0x80 trick and the misaligned-read handling are useful to anyone writing ESP32-S3 SIMD code. A standalone explainer would help people working on other image kernels.
• A parts note in the README. Naming the board it was tested on would save newcomers some guesswork.

Credit

This build is by shraiwi. The original write-up is on shraiwi.com, and the code is on GitHub at shraiwi/simd-fast-esp32s3. Hackaday covered it on July 1, 2024 (“SIMD-Accelerated Computer Vision On The ESP32-S3”) and again on Oct 27, 2026 (Maya Posch), and Hackster.io also wrote it up. According to Hackaday, much of the early ESP32-S3 SIMD groundwork came from Larry Bank, whom the maker credits along with Espressif’s esp-dsp and esp-dl libraries. Artoo Maker Lab didn’t build this. We’re pointing you to it because it’s worth your time.