Prototyping interactions in hardware without writing code

01Sketching an interaction still meant writing code

Designers sketch constantly: on paper, in design tooling, code. Whatever is needed to get an idea out in front of someone. Bill Buxton’s “Sketching User Experiences” argues that sketching, fast, rough, and disposable, is central to how designers explore ideas, not just how they document finished ones. Source Bill Buxton’s “Sketching User Experiences” argues that sketching, fast, rough, and disposable, is central to how designers explore ideas, not just how they document finished ones. Source Back in 2010/2011, prototyping in hardware was not that easy. Building a working prototype with sensors and actuators meant learning electronics and programming.

Designers could sketch an idea for a physical interaction, but they couldn’t easily, or quickly, sketch directly in hardware. Tom Igoe and Dan O’Sullivan’s “Physical Computing: Sensing and Controlling the Physical World with Computers” was the standard reference for exactly that gap at the time, teaching designers electronics and programming from first principles. Igoe went on to co-found Arduino itself. Source Tom Igoe and Dan O’Sullivan’s “Physical Computing: Sensing and Controlling the Physical World with Computers” was the standard reference for exactly that gap at the time, teaching designers electronics and programming from first principles. Igoe went on to co-found Arduino itself. Source Atreyu was a five-month research project at TU Delft built to close that gap.

02A grid of modules that remembers relationships

Atreyu The project is named after Atreyu, the young hero of Michael Ende’s “The NeverEnding Story,” sent on a long, exploratory journey to save the world. Source The project is named after Atreyu, the young hero of Michael Ende’s “The NeverEnding Story,” sent on a long, exploratory journey to save the world. Source is a modular grid of input and output components that designers connect by hand. White IO modules represent individual inputs (a button, a sensor) or outputs (a light, a motor).

A black wire temporarily bridges two modules to establish a relationship between them; once the wire is removed, a red master module remembers that relationship and keeps it running on its own. Black modules in the grid are passive, carrying only signal and power between active ones. Up to 30 modules could be connected at once, letting designers build up complex interactive structures without ever opening a code editor.

03Five iterations, from rough prototype to toolkit

The concept started as a storyboard, working out how a designer would move through connecting modules and seeing a relationship take hold.

From there, Atreyu went through five iterations, each one shifting further from a proof of concept toward something a designer could pick up and use.

The second iteration proved the rough principle could work at all: a single input successfully triggering a single output. The third pushed the underlying architecture further, getting separate microcontrollers to cross-communicate data with each other rather than each acting alone, the piece that let the system scale past a handful of connected parts.

04Each module got its own physical identity

The fourth iteration is where modules first reliably remembered a relationship after the connecting wire was removed. The fifth and final iteration shifted focus away from new technical capability entirely, toward miniaturization and refinement, getting the toolkit small and solid enough to use reliably.

Custom PCBs made each module self-contained: an Arduino Nano, a set of connectors, and a custom IO shield to attach whichever input or output component that module represented. Because every module carried its own board, any module could be attached anywhere in the network, not wired into a fixed position.

The PCBs alone weren’t a toolkit yet. They still needed an embodiment robust enough to survive being picked up, plugged in, and rearranged by someone who wasn’t the person who built it.

The final iteration gave each PCB a 3D-printed housing, turning a bare circuit board into something self-contained enough to hand to someone else. Every module also carried its own graphic design: buttons, knobs, sensors, and logic modules each got a distinct visual language, so a designer could tell at a glance what a module did without reading documentation.

05Testing Atreyu with designers to sketch interactions in hardware

Atreyu was demonstrated at TU Delft’s final exhibition, where visitors who’d never seen the toolkit before could walk up and build their own interactive structures on the spot.

The system held up under unsupervised use: robust enough to be used, reused, and rearranged into new structures without anything breaking. Designers could sketch an idea in hardware and see it working in the time it would have taken to describe the idea to an engineer or learn programming themselves.

06Sketching in hardware, without touching code, worked

As a research project, Atreyu was never meant to become a product. It was an exploration to prove that sketching a physical, interactive behavior belongs in the design process, on equal footing with sketching on paper or in code. Designers who’d never touched an Arduino could now build working structures on the spot, then reused and rearranged those same modules into something new, without writing a single line of code. A well-known HCI study found that designers who created multiple rough prototypes in parallel, rather than refining a single one serially, produced measurably better results and explored a wider range of ideas. Atreyu’s own exhibition showed a version of the same pattern: designers who could sketch several structures quickly came back with more interesting ones. Source A well-known HCI study found that designers who created multiple rough prototypes in parallel, rather than refining a single one serially, produced measurably better results and explored a wider range of ideas. Atreyu’s own exhibition showed a version of the same pattern: designers who could sketch several structures quickly came back with more interesting ones. Source

Atreyu had some real limits, though. The form factor stayed large, the connectors were more fiddly than they should have been, and the logic between modules stayed simple: no conditionals, no layered behavior. Those are the boundaries a next iteration would need to push past.

Part of the achievement was technical too. Building hardware and software that let modules talk to each other, remember relationships, and stay simple enough to hand to someone else was a real engineering challenge in its own right, not just a means to an end. It was also a real test of how far a simple, self-contained module could be stretched before the approach broke down. But the bigger point Atreyu made was about timing: sketching earlier in the process, in hardware itself rather than after an idea was already fixed, led to earlier ideation and better ideas.