What's new in Krit.

• Recovers itself: a tab running a retired build reloads into the current one rather than failing silently.
• No 404 storms: it stops requesting chunks that no longer exist.
• Scroll restored: document scrolling works again on the pages that had lost it.

This was the worst thing about the canvas: you moved something, and a moment later it went back. It had two separate causes, which is why fixing one of them never fully solved it.

• Stale broadcasts: a sync message written before your change could arrive after it. Updates are now sequence-gated, so an older one is discarded instead of applied.
• The REST reply: a save could return a snapshot from before your next move and quietly overwrite it. That window is closed too.

• Sections, not one dump: the server splits a long screen into chunks and streams them in order.
• A readable pace: pacing is tuned to be watched rather than to finish a millisecond sooner.
• You can see the work: a soft halo marks the frame currently being generated.
• Reload safe: structure is committed as it streams, so a refresh mid-generation does not leave a half-built screen.

The canvas captured the pointer to make dragging smooth, which had the side effect of swallowing the second click entirely. Dragging is unchanged; the double-click gets through now.

Not every mark on a board deserves a prompt. Some of it is a note to yourself, an arrow, a box around the thing you are worried about. Those are native layers now, with their own tools.

The tools

• Text (T): click and type. Editing happens in place, not in a side panel.
• Shapes (R, O, L): drag out rectangles, ellipses, and lines, each with its own style inspector.
• Sticky notes (N): a colored card for the thinking that is not part of the design.
• A toolbar: Select, Text, Shapes, and Section now live in one floating bar instead of scattered shortcuts.

Double-click any text or note to edit it, use your native right-click menu inside it, and undo the whole editing session as one step rather than character by character.

• One picker, four surfaces: replacing media works the same way everywhere it is offered.
• Reuse what is there: the project keeps an index of its assets, so you pick from what you already have instead of uploading it twice.
• Clear failures: a picker that cannot load says so rather than sitting empty.

• Every run surfaces: no more walks that finish somewhere you cannot see.
• Faithful replay: the walk replays from what was captured, so what you watch is what the persona did.
• Honest failures: a run that could not complete says so. A usability report you cannot trust is worse than none.

Copying raw code into a chat loses everything around it. Copy prompt wraps the frame in the instructions an agent actually needs, and it sits wherever you happen to be.

• Four places: the Code header, the frame context menu, the Export section, and as an MCP tool your agent can call itself.
• Any target: the prompt wraps whichever format you pick, defaulting to React.
• Honest dependencies: React and React DOM are treated as already present rather than told to install.

• Your call: visitor copy is a toggle in the share dialog, off unless you turn it on, and flipping it does not rotate your link.
• No account needed: a visitor copies code straight from the shared view.
• Attribution: shared views carry a Made in Krit chip, and copied code carries a one-line credit comment.
• Protected: copy requests are rate limited per link and per visitor.

A design that only works at one width, in one theme, and does nothing when you click it is a picture. This release makes the floor higher: every generated frame has to clear it before it reaches you.

The three floors

• Interaction: buttons, inputs, and menus respond in the frame itself. There is no prototype layer to wire up.
• Responsive: viewport handling and media guards go in automatically, and the result is verified at two widths.
• Dual theme: light and dark are snapped from one set of tokens and verified together, so neither one is an afterthought.

How it is checked

Frames render in multiple passes and are verified across both themes and both widths before they settle. Contrast on light boards is guarded specifically, since that is where washed-out text used to slip through. You can also flip the whole board's theme and watch every artboard follow.

You no longer have to export a file to find out what a frame is made of. Code is a third segment on the frame pill, next to design and preview.

• A real editor: the Code view was rebuilt as a plain, quiet IDE rather than a wall of preformatted text.
• Loaded on demand: the panel only mounts when you open it, so frames stay light.
• Zoom still works: pinch and scroll pass through the panel instead of fighting it.
• Straight to Export: right-click a frame and Export reveals the panel already open on that frame.

Export used to be one format at a time. Now every frame has an Export section in the right panel with Figma-style preset rows: add the outputs you want, set them once, and run them all together.

What you can get out

• Images: PNG and JPG at any scale, with a megapixel ceiling so a huge board cannot blow up the job.
• PDF: real vector text, not a screenshot. Select many frames and they merge into one document.
• SVG: true vector paths, so an export lands in Figma as editable layers instead of an empty box.
• Code: HTML, React, Next.js, Vue, and plain CSS.

Built for more than one frame

• Batch: select a set and download a streaming ZIP with a manifest of what is inside.
• Nothing silently missing: a broken frame is skipped and reported rather than failing the whole run.
• Cancel: long jobs stop when you tell them to.
• Self-contained: downloaded code carries its own styles, fonts, and images, so the design survives leaving Krit.

Placeholder rectangles are one of the tells that a screen was generated. Krit can now produce real images for a design, with two guards so it does not turn every surface into stock art.

• A necessity gate: an image is generated when the design calls for one, not by default.
• A cost ceiling: per-project budgets are enforced before a request is made, not discovered on a bill.
• Recapture that knows about media: regenerating a frame keeps the imagery consistent rather than reshuffling it.

A sitting-still canvas was firing roughly 22 network requests a second to revalidate frames that had not changed. We stabilized the subscription so an idle project now makes zero. Easier on your battery, your network, and the fan.

• Move with contents: dragging a section carries every frame inside its bounds, and membership self-heals on the next move.
• Title is a handle: drag from the title to move, double-click to rename.
• Any color: a full hex picker replaces the six presets, and the tint slider drives the fill live while you drag.

We rebuilt undo from the ground up to feel like a top-tier editor. The old version took seconds, threw snackbars, reset whole paragraphs, and could wipe another frame's animation. All of that is fixed.

What changed

• Instant and in place: the change reverses immediately, right where it happened.
• Granular text: undo steps back through your edits, not the entire paragraph.
• One unified stack: moves, styles, text, and structure all share a single, predictable history.
• No collateral: undoing a move no longer touches other frames' animations.

New handoff tools let an agent reason about a board the way an engineer would before writing a line:

• Component candidates: repetition on the board is detected and turned into reusable components with props.
• Computed spec: resolved values, your --cv-* tokens, and keyframe motion come through exactly.
• Reuse before create: the agent discovers components already in your repo and wires to those first.

• Arrow-key nudge of the selected element, coalesced into a single undo step.
• Tab / Shift+Tab to cycle through visible siblings without reaching for the mouse.
• Enter to edit text in place, and ? for the full shortcut cheatsheet.

• Instant page flip: the page changes immediately and persists in the background.
• Earlier paint: static frames render as soon as the page arrives, not after every frame loads.
• Idle prefetch: the next likely page is quietly prepared so it is ready when you get there.

Krit boards render in the viewer's sandboxed iframe, so anything pointing at your local files used to break the moment you shared. Every asset class is now made portable automatically, and the agent is steered to fix any local reference before you send the link.

• Camera position persists between sessions.
• Cmd+A selects everything on the page as expected.
• Share links open reliably, with the project they point to.
• Version history no longer throws on load.

Frames now keep a frozen snapshot alongside the live version, so zooming out shows the real design instead of empty boxes or stuck spinners. The swap between the two happens with no flash, and a data-loss guard protects your work as a project loads.

Ragged edges, muddy contrast, the default-gradient look: known AI-design tells are caught and corrected on every write, not flagged in a report you have to act on. The floor is a guarantee, not a suggestion.

Pick personas, run the walk, and Krit plays back each one moving through your flow and records what tripped them up. Usability feedback while the design is still on the canvas.

Storyboards let you author a sequence of beats on a shared clock, scrub the result live, and export it as video. The cinematic product reels you might have seen are made this way, inside Krit.

Krit is not locked to one assistant. Pick your client, paste the snippet, and your agent can read and build on the canvas. There is also a self-diagnosing setup helper if a connection ever misbehaves.

Krit connects your agent to a canvas. Ask for a screen and it renders as a real artboard you can see, move, and refine, with every change syncing live. This is the foundation everything since has been built on.