Encoder mechanics

Film grain smoothed out after uploading video.
Grain is the first thing a rate-limited encoder stops paying for.

Grain, halation and film emulation are high-frequency, low-correlation detail. That is the exact signature a rate-limited encoder reads as noise, and noise is what it defunds first. Here is the mechanism, what Vimeo's own published delivery ceilings imply for grainy footage, what to change at export, and the one structural fix.

See the plans

No credit card required. Cancel any time.

Updated September 2026

The mechanism

Grain is not noise to you;
it is the most expensive thing in your frame.

A modern video encoder is a prediction machine with a budget. It predicts each frame from the ones around it, encodes only the difference, and spends its remaining bits where it believes they will be missed. Grain defeats the prediction and then loses the argument about the remaining bits. Both halves of that sentence are mechanical, and neither is a bug.

Motion compensation cannot predict it

Inter-frame coding works by finding a block in a previous frame that looks like the block being coded, then storing the small difference between them. A grain field is close to random from one frame to the next, so no candidate block matches, the residual stays large, and the encoder is asked to spend real bits on a pattern that will be different again in a fortieth of a second.

The transform pushes it where the quantiser sweeps first

The residual is transformed into frequency coefficients. Smooth shapes land in the low-frequency corner; grain, halation edges and fine texture land in the high-frequency coefficients. Quantisation divides every coefficient by a step size and rounds. The small high-frequency values round to zero before anything else does, so the first thing an encoder discards, at any bitrate, is precisely the band your grain lives in.

Rate control has a budget, and grain is the line item it cuts

The encoder is targeting a bitrate, so each frame gets a share of bits and a quantiser step chosen to hit it. A grainy frame is expensive, which drives the step coarser, which zeroes more coefficients, which removes more grain. The feedback loop runs in the direction you do not want: the grainier the shot, the harder that shot is quantised.

Psychovisual models label it maskable

Encoders carry perceptual models that decide which detail a viewer will miss. Fine random texture with no shape is classed as maskable, on the reasonable assumption that it is sensor noise. Your grain and halation are indistinguishable from sensor noise at the coefficient level. The model is doing its job and getting your intent exactly backwards.

Put the four together and grain is uniquely badly served. Detail that is predictable, like a static wall or a slow pan across a building, costs almost nothing because prediction handles it. Detail that is unpredictable but structured, like a face in motion, gets defended because the perceptual model knows it matters. Detail that is unpredictable and unstructured is the worst case on both axes: expensive to code and cheap, in the encoder’s judgement, to throw away. That is grain. It is also halation bloom, film-emulation gate weave, and the shallow dither a colourist adds to protect a sky from banding.

Why it looks worse, not simply softer

The grain is not removed;
it is replaced.

If quantisation removed grain evenly you would get a clean, slightly plastic image and most people would shrug. That is not what happens, and the reason the complaint is always “smeary” rather than “soft” is worth understanding.

Quantisation zeroes the high-frequency coefficients but keeps the low-frequency ones. The energy that used to be a fine, even, per-pixel field is now carried by a handful of coarse coefficients spread across an eight or sixteen pixel block. Reconstructed, that is not an absence of texture. It is a larger, softer, lower-frequency blob, and there is one in every block. Then the next frame is coded and the blobs land differently, because the residual that produced them was different. The result crawls.

Your eye is extremely good at spotting low-frequency motion that does not correspond to anything in the scene, and extremely tolerant of high-frequency motion that does. Real grain is the second thing, which is why it reads as texture and film. Quantised grain is the first thing, which is why it reads as a wash moving under the picture. On skin it looks waxy. On a night sky it looks like a slow-moving stain. On halation around a practical light it looks like the bloom is breathing. Nothing in the frame is technically missing; the grain budget has simply been reallocated from a fine field to a coarse one.

The tell that says re-encode rather than bad export

Play your local master and the uploaded version side by side and watch a flat area: a wall, a sky, a shadow. If the master has an even, still-textured field and the upload has patches that shift shape every few frames, the grain was quantised away and rebuilt as block-level energy. If both look identical and merely soft, the problem is in your export, not in the platform. The second case you can fix yourself, and the section below is how.

What the published ceilings imply

Vimeo publishes its delivery maximums,
and says complex images get less.

This part does not need a measurement, because the numbers are Vimeo’s own. Vimeo states that during transcoding your file is re-encoded into several formats, and it publishes the maximum video bitrate of each rendition it delivers. Those are ceilings, and Vimeo says so in the same table.

22 Mbps

4K ceiling, H.264 ladder

Vimeo's published maximum for its 4K rendition

16 Mbps

4K ceiling, HDR ladder

The HDR and above-4K HEVC renditions are published separately and lower

Lower

On complex images

Vimeo's own qualifier: a video can transcode below the listed maximum depending on the complexity of the image

Re-encodes here

The player streams the exact bytes you uploaded

Vimeo H.264 ladder, 1080p60

up to 7 Mbps

Vimeo H.264 ladder, 2K

up to 12 Mbps

Vimeo HDR ladder, 4K

up to 16 Mbps

Vimeo H.264 ladder, 4K

up to 22 Mbps

Vimeo recommended 4K upload

30 to 60 Mbps

A 4K graded export, streamed here

150 Mbps, byte for byte

04080120160Mbps

Vimeo's maximum delivery bitrates per rendition and its recommended upload bitrates, both from its help centre, fetched 4 September 2026. Vimeo states that the bitrates listed for each resolution are a maximum and that a video could transcode at a lower bitrate depending on the complexity of the image. The uncompressed.io bar is not a ceiling: it is whatever bitrate your export happens to be, shown here at a 150 Mbps 4K grading export.

Now join the two facts. A rate-limited encoder spends fewer bits on complex images, and Vimeo says its output can fall below the listed maximum when the image is complex. Grainy footage is the definition of a complex image to an encoder: high entropy, poor inter-frame prediction, large residuals. So grain is not merely subject to the ceiling, it is the material most likely to be delivered at the lower end of the published range. That is reasoning about published ceilings, not a measurement of any particular file, and it is stated here as reasoning.

It also explains a result that confuses people: uploading a bigger file changes very little. Vimeo recommends 30 to 60 Mbps for a 4K upload, and delivers up to 22. The extra bitrate you send does useful work by giving the second encoder a cleaner input to work from, so it is still worth sending. What it cannot do is raise the ceiling on the file the viewer receives. If you want the arithmetic on your own footage, the bitrate calculator and video bitrate explained cover it.

The professional answer, and why it is closed to you

Denoise, encode, regrain: unless
you do not own the last encode.

Broadcast and streaming engineering solved this years ago, and the solution is the opposite of what most filmmakers try. You do not fight the encoder for grain bits. You take the grain out before the encode and put it back after.

Denoise the master

Strip the grain, and with it the expensive high-frequency residual. The clean image is smooth, highly predictable and cheap to code, so the same bitrate now buys detail in the parts of the frame that carry shape.

Encode the clean image

The quantiser is no longer being driven coarse by a grain field it cannot predict. Edges hold, gradients hold, and the bits go where a viewer will actually miss them.

Describe the grain in parameters

Grain is statistics, not content: a size, a strength, a chroma weighting, a per-channel variance. That is a few bytes per frame rather than a few megabits.

Rebuild it at the far end

The decoder synthesises grain from those parameters at playback. AV1 ships exactly this as a film grain synthesis tool. The viewer sees an even, correctly-sized grain field that was never quantised, because it was never transmitted as picture.

It works, and it is why a well-mastered film on a major streaming service can look grainy and clean at once. It is also unavailable to almost everyone reading this, for one structural reason: it requires ownership of the final encode. The denoise and the regrain have to bracket the same compression step. If you denoise and regrain in your grade, then hand the result to a platform that re-encodes it, you have simply given that platform a grainy master again, and its encoder makes the same decision it was always going to make. Your regrain is now input, not output.

The honest limit of every export-side tip

Everything in the next section improves the file you deliver and the first encode it goes through. None of it survives contact with a second encoder you do not control. That is not pessimism about any particular platform, it is the arithmetic: two lossy encodes in series means the second one gets the last word, and the last word about grain is always the same one.

What to change at export

Five settings worth fixing,
wherever the file is going.

These are worth doing even if you never move hosts. They make the file you hand a client better, they make the first encode less destructive, and two of them change how the grain behaves under any later quantisation.

Export at CRF 18 or below

Constant rate factor targets a quality level rather than a bitrate, so a grainy shot is allowed to get the bits it needs instead of being squeezed to hit a number. Vimeo itself recommends CRF 18 or below in its compression guidelines. Below 18 costs file size and buys grain; above 18 the quantiser starts clearing the high-frequency band on every complex shot.

Prefer 10-bit at the same bitrate

Ten bits give 1,024 code values per channel instead of 256. The quantiser has finer steps to land on, flat areas hold their shallow gradients, and the internal precision means less error accumulates through the transform. At an identical bitrate a 10-bit encode of a grainy shot holds together visibly better than an 8-bit one, and it is the difference between grain thinning and grain being replaced by bands.

Grain goes in the grade, not on the file

Add grain, halation and emulation before the final render, so exactly one encode sees them. Adding grain to an already-compressed file means encoding twice: the second pass now has to spend bits on your grain and on the artefacts underneath it, and it will fund neither properly.

Consider a slightly coarser grain

Fine grain lives in the highest-frequency coefficients, the first to be zeroed. A larger particle puts energy into mid-frequency coefficients that survive a coarser quantiser, so it thins gracefully rather than disappearing and being replaced by block-level blotching. If a delivery is going somewhere that re-encodes, size up half a step.

Keep the grain out of the chroma if you can

Chroma is subsampled to 4:2:0 on almost every delivery path, so chroma grain is being averaged into a quarter of the samples before the quantiser even starts. Luma-weighted grain reads the same to a viewer and costs the encoder far less.

Test on the rendition the client receives

Not your local render, and not the platform's preview player at whatever quality it defaults to. Force the exact rendition that will be delivered, play it full screen, and look at a flat area. This is the only step that tells you the truth, and it is the one almost nobody does.

One thing not on the list: sharpening. It is the common reflex when grain goes missing, and it makes the next encode worse. Sharpening raises high-frequency energy across the whole frame, which is more of exactly the material the quantiser is already clearing, so the encoder spends more bits arriving at the same place with harder edges around the blotching. If the image reads soft after upload, the answer is bitrate, bit depth and grain size, not an edge filter.

The structural answer

If nothing re-encodes the file,
there is nothing to survive.

Everything above is mitigation, because it assumes a second encode. Remove the second encode and the problem does not get better, it stops existing. A host that stores and streams the exact bytes you uploaded never makes a quantisation decision about your grain, because it never runs a quantiser.

Vimeo

What happensto your upload

Re-encoded intoseveral formats

Stored and streamedbyte for byte

Published 4Kdelivery ceiling

Up to 22 Mbps H.264,up to 16 Mbps HDR

The bitrate ofyour own export

On acomplex image

Can transcode belowthe listed maximum

No second encode,so no decision to make

Grain theviewer sees

Re-quantised by an encoderyou do not control

The grain yougraded and rendered

Adaptiveladder

Yes, several renditionsper upload

None: one file,one bitrate

On a slowconnection

Drops to a lower,softer rendition

Buffers, rather thanquietly degrading

Codecs thatstream

H.264 renditions, with HEVCfor HDR and above 4K

H.264, HEVC and AV1,as the file was encoded

Vimeo figures and policies from its help centre, fetched 4 September 2026: every upload is re-encoded into several formats; the published maximum delivery bitrates are up to 22 Mbps at 4K on the H.264 ladder and up to 16 Mbps at 4K on the HDR ladder; Vimeo states those are maximums and that output can be lower depending on the complexity of the image; above 4K is delivered in HEVC. uncompressed.io accepts MP4 or MOV in H.264, HEVC or AV1 up to 50 GB per file; ProRes and DNxHR are hosted for client download rather than streamed.

Three caveats belong on the same page as that claim, because the trade is real. Playback depends on the viewer’s hardware decoder, so a 10-bit 4:2:2 HEVC file plays where the machine in front of the client can decode it and not where it cannot. There is no adaptive ladder, which is the direct consequence of never re-encoding: a viewer on a weak connection buffers instead of being silently handed a mushier version, and on some jobs that is the wrong trade. And camera RAW is not part of this at all: the honest workflow is to finish to HEVC or ProRes and upload that. If 10-bit delivery is the part you care about, the 10-bit video hosting and HEVC 10-bit 4:2:2 browser playback pages carry the decoder detail.

When you should not move

Reach requires the ladder,
and grain is what it costs.

There is a version of this page that ends by telling you to leave every platform that re-encodes. That version would be wrong, and here is the honest boundary.

If the job is reach, the ladder is not optional. A platform that has to serve one file to a phone on a train, a laptop on hotel wifi and a television on fibre has no choice but to produce several renditions at several bitrates, and producing them means re-encoding what you sent. Your grain will be quantised no matter which host you pick for that job. Nothing in this page changes that, and choosing a host that does not re-encode does not get you a grain-safe version on a discovery platform, because you still have to publish there separately. Publish for reach where reach lives, and accept the ladder as the price.

The same goes for the rest of what a mature platform sells. Vimeo’s player, its marketing and lead-capture tooling and its OTT products have no equivalent here, and none of them are on the roadmap. If your delivery depends on those, the grain question is a small line in a much larger decision and the answer is to stay and export well.

Where a no-re-encode host earns its place is the narrow, high-stakes case: the client review of a graded cut, the director’s approval of a look, the portfolio piece where the grain structure is the work, the delivery where someone is paying for a finish and needs to see the finish. Those files go to a handful of named people, not to an audience, so the ladder buys you nothing and costs you the thing being judged. For everything else, use the export settings above and stop sharpening.

Questions

Frequently asked

Does video compression ruin film grain?

It does not ruin it evenly, which is the problem. Grain is near-random, so motion compensation cannot predict it from the previous frame and the residual stays large. It is also high-frequency, so the transform concentrates it in the coefficients the quantiser rounds to zero first. At a low enough bitrate the fine structure is gone and what replaces it is a coarser, moving blotch pattern. That reads as smeary or plasticky rather than clean, because your eye is comparing it to the grain it saw a second earlier.

Why does the encoder target grain specifically?

Rate control has a bit budget per frame and has to decide where the bits go. Psychovisual models treat fine random texture as maskable: the assumption is that a viewer will not miss detail that carries no shape. That assumption is right for sensor noise in a corporate interview and wrong for a grain structure you added on purpose, and the encoder cannot tell the two apart.

Will a higher export bitrate fix it?

It fixes the first encode, which is worth doing. It does not fix a platform that re-encodes what you send. Vimeo states that every upload is re-encoded into several formats, and publishes maximum delivery bitrates of up to 22 Mbps at 4K on the H.264 ladder and up to 16 Mbps on the HDR ladder. Whatever you upload above that is spent on giving the second encoder a cleaner input, not on what the viewer receives.

Does 10-bit help grain survive?

Yes, at the same bitrate. Ten bits give the encoder 1,024 code values per channel instead of 256, so the quantiser has finer steps to land on in flat areas and in the shallow parts of a grain field. The practical effect is less banding where the grain has been stripped, and a slightly cheaper residual because the internal precision is higher. It is not a substitute for bitrate; it makes the bitrate you have go further.

Why is denoise then regrain not available to me?

Because it requires control of the last encode. Broadcast and streaming pipelines denoise the master, encode the clean image cheaply, then rebuild the grain at the far end, which is also what AV1's film grain synthesis tool does in the decoder. If a platform re-encodes after you deliver, that last encode is theirs, not yours, and any grain still in your file arrives at their encoder as expensive noise.

Does a fine grain or a heavy grain survive better?

A slightly coarser grain survives better at any given bitrate. Fine grain lives in the highest-frequency coefficients, which are the first zeroed. A larger grain particle has energy in lower-frequency coefficients that the quantiser keeps for longer, so it degrades gracefully instead of vanishing and being replaced by blotching. Test it rather than trusting the intent: render two grades and watch the rendition the client will actually be sent.

What does uncompressed.io do differently?

There is no second encode. The player streams the exact bytes you uploaded, so the grain that leaves your grading suite is the grain that reaches the viewer. The honest caveats: playback depends on the viewer's hardware decoder, browser-decodable codecs stream (H.264, HEVC and AV1) while ProRes and DNxHR are hosted for download rather than streamed, and there is no adaptive ladder, so a slow connection buffers instead of quietly switching to a mushier rendition.

Grain survives when nothing re-encodes it

The player here streams the exact bytes you upload. No transcode, no adaptive ladder, no second encode to re-quantise the grain you spent an afternoon dialling in.