ReWeird

Evidence-first debugging and Git for hardware. ReWeird photographs your circuit, tells you where to probe, finds the fault, and commits every working state so you can get back to it.

Comment

Inspiration

Every one of us has been the hardware person at a hackathon. You spend the whole weekend wiring and debugging, and at the end your GitHub has like three commits, so it looks like you barely did anything even though you built the thing the whole project runs on. And when something breaks at 3am, there's no git log for your breadboard and no way to get back to the version that worked. AI chatbots don't help much either since they can't see your circuit, so they just guess.

So we built ReWeird: version control for hardware, and a debugger that actually measures your circuit before telling you what's wrong.

What it does

ReWeird is basically Git and a debugger for your breadboard. It runs one full loop:

Understand → Map → Measure → Analyze → Diagnose → Test → Verify → Remember

Understand. You connect your project's GitHub repo and place your circuit in front of the camera. ReWeird takes the photo itself, reads your Arduino, ESP32, or MicroPython code (without ever running it), and uses Gemini Vision to figure out what parts are on the board. If the code says one thing and the photo says another, it shows you the conflict instead of picking one. Nothing gets trusted until you confirm it. Every time you push to your repo, it re-reads the code.

Map. Your project turns into an interactive circuit map. Click any connection and you see the component, the pin, where it's supposed to go, which probe is on it, and live readings if we have them.

Measure. ReWeird tells you exactly where to clip ground and six probes, like "connect P3 to the HC-SR04 ECHO line." Our ESP32-S3 probe board reads them live and shows the numbers on two little OLED screens right on the board.

Diagnose. Raw signals get turned into actual evidence: voltages, pulse widths, frequency, jitter, dropouts, whether the power rail is stable. Obvious problems get caught by plain engineering rules first. Only after that does our AI (PROBE) come in to rank what might be wrong, and every guess it makes has to point at real evidence. If the AI gives back something weird or unsure, ReWeird ignores it and sticks with the rule-based answer. AI never gets shown as a measurement.

Test and Verify. Instead of just saying "probably a loose wire," ReWeird walks you through a test to prove it, like wiggling a wire while it watches the signal. After you fix it, it measures again and compares before and after. It only calls it fixed when the numbers actually say so.

Remember. You can save a healthy reading as "Known Good," and every project gets a Device Passport, kind of like a service record with its baselines, history, and every verified repair.

Physical Git

This is the part that came straight from that hackathon frustration. Every Physical Commit saves a snapshot of your hardware: the camera photo, the circuit map, the latest probe readings, and the Known Good baseline. They're numbered HW-001, HW-002, and so on, so your hardware finally has a history.

You can diff any two commits and see what changed in the wiring, the parts, and the signals. When something breaks, Restore gives you a checklist to get back to a working commit, and Verify takes fresh measurements to check if you actually got there. Now the hardware person has a commit log too.

ReWeird also makes JSON, Markdown, and printable reports, can commit those reports to your repo if you approve it, and has a computer diagnostics mode for when the problem is actually on the PC side.

If you don't have hardware, you can still try it at /try. Break a simulated circuit (or let it pick a mystery fault), probe around, try a fix, and hit Verify until it says NOT WEIRD ANYMORE.

How we built it

Probe board: An ESP32-S3 with six input-only probes, voltage dividers for 5V signals, and two SSD1306 OLEDs on separate I2C buses. The trigger and echo lines use the S3's hardware capture, so it catches a 10 µs pulse with 12.5 ns timing instead of missing it.

Test circuit: A separate ESP32 running an HC-SR04 ultrasonic sensor, a servo that moves based on distance, and a ZMPT voltage sensor. This is the thing we break on purpose.

Camera: An Android phone streaming over Wi-Fi. ReWeird grabs one frame when you make a commit and then disconnects.

Firmware: PlatformIO, sending one validated JSON packet per second over USB. The screens run on their own core so they can never slow down the measurements.

Backend: Go and Fiber with SQLite. It handles the telemetry (real or simulated), signal analysis, the rules engine, test planner, Verify, Device Passport, and Physical Git.

AI: A Python and FastAPI service for PROBE, using Gemini with a strict check that every answer is tied to real evidence. There's also an offline mode so it still works without an API key. Gemini Vision handles the photos.

Frontend: Next.js and TypeScript, with Google sign-in, the circuit map, live diagnostics, physical history, and reports.

GitHub: A read-only GitHub App that pulls firmware and re-analyzes it on every push.

Hosting: Web on Vercel, API on Railway, and Docker Compose for running it all locally.

Challenges we ran into

Keeping the AI honest. The hardest design problem wasn't the AI, it was making sure the AI couldn't pretend to be data. We had to keep measurements, rule results, baselines, and AI guesses separate everywhere, from the database all the way to the UI.

Fake data sneaking in as real. Since we built a simulator, we had to make sure simulated readings could never get saved as a real baseline. Telemetry that doesn't match the confirmed project just gets rejected.

Voltage stuff. ESP32 pins can't handle more than 3.3V, so every probe is input only. We also found out that dividing a 3.3V trigger signal drops it too low for the S3 to read as HIGH, so we only divide signals that are actually above 3.3V.

The screens. Our first plan ran both OLEDs through an I2C multiplexer, and it died on us. We ended up giving each screen its own I2C bus.

Pulses that were too fast. Regular interrupts kept missing the 10 µs trigger pulse, so we switched to the S3's hardware capture.

Accomplishments that we're proud of

  • The whole loop works, from a camera photo and a GitHub repo to a verified fix.
  • Physical Git. Hardware finally gets commits, diffs, and a way back to the last working version.
  • A real probe board reading live signals off a real circuit.
  • An AI that's upfront about what it knows versus what it's guessing.
  • A demo judges can run with zero hardware.

What we learned

Most debugging doesn't need an LLM. It needs good measurements and some simple rules. AI is way more useful once the evidence is already clean, and a fix doesn't count until you measure it again.

We also learned that hardware progress is really easy to lose track of. Half our debugging time went into remembering what the circuit looked like when it last worked, which is exactly the problem Physical Git fixes.

What's next for ReWeird

  • Calibrate the probe board and run more real faults through the full loop
  • Link each Physical Commit to the exact firmware commit on GitHub, so code and hardware history live together
  • Wireless probes over Wi-Fi
  • Support for more components and bigger projects
  • Unlock PATCH, which lets ReWeird apply small, safe electrical fixes itself, once we have hardware rated for it

Built With

Share this project:

Updates

Submission history