Holotrace

We are a convenient application for students and hobbyist to assist, create, and simulate electrical circuit diagrams.

Comment

Holotrace

Inspiration

Circuit design still starts the same way it did decades ago: pencil, paper, and a scrawled schematic on the back of a notebook. That sketch is fast and expressive, but it's a dead end: to actually build, simulate, or share the circuit, someone has to redraw it from scratch in a separate tool. We wanted to close that gap. Holotrace started from a simple question: what if the sketch itself could become the working circuit, with nothing lost in translation between paper and screen?

What it does

Holotrace turns a hand-drawn circuit into an interactive, editable model:

  • A user photographs or uploads a sketch.
  • A local, on-device vision pass proposes regions that look like circuit symbols.
  • Those regions are surfaced for a quick human check before anything goes further, so the user always sees what the app found before committing to deeper recognition.
  • Confirmed regions are classified into one of 44 hand-drawn symbol types, stitched together with the wire geometry on the page, and normalized into an editable Circuit IR.
  • The circuit then lives in a full workspace: pan, zoom, select, place, and wire components, and switch between canvas, schematic, and parts views.

The same circuit stays usable whether it was captured on a phone at the workbench or refined later on a desktop.

How we built it

The core of Holotrace is a classifier we call ResNet Tiny, written from scratch and trained on cropped circuit symbols:

  • Takes a 64×64 grayscale "ink crop" as input.
  • Runs it through a stem (3×3 conv, stride 2, BatchNorm, ReLU).
  • Passes it through four stages of residual blocks, each stage halving spatial resolution while doubling channels: 32×32×32 → 16×16×64 → 8×8×128 → 4×4×256.
  • Each residual block is two 3×3 convolutions with BatchNorm and ReLU, plus a shortcut that's either an identity or a 1×1 conv-and-BN projection whenever stride or channel count changes between blocks.
  • Ends with a head of global average pooling, dropout at 0.2, and a linear 256→44 layer producing the final class logits.
  • At width 32, the whole network is about 2.8M parameters and exports to roughly 11 MB of weights, small enough to ship inside the app and run on-device.

ResNet Tiny handles the fast path: labeling each region the on-device pass proposed, and rejecting false proposals through a dedicated background class. For symbols the local pass misses, a recovery path kicks in: a Faster R-CNN detector with a MobileNetV3 FPN backbone (about 19.2M parameters, ~77 MB) searches the full page rather than just the proposed crops. A normalizer then combines both models' boxes, confidences, and model versions with the page's wire geometry to build the editable Circuit IR that the workspace actually renders. Every prediction keeps its source location, confidence score, alternative labels, and the model version that produced it, so a shaky read can be explained and corrected before it ever reaches simulation.

The app itself is built with Tauri, giving us one codebase that ships as:

  • A Windows installer
  • A universal macOS DMG (Apple Silicon and Intel)
  • A portable Linux AppImage
  • An Android APK with direct camera capture

All four share the same circuit workspace and Circuit IR underneath.

Challenges we ran into

  • Getting the classifier from "works on common parts" to "trustworthy across the board" was the hardest part of the project. ResNet Tiny reaches 97.6% overall accuracy on our validation split, but that number is carried almost entirely by common classes, resistors, LEDs, sources, while rarer symbols have far fewer training examples than they need, which drags the macro F1 down to 0.823.
  • Deciding how much to trust a single fast on-device pass versus when to fall back to the heavier, full-page Faster R-CNN recovery model was its own balancing act between speed and completeness.
  • Building one circuit workspace that feels natural on both a mouse-and-keyboard desktop and a touch-first phone, and shipping it consistently across Windows, macOS, Linux, and Android from a single Tauri codebase, surfaced a steady stream of platform-specific quirks.

Accomplishments that we're proud of

  • ResNet Tiny is genuinely built from scratch, no pretrained backbone, and still lands at 97.6% accuracy across 44 hand-drawn symbol classes.
  • The exported model stays under 11 MB, small enough to run locally rather than round-tripping every crop to a server.
  • We built a review-first pipeline: showing users exactly what the model found, with confidence and alternatives, before it continues to deeper recognition, rather than silently trusting the network.
  • We shipped a real, working cross-platform app, with camera capture on Android and a full editable workspace on desktop, not just a model in a notebook.

What we learned

The biggest lesson was that raw accuracy hides a lot. A 97.6% headline number meant little once we looked at macro F1 and saw how thin the coverage was on rare symbols; it reshaped how we think about the dataset and where we need more examples, not just more training. We also learned a lot about designing a two-tier recognition system: keeping a fast, cheap, on-device model for the common case and reserving a heavier, more thorough model for recovery, rather than forcing one network to do both jobs well. Finally, carrying provenance, source location, confidence, alternatives, and model version, through every prediction turned out to be essential for building a UI people can actually trust and correct, not an afterthought bolted on at the end.

What's next for Holotrace

  • Grow the dataset for underrepresented symbol classes to close the macro F1 gap.
  • Expand past 44 classes as coverage improves.
  • Push circuit behavior further, beyond inspecting connections toward real simulation.
  • Tighten the loop between the fast and recovery paths so the on-device pass leans on the heavier model less often over time.

Built With

Share this project:

Updates

Submission history