Panic.Design

15 mins until your pitch. Total panic. Panic.Design is a zero-dependency, single-file AI slide generator. Bring your own key, instantly generate beautiful slides, and export natively to .pptx.

Comment

Inspiration

It is 8:45 AM. Your high-stakes investor pitch or project demo is at 9:00 AM. You have exactly 15 minutes, a blank screen, and a creeping sense of pure, unadulterated panic. You do not have time to fight with font pairings, micro-manage bounding boxes, or sign up for a new $10/month SaaS subscription that holds your data hostage. Panic.Design turns last-minute chaos into presentation-ready slides.

When reviewing the available options for the name.com Domain Roulette track, panic.design immediately resonated with this exact scenario. We specifically chose this domain because we saw an opportunity to build a tool where the concept of "panic" isn't just a quirky name, it dictates the entire product architecture. Panic.Design is built to bypass the endless time-sink of layout micro-editing by delivering beautifully finalized, presentation-ready slides instantly when the deadline clock is ticking down.

What it does

Panic.Design is an ultra-fast, local-first, Bring-Your-Own-Key (BYOK) AI presentation generator.

Unlike SaaS presentation tools, Panic.Design does not require an account, backend, subscription, or cloud storage. It is a single local file that users can keep forever, open instantly, and run with their own API key.

You simply input your raw, frantic text prompts, optionally select an emergency design aesthetic (such as "Save-My-Job Corporate"), and hit generate. To maintain visual cohesion across the entire deck, the application intelligently references your previously generated slides to match layout density, palette choices, and aesthetic weight. Users can even attach real-time reference photos or screenshots to ground the AI generation in precise visual context.

Once your slides are ready, a single click exports the entire deck into a native, standalone .pptx file. No logins. No trackers. No corporate databases. Just pure speed.

How we built it

In a landscape filled with heavy server infrastructures and massive node_modules folders, Panic.Design takes a radically minimalist approach. The entire application exists inside a single, standalone panic_design.html file. It requires no build steps, no installation, and runs natively right from a desktop double-click.

The Self-Contained Client Architecture

    ┌──────────────────────────────────────────────────────────┐
    │                   PANIC.DESIGN CLIENT                    │
    │  (Single index.html • Zero Dependencies • Local-First)   │
    └──────┬──────────────────────┬──────────────────────┬─────┘
           │                      │                      │
           ▼                      ▼                      ▼
   ┌───────────────┐      ┌───────────────┐      ┌───────────────┐
   │  IndexedDB    │      │ Web Crypto API│      │ Pure JS ZIP & │
   │ State Storage │      │   (AES-GCM)   │      │ XML Compiler  │
   └───────┬───────┘      └───────┬───────┘      └───────┬───────┘
           │                      │                      │
           ▼                      ▼                      ▼
  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
  │Persisted Drafts │    │ Encrypted Local │    │ Direct Native   │
  │& Slide History  │    │ OpenRouter Key  │    │ .PPTX Download  │
  └─────────────────┘    └────────┬────────┘    └─────────────────┘
                                  │
                                  ▼ (HTTPS)
                         ┌─────────────────┐
                         │ OpenRouter API  │
                         │  (BYOK Model)   │
                         └─────────────────┘
  • Zero-Dependency .PPTX Compilation Engine: Rather than relying on heavy external libraries like JSZip or PptxGenJS, we engineered a custom ZIP packager from scratch. We utilized raw crc32 hashing and Uint8Array byte manipulation to dynamically construct and stream valid Microsoft PowerPoint XML files directly in the browser.
  • Local Key Encryption: Because we operate with zero backend servers, we protect user privacy by encrypting your OpenRouter API keys locally in the browser using the native Web Crypto API via AES-GCM encryption.
  • Local-First State: All presentation drafts, slide arrangements, and custom styling presets are persisted entirely on the client side using IndexedDB.
  • Smart Token Optimization: Reference photos are processed client-side, drawn to an internal HTML5 <canvas>, and automatically compressed and downscaled to a maximum of 512px before making network requests to prevent massive images from draining the user's API token balances.

Challenges we ran into

Compressing an advanced data infrastructure into a single document presented massive constraints. Implementing seamless drag-and-drop slide reordering alongside reliable file stream handling using purely vanilla JavaScript meant managing intricate DOM reflow lifecycles entirely by hand.

Additionally, ensuring that raw base64 binary image bytearrays mapped perfectly to modern OpenXML presentation and slide relationships (.rels) required navigating strict PowerPoint schema structures byte-by-byte. If a single byte or XML namespace tag was malformed, PowerPoint would reject the entire file as corrupted.

Accomplishments that we're proud of

We are incredibly proud to have engineered a fully functional, polished, privacy-conscious local-first application with absolutely zero external dependencies. Building our own file packager and encryption pipeline allowed us to work directly with native browser APIs, stripping away the heavy abstractions that modern frameworks usually impose.

Furthermore, we proved that it is possible to build a high-end, responsive, and gorgeous user experience using only native CSS variables and a clean vanilla architecture.

What we learned

We learned that constraints breed the ultimate form of creativity. Restricting the application to a single file forced us to re-evaluate what is actually necessary to ship production software. Building our own ZIP packager and encryption pipeline from scratch was a rigorous crash course in byte manipulation and local-first security, proving that stepping outside the comfort zone of modern frameworks can lead to highly efficient software.

What's next for Panic.Design

Panic.Design is our contribution to a more open, lightweight, and user-friendly future for AI tools. Instead of asking users to create another account, pay another monthly subscription, or send their work through another backend, we wanted to build something simple: a tool that runs locally, respects the user’s privacy, and gets out of the way when time matters most.

Because Panic.Design runs entirely client-side, it has no traditional server infrastructure to maintain. That makes it easy to keep the project open-source, free to use, and accessible to anyone with a browser and their own AI API key.

Moving forward, our vision is to keep expanding Panic.Design while staying true to the spirit of the name.com Domain Roulette challenge. We took panic.design not just as a domain name, but as a product brief: build something immediate, practical, and helpful for moments when people need great design fast. Panic.Design shows that powerful software does not always need to be heavy, expensive, or complicated. Sometimes, the best tool is the one that opens instantly and helps you finish the job.

Built With

Share this project:

Updates