Grainy: real-time film effects in the iPhone viewfinder

The problem: digital photos are too clean

Modern phone cameras are extraordinarily good, and that is exactly the problem.

Every year the computational photography stack gets better at removing the things that used to make a photograph feel like a photograph. Noise gets denoised. Highlights get pulled back. Skin gets smoothed. Shadows get lifted until nothing in the frame is genuinely dark. The result is technically excellent and emotionally flat — an image with no evidence that a physical process ever produced it.

Film has the opposite personality. Grain, halation around bright edges, a color response that is not neutral, highlights that roll off instead of clipping, a slight softness that a lens designer would call a flaw. None of that is "better" by any measurable standard. It just reads as real, because it is the visible residue of light hitting a physical emulsion.

So people want the film look back. The obvious way to get it is to shoot a normal digital photo and run a filter over it afterward. That is what almost every app on the App Store does, and it is the thing Grainy deliberately does not do.

What Grainy is

Grainy is an iPhone camera app that renders film effects live, in the viewfinder, as you frame the shot. What you see before you press the shutter is what you get after.

That distinction sounds like a technical footnote. In practice it changes the entire experience of shooting.

When the effect is applied after capture, the camera is a data-collection step and the app is a darkroom. You shoot, then you scroll through a strip of presets, then you decide which one you like. The creative decision happens in a gallery, minutes or days later, disconnected from the thing you were looking at.

When the effect is live, the camera becomes an instrument again. You move the phone and the grain moves with it. You point at a bright window and watch the highlight bloom in real time. You notice that the look falls apart in flat overcast light and comes alive at golden hour — and you notice it while you are standing there, which means you change what you shoot. The feedback loop is closed. That is what shooting film actually feels like, and it is the part the after-the-fact filter apps cannot reproduce no matter how good their presets are.

Why real-time is the hard part

Applying a film look to one still image is not difficult. Applying it to every frame of a live camera feed, continuously, on a battery-powered device, is a different engineering problem entirely.

The camera feed arrives as a steady stream of frames. Every one of them has to be pulled off the camera pipeline, processed through the full effect chain, and put on screen before the next one arrives — and it has to keep doing that indefinitely without the phone getting hot, the preview stuttering, or the battery visibly draining while the user is still deciding what to photograph. Miss the budget on a single frame and the user does not see a dropped frame; they see a viewfinder that feels broken.

That constraint reshapes every design decision:

The effect chain has to be built for a per-frame budget, not for quality in isolation. A film simulation is not one operation. It is a stack: tone response, color shift, grain, halation and bloom around highlights, vignetting, a touch of softness. Each layer is cheap on its own and expensive in aggregate. Getting the stack to fit means being honest about which layers actually carry the look and which ones are decoration that costs frames.

Rendering has to happen on the GPU, on-device. Nothing round-trips to a server. There is no "processing…" spinner, because a spinner in a viewfinder is a contradiction. Everything is real-time on-device rendering, which also means the app works on a plane, in a basement, and in a foreign country with no data plan — where, in practice, a lot of the photos people care about actually get taken.

Grain has to move correctly. This is the detail that separates a convincing live film look from an obvious fake. Real grain is a property of the emulsion, so it changes every frame, randomly. A static grain texture overlaid on a moving preview reads instantly as a screen-door effect — the grain sits on the image instead of being in it. Making grain that resamples per frame, at the right scale, without shimmering into visual noise, is a surprisingly finicky problem.

The preview and the capture have to agree. The viewfinder runs at preview resolution; the photo is captured at full sensor resolution. Run the same effect chain on both naively and the results do not match — grain that looked right at preview scale becomes invisible at full size, and halation that looked subtle becomes heavy-handed. The effect has to be defined in terms that scale, or the promise of "what you see is what you get" quietly breaks at the exact moment the user presses the shutter.

"No presets, no fakery" as a product philosophy

The line in Grainy's description — real film effects, no presets, no fakery — is a product position, not marketing copy.

Preset-driven apps make a specific bargain with the user: here are forty looks, swipe until one feels right. It is a generous-seeming offer that quietly outsources the aesthetic decision to a menu. It also encourages the app to keep adding looks, because the count is the selling point, and the looks drift further from anything a physical film ever did.

Grainy takes the opposite bargain. There is one coherent rendering of what film does to light, and the user's job is to point it at something worth photographing. Fewer decisions in the app, more decisions in the world. The constraint is the feature — the same way shooting a single roll of one stock for a week makes people better photographers than having every look available at all times.

"No fakery" is the stricter half of the claim. It rules out the shortcuts that make a film look cheap: a scanned dust-and-scratches overlay, fake sprocket holes, a light leak stamped in the same corner of every frame, a date stamp in the bottom right. Those are costume-shop signifiers of film rather than a simulation of it. They are also instantly recognizable — put two of those photos next to each other and you can see they came from the same asset library. Effects that are computed from the actual image content, frame by frame, can never have that problem, because there is no library to repeat from.

What building it clarified

Three things carried over into how I approach product work generally.

Latency is a feature, not a metric. The entire value of Grainy lives in the gap between moving the camera and seeing the result. That is true of far more products than people admit — a voice agent, a search box, a form that validates as you type. Once feedback arrives fast enough, users stop evaluating the tool and start using it. The engineering work to close that gap is not polish, it is the product.

A narrow product needs an opinion. "Film camera app" is a crowded category, and the only defensible position in a crowded category is a point of view someone can disagree with. Refusing presets loses the users who wanted forty looks. It also makes the app legible to the people who wanted exactly one honest one.

Constraints picked early are cheaper than constraints discovered late. Deciding up front that everything renders live, on-device, per frame, ruled out entire categories of implementation before any of them got built. That decision cost some effects that were only viable as post-processing. It also meant there was never a version of the app that felt fast in the demo and slow in the hand.

Grainy is on the App Store. Point it at good light.