Creeza
A Mac app for designing with AI. Drag in an AI model, a photo, a song, connect them with cables, and watch every step render live on one canvas.
Last updated 18 August 2026
Work in progress
Creeza is still being built, so this case study writes itself using AI. It regenerates from the project description in my CLAUDE.md and from screenshots the app captures automatically as features land. I'm prototyping, exploring and validating as I build, so some of what you see here is an idea being tested rather than a finished decision. I direct the page like an editor, shaping it by taste and giving notes; Claude Code does the rest. This is the state of the work today, not a retrospective written after the fact, so come back often as the project keeps moving.
Seven documents, end to end. Models, media and logic sit side by side as patches, wired into a View that renders as you work. Every step shows its own result.
Overview
You drag in the things you need, a camera, a photo, a model, a sound, connect them with cables, and every step shows its own result right there on the canvas. No render step, no preview window, no waiting to find out what you made.
It's the directness of Quartz Composer and Origami, pointed at the AI era. And what you build isn't a mockup: the same file runs inside a real app, so the thing you tuned is the thing that ships.
The name is a portmanteau: creez, French for “create,” and sprezzatura, the Italian art of making hard things look effortless.
Two builds, one file format
Creeza
On the App Store. The whole library, everything on your Mac, everything in the cloud.
Creeza Pro
Adds the terminal, the Claude-powered canvas assistant that can scaffold and build real projects, command-line patches, and stem separation.
Both editions open the same files. If a document uses a Pro patch and you're on the App Store build, it stays put and shows a badge, nothing is ever quietly removed from your work.
Prompt in one app, download, re-import, discover it doesn't work in context, start again. How a model behaves inside a real interface is the part you never get to feel.
One local canvas where the models, the media and the layout are the same document. Wire an asset into the thing that uses it and see the result at full fidelity, instantly.
AI makes the assets
Images, sound, voice, video and 3D are made right next to the layout that uses them. No round trip, no re-importing, no naming files.
Generate sits in the graph as a processor like any other, with Run and Done in the same Action strip every patch uses. When Apple's Image Playground finishes, the sheet closes itself instead of waiting for a click, the preview hinge places itself to suit the shape of what came back, and the Quality knob is hidden on the models that ignore it rather than pretending to matter.
Read moreRead less
A lot of it runs on your Mac with Apple's own models: no key, no account, nothing metered. When you want a particular look or voice, the same patch reaches out to OpenAI, Gemini, Stability or ElevenLabs, so switching provider is one connection rather than a rebuild.
Auto-confirm reads the Image Playground sheet through the same accessibility tree VoiceOver reads, and only fires when the patch's Done output is actually wired, so it never steals a click you meant to make. Provider action buttons fade in on hover or selection, so a resting patch is just its content, and the preview/inline toggle moved out of the header into the info popover where it reads as a setting rather than a mystery glyph.
Several attempts can live side by side. Keep four versions in one place, flip between them, and the layout updates around whichever one you're looking at.
Assets generated in the graph, landing straight in the layout that uses them.
Pick the model, not the app
Every service sits behind the same kind of patch. Choose the one you want from a menu, and swapping it for another is one connection, not a rebuild.
And the badge you picked is the model that ran. Ask for something a service can't do, video on Grok, say, and Creeza tells you, instead of quietly generating on something else.
Apple, on your Mac
The Foundation Models, Image Playground, Vision, Speech and Translation. Text, images, understanding, transcription and voices with no key, no account and nothing metered.
OpenAI
Language, code and image generation and editing, for when you want that particular look or a model that reasons harder than the on-device one.
Anthropic
Claude for text, structure and code, including the Claude CLI patch that writes new patches inside your document (Pro).
Google AI
Gemini for text and images, Veo for video. The video path is separate on purpose, because video models and image models aren’t interchangeable.
xAI
Grok for text, code and images, chat-completions for the words, the Imagine API for pictures, generating or editing depending on whether a reference image is wired.
Stability AI
A different house style for stills, and the one to reach for when a prompt lands better outside the big general-purpose models.
ElevenLabs
Voices, dubbing and invented sound effects, when Apple’s speech synthesis isn’t the performance you’re after.
BytePlus ModelArk
Seedance for video generation, alongside Veo, so a shot has more than one model to come from.
LALAL.AI
Stem separation in the cloud, for splitting a track when you’re on the sandboxed App Store build. Local separation is Pro.
On-device work is free and unmetered. The third-party services draw credits, and only when you actually call one.
Pay only for what leaves your Mac
Anything Creeza can run on-device, or on Apple's own cloud, is free and unmetered. Credits cover the third-party services, the image models, the music models, the large language models, and only when you actually call one.
The balance sits in the toolbar with a running log of what spent it, so the cost of an experiment is visible while you're making it rather than at the end of the month. Credits never expire, they're tied to your account, and they survive a reinstall.
Read moreRead less
Buying is an App Store purchase, so it's Face ID or a password and done, on the payment method already on your Apple Account. No card entry, no billing portal, no per-service API keys to manage, and family sharing and refunds work the way they do for anything else you buy from Apple.
Every new account starts with 500 credits, which is enough to find out whether the paid models are worth it before spending anything.
Behind it is real infrastructure rather than a mock: a Postgres-backed service with per-host TLS, and balance totals reconciled against the database.
Your file is the product
Most prototypes get read once and rebuilt from scratch. This one gets dropped into the app and runs, on Mac, iPhone, Apple TV or Vision Pro.
And it runs alive. The embedded file isn't a static render: pulses tick, animations play, the music actually sounds, and a tap on the host's screen reaches the graph.
Read moreRead less
One click, File ▸ Send to Xcode, wraps your document in a ready-to-run host project (Pro). Nothing is converted or regenerated, so when the timing feels off two weeks later you open your file, fix it, and hand back the same file. The export command is the Pro-only part, because it spawns the Xcode toolchain; CreezaKit itself isn't gated.
CreezaKit is an early runtime, v0, but it's real: three sample hosts — a Mac app, an iOS tab app and a tvOS app — load the same documents today. Samples, not products. Touch goes through an Interaction patch that turns a tap on a layer into Down and Tap signals, even inside collapsed components. Both app targets build with zero compiler warnings, if you're the kind of engineer who checks.
It's a proper Mac app about it too: tabs, recents, duplicate, rename, autosave. Documents carry their own media inside, so sending one to someone just works.
CreezaKit
Engineers add one Swift package and point it at the document. CreezaKit renders the file natively, exposes its inputs as ordinary Swift properties and its outputs as callbacks, so wiring a Creeza scene into an existing screen is a few lines rather than a rebuild. The graph stays the source of truth, which means designers keep iterating on the same file after integration.
Say it, don't hunt for it
Drop a cable in empty space, say what you want, and the right thing is already at the top of the list.
And now see it, too: results come in two columns, every patch wears its own symbol, and AI patches have a category of their own — so browsing works as well as asking.
Read moreRead less
It reads the cable before you type. Two images in means image processors rank first, text tools sit below, and anything incompatible never appears at all.
Hit return on the top result and it lands wired up, inputs connected, ready to run. Dictate it instead of typing if you'd rather, or leave the model on Auto and let Creeza pick.
The AI category sits alongside the domain filters rather than replacing them, and each symbol comes from the patch's own definition, so the picker, the canvas and the docs all agree on what a thing looks like.
What you get to play with
Media & AI images
Make an image, edit one, extend past its edges, remove something and heal the gap, lift a subject off its background, upscale, crop, glitch. Turn a still into 3D, or into motion.
Text & understanding
Describe what's in a picture, pull the text out of one, translate copy, or dub a whole video, and turn speech into text. Claude for everything else (Pro).
Sound & music
Speak text aloud, invent sound effects, compose and remix music, recognise sounds. Read a track's beat, key and structure so your interface can move with it, then trim, pitch, crossfade, wash it out with one knob, or stutter audio and video in time. Split a song into stems (Pro).
Inputs
Camera, photo library, microphone, your music, the keyboard, taps and presses on any layer, and your AirPods, which will tell you where someone's head is pointing and when they nod. Drop or paste in anything else.
Logic & timing
Count, compare, switch, sample and hold, pulse, loop, and draw your own animation curve on a timeline. If you know Origami or Quartz Composer, this part needs no introduction.
Output & layout
Layers, video playback you can drive from the graph, an Apple Maps layer whose camera any patch can fly, artboard frames with auto-layout, and comments for the next person who opens the file.
Model & service coverage
Apple's on-device models, OpenAI, Anthropic, Google AI, xAI's Grok (text, code and images), ElevenLabs, Stability AI, BytePlus ModelArk and LALAL.AI, all behind the same kind of patch, so swapping one for another is one connection. Pick a model that can't do the job and Creeza tells you, rather than quietly generating on something else behind the badge you chose.
It can see what you dropped in
Hand Creeza an image and it will tell you what's in it, read the text off it, and find the subject. Your layout can then react to the picture instead of ignoring it.
Read moreRead less
That description is just a value, so it can caption the image, feed the next prompt, or decide which of three layouts an asset belongs in. Point it at a folder and the same graph sorts and re-lays every file in it.
Extract pulls the words out of a screenshot or a photo, which makes real content easy to get at when all you have is a picture of it.
It runs on your Mac, so you can throw a hundred images at it without watching a spinner or a bill.
Vision doesn't stop at the media you drop in. Creeza captures the canvas itself and reads it the same way, so the picker knows what you're looking at, not just what you typed.
Read moreRead less
When a request doesn't match anything in the library, the picker falls back to Ask Creeza: same Vision path, reasoning over what's actually on the canvas rather than a keyword guess, so it can match you to a patch, or invent a new one on the spot.
Motion that lands on the beat
Drop in a track and Creeza hears it. Motion doesn't approximate the music, it's driven by it.
Read moreRead less
Tempo, key, downbeats and where the sections change all come out as values you can wire into anything.
No counting frames, no nudging keyframes until it feels close. Swap the song and the timing follows.
The Music patch also takes a Time input, so the playhead is a value like any other: wire a slider, a counter or another patch to it and scrub the track from the graph while everything downstream follows. Time as data, the same idea as the Timeline patches applied to audio analysis.
Beat Repeater's video monitor went through three implementations in a day. Seek-driven playback made the knobs buttery but stuttered on fine grids; swapping composition items keeps repeats locked to the grid at 1/8 and below, at the cost of a less smooth knob. Timing won, on purpose. Its ports are grouped Body, Action and Advanced, and it exposes a Time output other patches can consume.
Beat Repeater with tempo, grid and repeat count as ordinary inputs, the same numbers the Music patch is already producing.
Music
The listener. Beat, BPM, key, and the structure of the track (intro, drop, chorus) read on your Mac, no upload. Its outputs are the clock everything else runs on.
Beat Repeater
DJ-style stutter, but for picture as well as sound. Set the grid and repeat count and it chops audio and video together, always in time. A Play button auditions it in the patch, and an Enable switch A/Bs it against the dry signal.
Fade to Grey
One knob that drains a scene: colour, brightness and audio pulled down together. Tie it to the beat for a build, or to a gesture for a mood.
Treatments you can dial in
Crop, upscale, lift a subject out, drain the colour, or run it through Glitch for real signal damage. Every control moves live under your hand.
Cropping is now just resizing. Drag an image patch's corner and the output reframes to exactly what the preview shows you, on generated images and on photos you dropped in, so reframing is a drag rather than a trip to another app.
Read moreRead less
Effects chain and stack, and a chain you like becomes a component with only the knobs you care about exposed. Point it at every variant instead of repeating the same treatment by hand.
Any control can be handed to something else: a beat, a head turn, a slider, a playhead. Glitch on the downbeat, colour draining as a scene ends, a mask tightening as someone leans in.
Nothing is baked in. Change the source image weeks later and the whole treatment re-runs on it.
The crop reads its source from the patch's own preview assets rather than an input port, so it composes with whatever produced the image. Cells clip content at the cell's final frame, which is what makes the preview an honest promise of the output.
A crop and treatment chain wrapped into a component, reused across every variant.
Words as live material
Speech becomes text, text becomes any language, and either can be spoken back in a voice you choose. Copy stops being placeholder.
Read moreRead less
Localisation becomes something you can see: run your layout in six languages and watch which strings break it, rather than finding out after handoff. Dub a whole video and the transcript, the timing and the voice all come from the same file.
Feed a line to a voice and hear it read. Hear how a prompt or an empty state actually sounds before anyone books a session.
It runs on your Mac, so nothing is uploaded and there's no wait between hitting play and reading the result.
Playhead position, transcribed text and the frame itself, all readable on the canvas at once.
Layout you can animate
The View is a real patch now, with the same proportions, port rail and settings drawer as everything else on the canvas. Its Spacing and Padding are number ports, so a beat, a slider or a model output can drive them, and the layout breathes instead of sitting still.
Drag a cable over a View and it lights the same drop ring a patch does, so it's obvious where content lands. Reordering nested Views works exactly like reordering layers, and the drop preview lands on the slot it promised. Padding starts at 0, so a View is flush until you decide otherwise.
Read moreRead less
The View was merged onto the same Consumer template every other patch uses, which is why it now resizes, reorders and reveals its chrome like its siblings: one set of behaviours instead of a bespoke copy. Colour, Fill and Corners knobs went away, because the layers themselves already control those, and a crop of phantom knob dots that were swallowing clicks on the real ones went with them.
Because every asset arrives from the graph, rearranging is cheap: nudge an image and the version behind it follows, swap the source and the composition survives.
Even Apple Maps is a layer now, not an app. The map renders in the composition and resizes like anything else, and latitude and longitude are just ports, so a language model extracting a place from text, a slider or a beat can fly the camera. It's MapKit on the same patch template as every other visual, which is why it composes instead of being a special case.
Comments sit on the canvas next to it all, and they hold pictures rather than just words, so the reasoning for a choice lives beside the choice.
Layers composing a view, with a comment holding the references the layout was judged against.
Watch it while you build it
Your composition plays full-size in a floating Viewer while the graph stays under your hands. ⌘3 brings it up, ⌘F takes it full screen.
Drag any corner and it resizes from that corner, then glides back to its home corner instead of snapping. Controls hide at rest, so nothing sits between you and the work. And when the motion is right, you don't screen-record around the chrome: the Viewer itself captures stills and records video of the composition, sound included, so a clip of a beat-driven layout arrives with the beat in it.
Read moreRead less
Opening and closing are instant, with no window-server churn. Resize is computed in screen space, so the grip stays under your cursor with no flicker. Capture moved out of the View patch and into the Viewer's header, where the recording actually happens.
The Viewer also survives stepping inside a component: edit a nested interior while the outer composition keeps playing.
The canvas is the product
A canvas that behaves
Alignment guides, distance rulers, marquee select, smooth pan and zoom, real undo. Number fields keep the decimals you type. Pull a cable into empty space and Creeza offers only the things that could actually connect there, and pointing at a patch in a big graph repaints that patch, not the document.
You can see everything
Images, video, spinnable 3D, text, colour, numbers, each step previews itself in place. Click any result to copy it out. Even the cables tell you what's flowing through them.
Most of it is free
A large part of the library runs entirely on your Mac. No API key, no account, no per-image cost, just work.
The big models, when you need them
OpenAI, Claude, Gemini, ElevenLabs, Stability and more are a patch away. New models show up without waiting for an app update.
Ask, and it wires itself
Describe what you're after and Creeza drops in the right pieces, or writes a brand-new patch when nothing in the library fits.
Tidy up as you go
Wrap any messy cluster into a single reusable Component, name the few knobs that matter, and step back inside whenever you want to change it. Those named knobs are also what an engineer hooks into later.
The rest of your desk, docked
Drag a cable out of the graph and drop it into a chat. The image you just made becomes the thing you're asking about.
Read moreRead less
Left: Claude, ChatGPT, Gemini, Meta AI, Grok and Weave as chats, live and always loaded, so switching never loses your place. (Grok is also a service your AI patches can run on, over in the library.)
Right: Figma, Google Stitch and Claude Design, or a real terminal if you want one (Pro).