Makeable is an AI hardware-building buddy that turns messy IoT prototyping into a fun, LEGO-like experience.
Building with ESP32s can feel scary when you are new: sensors, wires, pin diagrams, Arduino setup, firmware, flashing, terminal logs, and debugging all show up at once. Makeable turns that chaos into a friendly step-by-step build guide using your own parts photo.
Upload a photo. Say what you want to build. Let Makeable guide the rest. 🧩⚡
Makeable deliberately supports the ESP32 family only: ESP32, S2, S3, C3, and C6. Arduino Uno/Nano/Mega and other microcontroller families are not accepted as build targets.
Instead of making beginners jump between wiring diagrams, Arduino IDE, random tutorials, and serial monitors, Makeable keeps the whole hardware journey in one place.
It can:
- 📸 Look at your real parts photo
- 🧠 Identify only the components your project needs
- 🏷️ Label the useful parts directly on the image
- 🔌 Walk you through the wiring one move at a time
- 💻 Generate ESP32 firmware for your idea
- 🚀 Flash the code into the board without touching Arduino IDE
- 👀 Debug the real build using terminal logs and webcam evidence
- 📚 Keep the final project guide and test notes together
Tiny hardware mistakes can break the whole project.
Wrong pin? Nothing works.
Missing ground? Mystery bug.
Bad code upload? More confusion.
Serial log error? Time to panic-scroll forums.
Makeable is designed to feel like a calm friend beside you saying:
“No worries. Pick up this wire. Put it here. I’ll check the next part with you.”
That is the heart of Codex For Hardware.
Lay out your parts, upload one clear photo, then type or speak the thing you want to make.
In this demo, the user wants a motion-triggered light build.
Makeable reads the photo and focuses on the parts needed for the project. Extra parts are ignored so the screen does not become label soup.
The guide does not dump every wire on you at once. It highlights the current move, shows the exact parts on your own photo, and keeps the instruction simple.
Each step is built around the photo, the selected parts, and a clear action. It feels closer to LEGO instructions than a scary circuit diagram.
Connect the ESP32 by USB. Makeable infers the supported board target from the recognized hardware; ordinary users do not see compiler settings or source code.
The app generates firmware and loads it directly into the ESP32. No Arduino IDE adventure required.
After flashing, Makeable can check terminal logs and webcam footage to confirm the physical project is actually doing what it should.
When the build works, Makeable packages the project guide, parts, and test results into readable notes within the build session.
| Old Hardware Workflow 😵 | Makeable Workflow ✨ |
|---|---|
| Search for wiring diagrams | Upload your own parts photo |
| Guess which parts matter | AI marks only the needed parts |
| Read a giant pinout chart | Follow one small move at a time |
| Copy random Arduino code | Generate firmware for your exact idea |
| Manually compile and flash | Load code directly into the ESP32 |
| Debug alone with serial logs | AI checks logs + webcam evidence |
| Write docs after everything | Automatic in-session project notes |
Makeable uses the user’s real photo as the source of truth. The guide is not generic. It points to the actual objects on the table.
The guide shows one connection at a time so beginners can move slowly and confidently.
The app generates ESP32-ready firmware based on the project goal and detected components. The source stays inside the Makeable workflow.
The Render container owns Arduino CLI, the ESP32 core, and common libraries. The browser receives a compiled binary and flashes it with Web Serial, so the user installs no IDE, CLI, extension, or SDK.
The app can inspect serial logs and webcam evidence, then explain whether the physical build is behaving correctly.
The final project is packaged into a readable guide in the final stage.
- Frontend: HTML, CSS, JavaScript
- AI planning: OpenAI Responses API
- Voice input: Deepgram transcription through an authenticated server-side WebSocket proxy
- Accounts: Amazon Cognito PKCE sign-in + DynamoDB credit ledger
- Login branding: Cognito Managed Login, styled with Makeable assets in
infra/cognito-managed-login-branding.json - Firmware compile: pinned Arduino CLI + ESP32 core in an AWS ECS Docker container
- Board flashing: Web Serial + ESP flashing flow
- Debugging: Serial logs + webcam evidence
- Hosting: Netlify frontend + CloudFront + AWS ECS Fargate Express Mode API
npm run toolchain:install
node server.mjsThen open:
http://127.0.0.1:8787
Chrome or Edge is required for Web Serial board flashing. This local setup is only for Makeable developers; end users visit makeable.build and install nothing.
Create a .env file:
OPENAI_API_KEY=
OPENAI_MODEL=gpt-5.6-terra
OPENAI_REASONING_MODEL=gpt-5.6-terra
OPENAI_REASONING_EFFORT=xhigh
OPENAI_SERVICE_TIER=priority
DEEPGRAM_API_KEY=
GITHUB_TOKEN=
GITHUB_OWNER=
ARDUINO_CLI_PATH=.makeable/toolchain/bin/arduino-cli
PORT=8787npm run toolchain:install installs the pinned CLI and ESP32 core into the ignored .makeable/toolchain development directory. Production gets the same toolchain from Dockerfile.
- Power the board by USB first.
- Always connect ground before trusting signal wires.
- Double-check the board pin labels before flashing.
- Disconnect power before changing messy wiring.
- If something gets hot, stop immediately.
Hardware should feel fun, not frightening. ⚡
Makeable is not just a code generator.
It is a hardware companion that watches the whole loop:
parts photo → AI guide → wiring steps → firmware → flashing → real-world check → build notes
The dream is simple:
Anyone should be able to build useful electronics without feeling lost in the wires.
Makeable
Tagline: Codex For Hardware
Small tool. Big hardware confidence. ⚡