Stop Buying Overpriced Smart Displays! Build Clawd Mochi for $7

Stop Buying Overpriced Smart Displays! Build Clawd Mochi for $7

What if I told you that developers are paying $80+ for novelty desk gadgets that do less than this $7 build? The secret hardware hackers don't want you to know? You can build a WiFi-controlled, animated pixel mascot in under an hour — no soldering iron required, no cloud subscriptions, no app store dependencies. Meet Clawd Mochi, the physical desk companion inspired by Anthropic's beloved pixel-crab mascot from Claude Code. This isn't another overpriced resin figurine collecting dust. It's a living, breathing (well, blinking) piece of pixel art that responds to your phone in real-time. And here's the kicker: it works completely offline. No internet. No cloud. No privacy nightmares. Just pure, open-source hardware magic sitting on your desk, making every coding session feel slightly less isolating. Ready to discover why this tiny ESP32 project is exploding across developer Twitter? Let's dive in.

What is Clawd Mochi?

Clawd Mochi is an independent fan project created by developer Yousif Amanuel — a physical desk companion that brings Anthropic's pixel-crab mascot "Clawd" into the real world. Inspired by the character that appears in Claude Code's interface, this build transforms a static digital icon into an interactive, animated companion that lives on your workspace.

The project centers around an ESP32-C3 Super Mini microcontroller — Espressif's ultra-low-cost, WiFi-enabled chip that's become the darling of hobbyist electronics. Paired with a 1.54" ST7789 color TFT display (240×240 resolution), Clawd Mochi renders crisp pixel-art animations directly on your desk. The entire system operates as a self-contained WiFi access point, serving a mobile web controller that any phone or browser can access instantly.

What makes this project genuinely remarkable isn't just the adorable factor — it's the architectural philosophy. In an era where every "smart" device demands cloud connectivity, account creation, and firmware updates that break features, Clawd Mochi runs entirely locally. The ESP32 hosts its own WiFi network (ClaWD-Mochi with password clawd1234), serves the web interface from onboard storage, and processes all interactions without ever touching the internet. This isn't just privacy-respecting; it's anti-fragile. Your desk companion will work exactly the same in ten years as it does today.

The project has gained serious traction because it hits a rare sweet spot: genuinely beginner-accessible (estimated build time: ~1 hour, skill level: beginner) while offering deep customization potential for advanced makers. At approximately $6–8 total cost, it undercuts virtually every commercial alternative by an order of magnitude. The 3D-printable case — available on MakerWorld with both standard and "squished eyes" variants — completes the package with professional-looking enclosure options.

Critical disclaimer: This is an independent fan project with no affiliation, sponsorship, or endorsement from Anthropic. "Claude" and "Clawd" are trademarks of Anthropic.

Key Features That Make Clawd Mochi Special

Let's dissect what separates this build from the sea of Arduino starter projects that collect dust in drawers:

Self-Hosted Web Controller — Zero Dependencies The ESP32-C3 doesn't just connect to WiFi; it becomes the WiFi network. When you power on Clawd Mochi, it broadcasts the ClaWD-Mochi SSID and serves the complete control interface from its own flash memory. No router configuration. No port forwarding. No "download our app" friction. Point your browser to 192.168.4.1 and you're controlling animations within seconds. This architecture means the controller works on any device with a browser — iOS, Android, Linux, that ancient tablet in your drawer — with zero compatibility concerns.

Hardware SPI for Silky Animations The wiring specification explicitly routes display signals through GPIO 8 (SCK) and GPIO 10 (MOSI) — the ESP32-C3's dedicated hardware SPI pins. This isn't casual advice; hardware SPI operates at bus speeds impossible to achieve with software-emulated SPI, enabling smooth animation frame rates without CPU overhead. The warning against GPIO 6/7 exists because those pins connect to the ESP32-C3's integrated flash memory — using them would corrupt firmware or cause erratic behavior.

Multiple Expression Modes with Distinct Personalities Clawd Mochi isn't a one-trick pixel pony. The Normal eyes mode features procedural wiggle and blink animations that feel alive. Squish eyes (> <) delivers an adorable happy-squint with satisfying open/close mechanics. Claude Code mode transforms the display into an interactive terminal aesthetic — perfect for maintaining thematic consistency with your actual development environment. The Canvas mode is where things get wild: real-time drawing from your phone directly to the 1.54" display, with configurable pen colors and background switching.

Animation Speed Control & Backlight Management The speed slider isn't cosmetic — it adjusts global animation timing variables, letting you calibrate between energetic hyperactivity and meditative slow-blinking. The display on/off toggle controls the backlight GPIO directly, useful for nighttime desk presence without light pollution.

Single-File Firmware Architecture The entire project compiles as one clawd_mochi.ino file. This deliberate constraint makes the project radically accessible to Arduino IDE users who might panic at complex PlatformIO configurations or multi-file C++ projects. Advanced users can still extend functionality, but the barrier to entry remains intentionally low.

Real-World Use Cases Where Clawd Mochi Shines

The Focus Companion Place Clawd Mochi in peripheral vision during deep work sessions. The gentle blink animation provides just enough ambient movement to prevent workspace sterility without demanding attention. Unlike notification-obsessed smart displays, it never interrupts with "You have a new email!" — it simply exists, a digital pet that respects your flow state.

Stream & Content Creation Prop Twitch streamers and YouTube creators use desk aesthetics as personal branding. Clawd Mochi's Claude Code mode creates instant thematic resonance for programming content. Switch to Canvas mode during breaks and doodle viewer suggestions in real-time — interactive engagement without complex OBS plugins.

IoT Development Learning Platform For developers transitioning from pure software to hardware, Clawd Mochi is the perfect bridge project. It demonstrates: SPI communication protocols, WiFi access point configuration, embedded web server implementation, GPIO control, and real-time user interface design — all in a single, well-documented codebase. The immediate visual feedback makes debugging intuitive; when your code works, a crab blinks at you. When it doesn't, nothing happens. Clear. Satisfying.

Kids' Introduction to Electronics The $7 price point and ~1 hour build time make this ideal for introducing children (or skeptical adults) to maker culture. The 3D-printed case provides instant gratification — "we're building a robot!" — while the wiring teaches fundamental electronics concepts. The web controller gives immediate, magical-seeming control that hooks interest for deeper learning.

Custom Notification Badge With the project's MIT license and extensible architecture, advanced users can modify the firmware to accept MQTT messages or HTTP webhooks. Transform Clawd Mochi into a physical CI/CD status indicator — green background for passing builds, red for failures, animated panic for production incidents. The ST7789's 240×240 resolution supports surprisingly detailed status icons.

Step-by-Step Installation & Setup Guide

Hardware Assembly

First, gather your components. You'll need: ESP32-C3 Super Mini ($2.50), ST7789 1.54" TFT display ($3.00), 8 short Dupont/jumper wires 8–10cm ($0.50), 2× M2×6mm screws ($0.10), double-sided tape (~$0.10), and a USB-C cable for power. Total: approximately $7–8.

Critical wiring warning: Connect VCC to 3.3V only — never 5V. The ST7789 will be destroyed by 5V logic. Use GPIO 8 and 10 for SPI (hardware SPI, fast). Do not use GPIO 6/7 for SPI — these connect to the ESP32-C3's flash memory.

Software Installation

Step 1 — Install Arduino IDE 2.x Download from arduino.cc and install.

Step 2 — Add ESP32 board support Open Arduino IDE → File → Preferences. In "Additional boards manager URLs" paste:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

Go to Tools → Board → Boards Manager, search esp32, install "esp32 by Espressif Systems".

Step 3 — Install libraries Go to Tools → Library Manager and install:

• Adafruit GFX Library
• Adafruit ST7735 and ST7789 Library

Step 4 — Configure board settings

USB CDC On Boot must be Enabled — without this, serial communication fails and uploads may appear to hang silently.

Step 5 — Upload firmware

# Clone the repository
git clone https://github.com/yousifamanuel/clawd-mochi.git

# Or download ZIP and extract

Open clawd_mochi/clawd_mochi.ino in Arduino IDE. Connect the ESP32 via USB-C, select the correct port under Tools → Port, and click Upload (→ arrow). Wait for "Hard resetting via RTS pin..." — this confirms success.

First Boot & Connection

1. Power the ESP32 via USB-C (any charger or power bank works)
2. Wait ~3 seconds for boot animation completion
3. On your phone or computer, open WiFi settings
4. Connect to network: ClaWD-Mochi · password: clawd1234
5. Open browser, navigate to http://192.168.4.1

The web controller appears instantly — no loading spinners, no analytics scripts, no cookie banners. Pure functional minimalism.

REAL Code Examples from the Repository

Let's examine actual code from the Clawd Mochi project, with detailed explanations of how this embedded magic works.

Customizing Eye Geometry

Near the top of clawd_mochi.ino, you'll find these critical constants that control the entire facial expression system:

#define EYE_W   30    // eye width in pixels
#define EYE_H   60    // eye height in pixels
#define EYE_GAP 120   // gap between eyes (center-to-center)
#define EYE_OX  0     // horizontal offset from center (negative = left)
#define EYE_OY  40    // vertical offset upward from center line

These #define macros are preprocessor directives — they don't consume RAM at runtime but are substituted directly during compilation. This is crucial on memory-constrained ESP32-C3 devices. The EYE_W and EYE_H values determine the base rectangle dimensions for the "Normal eyes" mode, while EYE_GAP controls the interocular distance. The EYE_OX and EYE_OY offsets allow fine-tuning positioning without rewriting animation math.

Practical modification: For a "wide-eyed surprised" look, increase EYE_H to 75 and reduce EYE_GAP to 100. For a "narrow suspicious" expression, drop EYE_W to 20 and increase EYE_GAP to 140. The animation system automatically adapates because all positioning calculations reference these constants.

Logo Animation Timing Control

The animLogoReveal() function contains two critical timing parameters:

// In animLogoReveal() — how long logo holds after animation completes
delay(1500);       // milliseconds — change this number

// Speed of the reveal drawing stroke by stroke
delay(speedMs(8)); // lower = faster, higher = slower

The first delay(1500) controls the dwell time — how long the fully-revealed "Claude Code" logo remains static before transitioning to the next mode. This isn't just aesthetic; it ensures viewers have time to read and recognize the branding. For a snappier feel, reduce to 800. For dramatic emphasis, extend to 3000.

The second line uses speedMs(8), a helper function that translates abstract speed levels into millisecond delays. The parameter 8 represents the stroke-by-stroke drawing speed during the reveal animation. Lower values accelerate the "drawing" effect, making the logo appear to sketch itself rapidly. Higher values create a deliberate, hand-drawn quality. The speedMs() wrapper likely incorporates the global speed slider value, enabling user control over this parameter without code modification.

Pro insight: The delay() calls here are blocking — the ESP32 does nothing else during these pauses. For a responsive system, this might seem problematic, but in single-task animation sequences, blocking simplifies state management dramatically. The web server likely runs on a separate FreeRTOS task, maintaining responsiveness despite these delays.

Understanding the Hardware SPI Pin Selection

While not explicit code, the wiring table encodes critical architectural decisions:

// Hardware SPI pins (ESP32-C3 specific — DO NOT CHANGE)
// SDA/MOSI → GPIO 10  (hardware SPI data out)
// SCL/SCK  → GPIO 8   (hardware SPI clock)
// 
// CRITICAL: GPIO 6/7 are RESERVED for flash memory
// Using them for SPI causes firmware corruption or boot loops

The ESP32-C3's SPI peripheral has dedicated pin mappings that bypass GPIO matrix routing, achieving maximum throughput. Software SPI — where any GPIO pins bit-bang the protocol — would consume significant CPU cycles and limit animation frame rates. By constraining to hardware SPI pins, the project reserves CPU bandwidth for animation computation and web server handling.

The RES (reset), DC (data/command), CS (chip select), and BL (backlight) pins use general-purpose GPIOs because they don't require high-speed signaling. This mixed approach — hardware SPI for data, GPIO for control — is the canonical pattern for TFT display interfacing.

Advanced Usage & Best Practices

Power Optimization for Battery Operation While designed for USB-C power, the ESP32-C3 supports deep sleep modes. Advanced users can modify the firmware to enter light sleep between animation frames, reducing consumption from ~80mA to ~20mA. For true battery operation, add a small LiPo cell with TP4056 charging module — though this requires case modification.

OTA Update Implementation The contribution guidelines suggest OTA updates as a desired enhancement. Implementing ArduinoOTA is straightforward on ESP32: include the library, set authentication password, and call ArduinoOTA.handle() in loop(). This eliminates physical USB connection for firmware updates — crucial once Clawd Mochi is sealed in its case.

MQTT Integration for Smart Home The most impactful extension: add PubSubClient library, connect to your WiFi infrastructure (instead of AP mode), and subscribe to MQTT topics. Map messages to modes: clawd-mochi/mode/set normal triggers eye animation, clawd-mochi/canvas/draw accepts base64 image data. Suddenly your desk companion responds to Home Assistant automations — flash red when CI fails, show weather on morning startup.

Display Longevity The ST7789 TFT has finite backlight lifetime (~10,000 hours typical). Use the web controller's display toggle aggressively, or implement automatic dimming after idle periods. The BL pin on GPIO 3 supports PWM dimming — modify firmware to reduce duty cycle rather than hard on/off for smoother operation.

Case Print Optimization The recommended 15% gyroid infill balances strength and material usage. For faster prints, use 10% with 3 walls. For maximum durability (if your desk companion travels), increase to 20% with 4 walls. The face-down orientation with supports for the display window overhang is non-negotiable — printing vertically would require support material on visible surfaces, ruining finish quality.

Comparison with Alternatives

Why Clawd Mochi wins: At 25× cheaper than commercial alternatives with zero ongoing costs or dependencies, it delivers comparable core functionality with absolute control. The Tidbyt offers superior resolution and polished apps, but requires subscription services for full functionality and could be discontinued. LaMetric TIME is essentially a notification ticker with limited visual expression. DIY Arduino solutions lack the integrated web controller and polished case design.

For developers specifically, Clawd Mochi's Claude Code thematic integration creates unique desk environment coherence that no commercial product replicates. The single-file firmware architecture also makes it uniquely hackable compared to multi-file commercial codebases.

FAQ

Is Clawd Mochi officially affiliated with Anthropic or Claude Code? No. This is an independent fan project by Yousif Amanuel with no affiliation, sponsorship, or endorsement from Anthropic. "Claude" and "Clawd" are trademarks of Anthropic.

Can I use a different ESP32 variant instead of the C3 Super Mini? The ESP32-C3 was chosen for cost and size optimization. Standard ESP32 or ESP32-S3 will work with pin mapping adjustments, but the case dimensions assume the C3 Super Mini form factor. ESP8266 lacks sufficient GPIO and RAM for smooth operation.

Why does my display show garbled colors or stay white? 99% of issues stem from 5V on VCC (destroys display) or incorrect SPI pins (software SPI too slow). Verify 3.3V power, confirm GPIO 8/10 for SCL/SDA, and check that USB CDC On Boot is Enabled in board settings.

How do I modify the web controller interface? The HTML/CSS/JavaScript^{↗ Bright Coding Blog} is embedded as PROGMEM strings in the .ino file. Search for HTML literals, modify, and reflash. For substantial changes, consider moving to SPIFFS or LittleFS filesystem to separate web assets from firmware logic.

Can I connect Clawd Mochi to my home WiFi instead of using AP mode? The current firmware uses AP mode for zero-configuration setup. Modifying to STA mode (infrastructure connection) requires adding WiFi credentials, potentially via captive portal or hardcoded values. This is a suggested contribution area.

What's the power consumption? Can it run on battery? Typical draw is ~80mA at 5V (400mW). A 2000mAh power bank provides roughly 20 hours. For battery operation, implement sleep modes or add a LiPo with charging circuit.

Are the 3D models free to modify and sell? The electronics project is MIT licensed (permissive). 3D models and media are CC BY-NC-SA 4.0 — free to modify and share non-commercially, with attribution. Commercial use of the 3D models requires separate licensing.

Conclusion

Clawd Mochi represents everything right about modern maker culture: open-source hardware that respects users, absurdly accessible pricing that democratizes technology, and genuine personality that mass-produced gadgets can't replicate. In an hour and for less than a lunch expense, you can build something that sparks joy every time you glance at your desk — something that blinks back.

The project's single-file architecture keeps it approachable, while the extensible ESP32 platform ensures you'll never outgrow it. Whether you're seeking a focus companion, a learning project, or the foundation for a custom IoT notification system, Clawd Mochi delivers beyond its humble $7 price tag.

My take? This is the desk toy that developers didn't know they needed. The Tidbyt crowd will sneer at the resolution, but they'll be paying subscription fees while your Clawd Mochi outlives their third corporate acquisition. The true measure of a project isn't its spec sheet — it's whether you actually build it, and whether it still makes you smile six months later.

Ready to build yours? Grab the complete source code, 3D models, and detailed documentation from the official repository: github.com/yousifamanuel/clawd-mochi. Print that case, wire those eight connections, and welcome Clawd to your workspace. Your desk has been lonely long enough.