Paper to Prototype

Turn research papers into interactive learning labs. Don’t just read the method—run it.

Comment

Inspiration

Research papers are great at introducing powerful algorithms and absolutely merciless about explaining them. The good ideas are in there somewhere, buried under dense notation, tightly packed prose, and a static diagram that assumes you already understand the thing it’s diagramming. You can read a paper cover to cover, nod at all the right places, and still have no real feel for how the algorithm behaves the moment you change an input.

Paper-to-Prototype exists to fix that. Instead of handing you yet another summary of the paper you already didn’t fully absorb, it turns supported methods into interactive labs—places where you can grab the algorithm by the shoulders, shake it a little, and watch what happens.

What it does

Paper-to-Prototype is built around one simple shift: stop reading the method, start running it.

Enter a supported arXiv paper ID, and the system surfaces the paper’s core method, learning goal, step-by-step procedure, and supporting evidence before checking whether it matches one of the platform’s trusted labs.

Right now there are three:

  • Scaled Dot-Product Attention — Watch attention spread across tokens, isolate individual relationships, nudge the temperature, compare scaled versus unscaled scores, and follow the math from raw vectors all the way to weighted output.
  • k-Means Clustering — Watch points get claimed by clusters and centroids shuffle around trying to find a stable home.
  • A* Search — Draw your own obstacles on a grid and watch the frontier creep outward as the algorithm hunts for a path.

The Attention walkthrough is explicitly marked as hand-reviewed and verified, so nobody has to take its word for it. If a paper doesn’t fit any of the labs, the system just says so—it fails safely instead of trying to improvise executable code on the fly, which felt like a genuinely bad idea to build a hackathon project around.

How we built it

Next.js, React, TypeScript, and Tailwind CSS—the reliable, slightly boring backbone that let us focus our energy on the actually hard parts.

Each lab runs on its own deterministic algorithm engine that doesn’t care whether React is even in the room. Seeded inputs mean the same experiment gives you the same result every time, and the visualizations are all SVG, so the “state” you’re watching is really the algorithm’s state, not a vibe. A closed registry makes sure a supported method only ever connects to a trusted, repository-owned implementation—no wildcards allowed.

The experimental analysis side uses GPT-5.6, but on a short leash: its job is to turn paper content into validated structured data—central method, learning objective, steps, evidence, limitations, and lab compatibility—never into interface code. It gets to describe the paper. It does not get to build anything.

OpenAI Codex worked alongside me throughout development—helping with architecture decisions, implementation, testing, debugging, accessibility, and security review. Basically, the teammate who never sleeps and has strong opinions about edge cases.

Challenges we faced

The big one: how do you turn an arbitrary research method into something interactive without just letting AI-generated code run wild in the browser? Our answer was to split the problem in two—let AI handle understanding the paper, and keep execution locked to labs that already exist in the trusted registry. AI gets to explain; it doesn’t get to compile.

The second challenge was explaining genuinely complex algorithms without dumbing them down into uselessness. The Attention lab in particular had to hold plain-English explanations and the real math—query-key comparisons, scaling, softmax, row totals, and weighted output—side by side without either one drowning out the other.

Then there was the deeply unglamorous challenge of making a heatmap and an editable grid behave themselves on a phone screen. Nobody puts that in the pitch deck, but it ate real hours.

Accomplishments that we're proud of

  • Three complete interactive labs spanning machine learning, search and planning, and modern generative AI—not bad for the time we had.
  • A verified walkthrough of Attention Is All You Need, wired directly to its matching lab.
  • Complex algorithm states made inspectable in two ways at once: visually and in plain English.
  • Reproducible experiments with zero arbitrary code execution at runtime.
  • Honest provenance—evidence records, validation states, and a graceful “nope, unsupported” path instead of a fake, confident answer.
  • A public prototype that works with no login and no setup, because friction kills curiosity.

What we learned

Explaining an algorithm and letting someone actually manipulate it turned out to be two very different experiences, even when the underlying content was identical. Nudge the attention temperature, drag an obstacle, or step a clustering iteration forward—thirty seconds of that teaches you something that three paragraphs of prose quietly fail to.

We also learned where AI is genuinely useful here, and it’s not “generate the whole app.” It’s the bridge between dense research language and a controlled, trustworthy environment—structured extraction paired with visualization engines we already trust, rather than handing the model the keys and hoping for the best.

What's next for Paper-to-Prototype

More labs. That’s the honest, unglamorous answer—expanding the trusted registry to cover more methods, plus an educator workflow for building guided experiments and classroom activities.

Down the line: more verified papers, learner checkpoints, a comparison mode, better accessibility, and shareable experiment states. The long game is making research methods explorable without cutting corners on accuracy, transparency, or safety.

Don’t just read the method. Run it.

Built With

Share this project:

Updates