Why We're Building Rosette

On creating the missing layer in chip design tooling

Here's the thing about chip layout tools: there's a disconnect between their incredible power and their user experience.

The commercial options are marvels—powerful, proven, feature-rich. The open-source alternatives are equally impressive. Both represent decades of sophisticated development. But their interfaces haven't kept pace with how we've learned to interact with software.

Why does this matter? Because tools shape thinking.

When your terminal tools feel modern (Ghostty, Warp, Claude Code), you think differently about command-line work. When your IDE is responsive and delightful (Cursor, Zed), coding becomes more fluid. Modern tools excel with instant command palettes, natural keyboard shortcuts, snappy interactions, and thoughtful design elements—like Linear for project management or Notion for documentation. Chip designers deserve the same thoughtful user experience.

The next generation of engineers doesn't accept this trade-off. They've grown up with tools that are both powerful and elegant. They expect their work environment to be as sophisticated as their ideas.

The Web Revelation

We made Rosette web-based for three reasons that seemed obvious once we saw them clearly:

First: the friction problem. How much time do teams waste on "can you install the tool?" conversations? Downloads, dependencies, platform compatibility—it's all overhead. With Rosette, you type a URL and you're designing. The barrier between "I want to try this" and "I'm using this" disappears.

Second: the development velocity problem. Here's what we know: LLM coding tools and AI agents are really good at web technologies (React, Next.js, etc.). Scary good. This means we can build features faster than if we were working in traditional desktop environments (C, Rust, etc.). While traditional desktop approaches require more platform-specific considerations, we can focus on rapid feature development. We believe this faster development velocity can ultimately lead to better performing software than the theoretically higher performance bar of other languages—through more iteration cycles, better optimization, and faster responses to user needs.

Third: the platform versatility problem. Web-based means true platform independence—Windows, Mac, Linux, tablets, even phones. Your design environment isn't tied to a specific operating system or device. Need to review a layout during a meeting on your tablet or projector? Make a quick adjustment while traveling on your laptop? Check a design update on your phone? The platform adapts to your workflow, not the other way around.

Figma for Hardware

The most exciting part isn't the technology—it's the collaboration layer.

Watch a design team using Figma: they share links, leave comments, work on the same file simultaneously. It's seamless. Now watch a chip design team: they're often working with more traditional file-sharing workflows—emailing GDS files, managing versions manually, working in isolation until integration time.

This is solvable.

Rosette is building toward the Figma model for hardware: cloud-native sharing, real-time collaboration, component libraries that propagate across teams. No more "which version are you looking at?" conversations.

But here's where it gets interesting: unlike purely digital design, chip layouts eventually become physical. The collaboration needs to extend beyond the design phase into fabrication, testing, and iteration cycles. We're definitely not there yet—not even close. But we're actively developing this collaborative foundation.

The Code-Visual Bridge

Many layout tools force you to choose: visual or programmatic. Click-and-drag or code.

This is a false dichotomy.

We believe the best developers, designers, and engineers often think visually but implement programmatically, or prototype in code but refine visually. We're building Rosette to support both approaches simultaneously—where your existing Python layout code renders in real-time alongside point-and-click layouts.

This means you can leverage the design frameworks and libraries you've already invested in, while gaining the benefits of modern visual tooling. No need to abandon your existing codebase or rewrite everything from scratch.

Think of it like a web designer working with modern development tools: write code and see the visual changes instantly, or adjust elements visually and watch the code update in real-time. The boundary between code and visualization dissolves. This integrated workflow is one of our core development priorities.

Virtual Nanofabrication

Here's where bringing PreFab from the same team becomes powerful: we can predict fabrication outcomes directly in the design environment.

Instead of designing → sending to fab → discovering problems → redesigning, you get design → predict → correct → verify. The feedback loop collapses to minutes.

This isn't just about catching errors earlier (though that's valuable). It's about designing with fabrication awareness as a first-class citizen, not an afterthought.

AI That Understands Design

Here's where we look to the future.

We're not just using our own AI models (for virtual fabrication)—we're integrating large language models that can actually understand layouts and generate new ones. The same way Cursor understands your codebase and helps you write better code, we're building an AI that understands your chip layout and helps you design better circuits.

What does this look like in practice?

For experienced designers, imagine having an intelligent partner that can spot optimization opportunities you might miss, automate the tedious routing work, and suggest alternative approaches when you're stuck. It's not replacing your expertise—it's amplifying it.

For newcomers, it's even more transformative. Like how V0 or Bolt let you describe an app interface and get working code, you could describe a photonic circuit and get intelligent guidance on how to implement it. "I need an MMI with 50:50 splitting" becomes the new starting point over File > New Layout.

The Meta Point

Tools don't just enable work—they define what kind of work feels possible.

When spreadsheets became visual, more people could think with data. When version control became distributed, software development became more collaborative. When design tools moved to the browser, entire new forms of creative collaboration emerged.

We're betting that the future belongs to tools that make the hard parts easier and the collaborative parts delightful.

The chips powering tomorrow's breakthroughs deserve tools built for tomorrow's workflows (or at least today's).

Want to be part of this future? We're actively building Rosette and would love your feedback. Try Rosette or reach out to share your thoughts on what the future of chip design tooling should look like.