Build Your Own AI Desk Companion for Under $8
Imagine having a tiny electronic companion sitting beside your laptop, blinking its pixel eyes, displaying playful expressions, and responding to commands from your smartphone. Now imagine building it yourself for approximately $6–$8 using inexpensive electronics, a small color display, and a 3D-printed enclosure. That is the idea behind Clawd Mochi, an open-source desktop companion built around the ESP32-C3 microcontroller. Rather than requiring an expensive development board, a dedicated mobile application, or a cloud subscription, the project uses a local Wi-Fi connection and a browser-based controller to make interaction simple. It is an appealing example of how DIY electronics, embedded programming, and creative product design can come together in a small, affordable project.
For electronics enthusiasts, Arduino beginners, robotics fans, and makers who enjoy experimenting with microcontrollers, Clawd Mochi offers an approachable way to explore several useful technologies in one build. You can learn about SPI display communication, GPIO wiring, embedded C++, wireless networking, and basic web interfaces while creating something that looks entertaining on your desk. The project also includes printable enclosure files and firmware, making it easier to move from an idea to a working physical device. If you have been searching for an affordable ESP32-C3 project, a DIY electronic pet, or a compact open-source gadget to build over a weekend, this is a project worth exploring.
Project source code and build instructions: Clawd Mochi on GitHub.
What Is Clawd Mochi?
Clawd Mochi is a small, physical desktop companion inspired by the pixel-crab mascot associated with Claude Code. It uses an ESP32-C3 development board to drive a 1.54-inch color TFT screen, displaying animated eyes and interactive graphics inside a compact enclosure. Its defining feature is the ability to create its own Wi-Fi hotspot, allowing a phone or computer to connect directly to the device and open a web-based control panel. This means you do not need to install a separate application just to change its expressions or use its drawing interface. The original project documentation estimates a parts cost of around $6–$8 and a build time of approximately one hour, although actual costs depend on component suppliers and whether you already own the required tools.
The concept is particularly interesting because it combines the personality of a digital pet with the flexibility of a programmable electronics project. Instead of buying a finished gadget, you can assemble the hardware, upload the firmware, print the enclosure, and modify the software yourself. You can experiment with its appearance, adjust animation timing, or explore how a microcontroller serves a webpage over a local network. The result is a device that is both a fun desk accessory and a hands-on learning platform. Although it is described as AI-inspired, its original functionality is primarily based on programmed animations and browser controls rather than an onboard AI model.
Why This Tiny ESP32-C3 Project Is Worth Building
Small electronics projects are often most rewarding when they teach several skills without requiring a complicated setup. Clawd Mochi achieves this by combining a microcontroller, a graphical display, wireless connectivity, and a 3D-printed case in a single build. You do not need a Raspberry Pi, a large touchscreen, or a complex robotics platform to get started. Instead, you can learn how embedded hardware and software interact using relatively inexpensive components. For beginners, this is an opportunity to move beyond basic LED blinking and create a device with a visible interface and real user interaction.
The project is also useful for experienced makers who want a starting point for experimentation. You could study its firmware, change the display graphics, redesign the enclosure, or use the Wi-Fi controller as inspiration for other ESP32-based devices. Because the project files are publicly available, you can inspect how its display and web server work rather than treating the device as a sealed commercial product. Just remember that open-source availability does not automatically mean every design asset is unrestricted for commercial use; review the individual code and model licenses before redistributing or selling modified versions.
A Mini Display With Animated Pixel Eyes
The display gives Clawd Mochi its character. The original firmware includes expressive pixel-style eyes with blinking and movement animations, along with a squinting expression that makes the device feel more like a tiny electronic pet than a conventional development board. Since the display is controlled by software, the graphics can be adjusted without changing the underlying hardware. You can experiment with eye dimensions, spacing, colors, and animation speed to give the companion a different personality. The screen also supports other display modes, including a terminal-inspired view and a drawing canvas.
For makers interested in graphics programming, this is a useful introduction to drawing shapes, updating screen regions, and managing animation timing on a microcontroller. Even simple changes, such as making the eyes look sleepy or adding a new expression, can teach you how software controls a physical interface. The small display also encourages efficient coding because screen updates and memory use matter on embedded hardware. With a little experimentation, the same approach can be adapted to an electronic pet, a desktop notification display, or a custom status screen for another DIY project.
Wireless Control Without a Mobile App
One of the most convenient features is its browser-based interface. The ESP32-C3 can operate as a Wi-Fi access point, creating a wireless network that your phone or laptop can join directly. Once connected, you can open the local web address and use the available controls without installing an app or connecting the device to your home router. This architecture is supported by the ESP32 Arduino Wi-Fi API, which provides access-point functionality and can support an HTTP server running on the device itself.
The practical advantage is simplicity. A browser is already available on most smartphones, tablets, and computers, so the control interface is accessible across different platforms. You can switch expressions, adjust animation speed, change colors, or draw on the display using the options provided by the firmware. Because the original project is designed to work locally without an internet connection, it also offers a useful demonstration of how embedded devices can communicate without relying on cloud services. However, you should change the example Wi-Fi password before sharing a modified build with others, especially if you add features that expose sensitive information.
Essential Hardware and Components
The best part of this build is that it does not require a long list of expensive electronic components. The original GitHub repository specifies an ESP32-C3 Super Mini, a 1.54-inch ST7789 color TFT display, eight short jumper wires, two small screws, and a little double-sided tape. A USB-C cable supplies power during operation and connects the board to your computer for firmware uploads. The enclosure can be 3D-printed using a small amount of PLA or PETG filament, making it an excellent project for anyone with access to a desktop 3D printer. You can check the complete bill of materials and assembly instructions in the official Clawd Mochi repository.
Understanding the ESP32-C3 and ST7789 Display
The ESP32-C3 Super Mini is the central controller. It runs the firmware, communicates with the screen, and handles the Wi-Fi connection used by the browser interface. The ST7789 is the display controller used by the small 240 × 240-pixel TFT screen, which communicates with the ESP32-C3 over SPI. The display is compact enough to fit into a small desktop enclosure while providing sufficient resolution for colorful eyes, text, and simple drawings.
Here is a quick overview of the essential hardware.
| Component | Purpose | Estimated cost |
|---|---|---|
| ESP32-C3 Super Mini | Runs firmware and provides Wi-Fi | $2.50 |
| 1.54-inch ST7789 TFT | Displays graphics and animations | $3.00 |
| Jumper wires | Connects the display and controller | $0.50 |
| Two M2 × 6 mm screws | Secures the display bezel | $0.10 |
| Double-sided tape | Holds components inside the case | $0.10 |
| 3D-printed enclosure | Protects and supports the electronics | $0.50 |
| USB-C cable | Power and programming connection | Depends on availability |
Estimated prices are from the project documentation, not live retail quotations. The listed components total approximately $6.70 before any additional shipping or incidental costs.
Before purchasing anything, verify that the development board is specifically an ESP32-C3 model and that the screen uses the compatible ST7789 controller. Different boards can have different pin arrangements, even when their names look similar. Buying a display with a different controller or connector configuration may require firmware changes. Checking the product listing against the repository’s specifications is much easier than troubleshooting incompatible hardware after it arrives.
How Much Does Clawd Mochi Cost?
The headline price of under $8 makes this project particularly attractive to budget-conscious electronics enthusiasts. At that price, the device can be cheaper than many ready-made desktop gadgets, while giving you the freedom to inspect and modify its code. The published estimate assumes inexpensive components and a modest 3D-printed case. Your final cost may be higher if you need to purchase a USB cable, soldering equipment, filament, jumper wires in a larger pack, or individual components from a seller with expensive shipping.
If you are buying parts in India, remember that the dollar estimate does not guarantee the same total in rupees. Local inventory, import costs, taxes, and minimum order quantities can change the final bill considerably. You may also find that jumper wires and screws are cheaper when purchased as part of a larger kit. For a first-time builder, the smartest approach is to calculate the delivered cost of all components before ordering instead of comparing only the headline prices.
The project can also become more expensive if you choose a premium filament, redesign the case, or add extra electronics. Those changes are optional; you can begin with the original design and upgrade it later. The goal is to get the basic companion working before spending money on cosmetic improvements.
How to Build Clawd Mochi Step by Step
You do not need to be an embedded systems expert to assemble Clawd Mochi, but you should be comfortable following a wiring diagram and installing software. Set aside roughly an hour for assembly if your components are ready and your 3D-printed enclosure is already finished. Your first firmware upload may take longer because the computer needs to install the board support package and compile the project. Keep the official repository open while building so that you can check the current files and follow any updated instructions.
Step 1 — Prepare the Electronics
Start by laying out the ESP32-C3 Super Mini, the ST7789 display, the jumper wires, and the mounting hardware on a clean work surface. Compare the labels on your actual components with the wiring information in the repository. If you have a multimeter, use it to check for accidental shorts before connecting power. You should also inspect the display connector and the ESP32-C3 pins carefully, since tiny boards are easy to misidentify when several similar versions are sold online.
Keep the USB cable disconnected while wiring the display. This gives you time to check every connection without risking damage from a misplaced wire. If your components have solder pads rather than fitted headers, make sure the joints are secure and that adjacent pads are not bridged by excess solder. A basic electronics workbench, good lighting, and a little patience can prevent most first-build problems.
Step 2 — Connect the TFT Display
The original project uses the following GPIO assignments for its 1.54-inch ST7789 screen. These assignments are specific to the published firmware, so do not substitute arbitrary pins without updating the code.
| Display connection | ESP32-C3 pin |
|---|---|
| VCC | 3V3 |
| GND | GND |
| SDA / MOSI | GPIO 10 |
| SCL / SCK | GPIO 8 |
| RES | GPIO 2 |
| DC | GPIO 1 |
| CS | GPIO 4 |
| BL | GPIO 3 |
In this configuration, SDA carries SPI data and SCL carries the SPI clock; they do not serve the same roles as the similarly named I²C signals. The display’s reset, data/command, chip-select, and backlight pins must also match the firmware configuration. Connect the display’s VCC to 3.3 V, not 5 V, as specified in the project instructions.
Check the pin labels on your own screen before applying power, because similar-looking modules may use different labels or electrical requirements. After wiring, inspect the connections again against the table and the source code. Correct wiring is the foundation for reliable screen initialization, so it is worth spending a few extra minutes here.
Step 3 — Install Arduino IDE and Required Libraries
Download and install Arduino IDE 2.x from the official Arduino software website. Next, add the Espressif ESP32 board package through the Boards Manager URL documented in the project’s README:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Open Arduino IDE preferences, add the URL to the additional board manager URLs field, and save the settings. Open Boards Manager, search for ESP32, and install the package named esp32 by Espressif Systems. This package allows Arduino IDE to compile and upload firmware for supported ESP32 boards.
After the board package is installed, open Library Manager and install the two libraries listed by the original project:
- Adafruit GFX Library — provides graphics drawing functions.
- Adafruit ST7735 and ST7789 Library — provides the display driver.
Select ESP32C3 Dev Module from the board menu and configure the other settings according to the README. The original instructions specify enabling USB CDC On Boot, using a CPU frequency of 160 MHz, and setting the upload speed to 921600. Available settings can vary with the installed board package, so consult the repository if your IDE presents different options.
Step 4 — Upload the Firmware
Open the original Clawd Mochi GitHub repository, download the source files, and locate clawd_mochi.ino. Open the sketch in Arduino IDE, connect the ESP32-C3 to your computer using a suitable USB data cable, and select the appropriate serial port. A charge-only USB cable will not work for data uploads, so try a known data cable if the board does not appear in the port list.
Compile the sketch before uploading it. This gives you an opportunity to identify missing libraries or other errors while the board is still disconnected from the final enclosure. Once compilation succeeds, upload the firmware and wait for the IDE to finish. If the board fails to connect, check the selected port, cable, board settings, and boot procedure for your particular development board. After a successful upload, the display should run the project’s startup sequence.
Step 5 — Assemble the 3D-Printed Case
The enclosure turns the exposed electronics into a compact desktop companion. Download the case files linked by the repository and print the main body and back plate in PLA or PETG. The project documentation suggests a layer height of approximately 0.15–0.20 mm and around 15% gyroid infill. It also recommends printing the parts in an orientation that supports the enclosure geometry and using supports where required for the display-window overhang.
Test-fit the display before permanently securing anything. Route the jumper wires through the appropriate opening, attach the display bezel with the specified M2 screws, and secure the ESP32-C3 inside the back plate using double-sided tape. Make sure the USB-C port remains accessible and that the wires are not pinched when you close the case. Power the device again and confirm that the display works before completing the final assembly.
If you own a 3D printer, you can also experiment with different filament colors or create your own enclosure shape. Just preserve the mounting points, screen opening, cable access, and internal clearance needed by the electronics.
How to Control Clawd Mochi Using Your Phone
Once the hardware and firmware are ready, using Clawd Mochi is straightforward. Power the device through USB-C and wait for the startup animation to finish. Open the Wi-Fi settings on your smartphone and connect to the network named ClaWD-Mochi. The original firmware documents the default password as clawd1234. Once connected, open your phone’s browser and enter http://192.168.4.1 to access the control interface.
The interface provides controls for switching display modes, changing colors, adjusting animation speed, and using the drawing canvas. Because the ESP32-C3 hosts the web server, your phone communicates directly with the device over the local wireless network. An internet connection is not required for the original controller to work, although your phone may display a warning that the Wi-Fi network has no internet access. That is expected when you connect directly to a standalone device.
One important security consideration is that the documented default password is publicly visible in the source code. If you build the project, consider changing it before using the device around other people. Keep in mind that joining its hotspot may temporarily disconnect your phone from your normal internet connection.
Explore the Pixel Eyes, Terminal, and Drawing Modes
Clawd Mochi offers several different display experiences, making it more interesting than a screen that simply shows a static picture. Its normal eye mode includes blinking and movement, while its squinting mode adds another expression. The terminal-inspired mode displays a Claude Code-themed interface, and the canvas mode lets you draw on the display using your phone. These features demonstrate how a relatively small microcontroller can combine graphical output with a simple wireless user interface.
The drawing mode is especially interesting for anyone learning embedded graphics. Instead of changing the source code every time you want to display something different, you can use the browser interface to draw directly on the screen. You can also explore changes to the animation speed and background colors using the supplied controls. For a personal build, you might eventually modify the firmware to include additional expressions, a startup greeting, or a custom pixel-art mascot.
Is Clawd Mochi Really an AI Robot?
This is an important distinction for anyone interested in AI gadgets and DIY robotics. Clawd Mochi is best described as an AI-inspired electronic desktop companion, not a fully autonomous AI robot. Its original features include programmed animations, a terminal-themed display, and a browser-based drawing interface. The presence of an ESP32-C3 does not automatically mean the device runs a conversational AI model or independently reasons about user requests.
However, the project could provide a starting point for future experiments. With additional hardware or software, an advanced maker might explore external AI APIs, a separate computer running an AI assistant, or a local network connection to another system. Such additions would require their own implementation, configuration, and potentially additional costs. They should not be confused with the capabilities included in the original project.
That distinction makes Clawd Mochi a useful learning project: it introduces the physical interface and embedded networking concepts that can later become part of a larger connected-device experiment.
Troubleshooting Common ESP32-C3 Problems
If the display stays blank, begin by checking the power and wiring. Confirm that VCC is connected to 3.3 V, that ground is shared, and that the SPI, reset, chip-select, and data/command pins match the firmware. If the board does not appear in Arduino IDE, check the USB cable, serial-port selection, and board configuration. If the code compiles but fails during upload, try a lower upload speed or the appropriate boot procedure for your board.
If the device starts but the Wi-Fi network does not appear, confirm that the firmware uploaded successfully and that the ESP32-C3 is receiving stable power. If the browser page does not load, check that your phone is connected to the correct hotspot and that you entered http://192.168.4.1 correctly. A phone may automatically switch away from a Wi-Fi network without internet access, so you might need to remain connected manually. Checking the serial output can also help identify initialization or server errors.
For persistent problems, compare your firmware against the latest instructions in the GitHub repository. Troubleshooting is much easier when you change one thing at a time rather than replacing several components simultaneously.
Customization Ideas for Makers
Once the original build works, you can make it your own. The source code exposes parameters for adjusting eye size, spacing, and positioning, as well as animation timing. Changing a few values can give the companion a noticeably different appearance without requiring any hardware modifications. You could also redesign the 3D-printed enclosure, experiment with contrasting filament colors, or create a stand that matches your workspace.
If you enjoy Arduino and ESP32 development, consider adding new pixel expressions, a custom logo, or a simple clock screen. You could also use the project as a starting point for a separate desktop notification display, provided you implement the additional functionality yourself. These experiments help you understand how graphical interfaces, Wi-Fi communication, and embedded firmware fit together.
Start with small changes, keep a working copy of the original code, and test each modification before making the next one. That way, if an experiment breaks the display or web controller, you can return to a known working version.
Where to Find the Open-Source Files
The original project is available here:
Clawd Mochi — GitHub repository
The repository includes the Arduino firmware, hardware wiring information, build instructions, and links to the printable enclosure. Read the README before purchasing components, since it contains the specific hardware configuration used by the original build. You can also inspect the source code to understand how the screen, animations, and web controller work.
The project is identified as an independent fan creation inspired by the Clawd mascot associated with Claude Code. It is not an official Anthropic product or an endorsed commercial device. If you plan to distribute modified versions or sell assembled units, review the relevant licenses and trademark considerations first.
Conclusion
Clawd Mochi demonstrates how a small budget, an ESP32-C3, a color TFT display, and a 3D-printed enclosure can become a fun and interactive desktop companion. Its animated pixel eyes, browser-based controls, terminal-themed display, and drawing mode make it an appealing project for beginners and experienced makers alike. The estimated $6–$8 component cost is attractive, although your actual spending will depend on local prices, shipping, tools, and the materials you already own.
More importantly, the project offers a practical introduction to embedded programming, SPI displays, Wi-Fi access points, web interfaces, and 3D printing. You can build the original version first and then explore your own ideas as your skills improve.
Ready to build your own tiny desk companion? Visit the Clawd Mochi GitHub repository, check the parts list, and start experimenting.
Would you build one for your desk? Comment “MOCHI” and share this project with a friend who loves DIY electronics, ESP32 projects, and open-source robotics.
Frequently Asked Questions
1. Can I build Clawd Mochi for under $8?
The project’s published estimate is approximately $6–$8 for the listed components. Your final cost may vary depending on shipping, local availability, tools, and whether you already have a USB-C cable and 3D printer.
2. Does Clawd Mochi require an internet connection?
No. The original project creates its own Wi-Fi hotspot and serves a local web controller. You can connect directly from a phone or computer without an internet connection or dedicated mobile app.
3. Which microcontroller and display does it use?
The original build uses an ESP32-C3 Super Mini development board and a 1.54-inch ST7789 TFT display with a resolution of 240 × 240 pixels. Check the repository before purchasing components to ensure compatibility.
4. Do I need a 3D printer to build Clawd Mochi?
A 3D-printed case is part of the original design, but you do not necessarily need to own a printer. You can use a local 3D-printing service or explore a suitable alternative enclosure, provided it fits the display and electronics.
5. Is Clawd Mochi a fully functional AI assistant?
Not in its original form. It is an AI-inspired desktop companion with programmed animations and browser controls. Adding conversational AI or other intelligent features would require additional development and potentially extra hardware or software services.