DaVinci Resolve Preview Fine but the Export Has Artifacts? Render, Encode & VRAM Diagnosis Guide

2026-11-17 | GPU Repair | 26 minutes | HK GPU Fix Editorial Team

DaVinci Resolve Preview Fine but the Export Has Artifacts? Render, Encode & VRAM Diagnosis Guide

Key Summary

The timeline plays back cleanly, yet the finished export shows green blocks, tearing, flicker, or black frames. This guide separates the export path from the preview path, using a finished-file playback check, a software-encode comparison, and a short-clip export to tell the render, encoder, effects, and memory layers apart.

The Shape of the Problem: Clean Preview, Damaged Export

This guide covers one specific shape, and the shape itself is the whole diagnosis. The timeline in DaVinci Resolve plays back without a visible fault. Scrubbing works, playback is smooth, the picture on the viewer looks right. Then the export finishes — no error, no crash, no stopped progress bar — and the finished file, when played back, has green blocks, coloured patches, tearing, flicker, or black frames in it.

That combination is what makes this symptom different from its neighbours. An export that fails partway through, with an error message or a halted progress bar, is a different shape, and it belongs with the export-failure diagnosis. A timeline preview that is itself damaged while the export comes out clean is the exact mirror of this one, and it belongs with the preview-artifact diagnosis. This guide is about the third combination: the preview is fine, the export completes, and the finished file is damaged.

The first conclusion most owners reach is that the source footage is broken, and the first remedy most reach for is buying a stronger graphics card. Both of those first reactions overlook the single fact that defines the symptom: the same footage plays back correctly in the timeline. If the source file were damaged at its core, the preview would normally show the same damage at the same point. And a fault that only appears when the picture is being written out is not, by itself, evidence that the card lacks computing power. The question is not whether the card is strong enough. The question is which part of the export path — the rendering, the encoding, the effects, the cache, or the memory — introduces the damage after the preview has already shown the picture correctly.

Why the Preview and the Export Are Two Different Paths

The key to this symptom is that preview playback and file export do not take the same route through the machine, even though they start from the same timeline. Preview playback is built for speed: the software may use proxy or optimised media, lower the playback resolution, skip or simplify effects, and reuse frames it has already computed and stored in the render cache. Export is built for final quality: it renders every frame at the full output resolution, applies every effect in full, and writes each frame through the encoder into a finished file.

That separation is why a clean preview and a damaged export can exist side by side without contradiction. Something can go wrong in the full-quality rendering, in the cache that the export reads, in the hardware encoder that writes the file, or under the memory load that only a full export creates — while the lighter preview path, which skips or simplifies those same steps, keeps looking fine.

There is one more point to settle before the layers begin. Re-exporting with the software encoder and watching the artefacts vanish proves something precise, and it proves nothing beyond that. It shows that the damage travels through the hardware encoding route. It does not prove the card has failed, it does not prove the driver is broken, and it does not prove the project is corrupt. It proves the fault lives somewhere on the hardware-encode path, and the rest of the guide is about narrowing that path down, one variable at a time.

The Five Suspicion Layers

A damaged export can fail at five layers, and they must be kept separate. Changing the encoder, the render cache, and the effects all at once and finding the export clean proves nothing about which change did the work, and the artefacts will return the next time only one of those conditions is present. The layers below run from the most direct test to the hardest to isolate, and each one has its own deciding evidence.

LayerWhat it coversDeciding evidence
1. Renderer layerThe GPU processing mode and the renderer setting the software uses for the timeline and the exportChanging the GPU processing mode or the renderer setting changes the export
2. Effects, Fusion, and plug-in layerIndividual effects, Fusion compositions, and third-party plug-ins on the timelineDisabling one effect at a time clears the artefacts
3. Decode and source-media layerThe source codec, inter-frame compression, and whether the media itself is damagedThe damage always sits at the same timecode, on the same clip
4. Hardware encoder layerThe hardware encoder, the output codec, and the encoder preset and bitrateA software-encode export of the same section comes out clean
5. VRAM, driver, and cache layerMemory pressure at full export resolution, a damaged render cache, damaged optimised media, and driver compatibilityClearing the cache and disabling optimised media changes the export

Layer One: The Renderer Layer

The renderer layer is the setting that decides how the software uses the graphics card to process the timeline. In DaVinci Resolve this is the GPU processing mode, which may offer choices such as CUDA, OpenCL, or Metal, along with automatic or manual card selection; in Premiere Pro it is the Mercury Playback Engine renderer setting. The same setting shapes both the preview and the export, but the export exercises it far harder, at full resolution and with every effect applied.

The evidence for this layer is change: switching the processing mode or the renderer setting and re-exporting the same section changes the result. One caution matters here. Software updates can reset these settings, so a project that exported cleanly before an update and produces artefacts after it deserves a check of the renderer setting before anything else is blamed. Do not write any version number down as a general standard — versions change, and the current official release is the reference. Menu names and locations also change between releases, so the paths named in this guide should be checked against the version actually installed, and the current official manual is the authority for them.

Layer Two: The Effects, Fusion, and Plug-in Layer

This layer is about what sits on top of the footage. A particular effect, a Fusion composition, or a third-party plug-in can interact badly with the source media, with the renderer, or with the encoder — and the interaction may only show up when the export renders that effect at full quality, while the preview plays a simplified or cached version of it.

The evidence for this layer is selectivity by disabling. Turn off one effect at a time, and re-export the same short section after each change. Whichever effect, when disabled, makes the artefacts disappear is the trigger condition. The same logic applies to Fusion compositions and to plug-ins: isolate them one at a time, and change only one thing between exports. A test that disables three effects at once and finds the export clean proves nothing about which of the three mattered.

Layer Three: The Decode and Source-Media Layer

This layer is about the footage itself and the codec it was recorded in. Inter-frame codecs such as H.264 and H.265 compress video by storing differences between frames, so playing back one frame can require decoding several frames around it. Intra-frame codecs such as ProRes and DNxHR store each frame on its own, so each frame can be decoded independently. That difference matters at export time, because the export decodes every frame at full quality, while the preview may be reading optimised media or a cached render instead.

The characteristic shape of this layer is a fixed position: the artefacts appear at the same timecode, on the same clip, in every export. A clip whose own data is damaged also sits in this layer. But a fixed position alone does not prove the media is damaged — it only proves the fault is tied to that part of the timeline, and the effects sitting on that part must be ruled out first, by the one-at-a-time disabling test in the layer above.

Layer Four: The Hardware Encoder Layer

The hardware encoder layer is where the rendered frames are written into the finished file. Hardware encoders such as NVENC and AMF do that writing on the graphics card, and they are the usual choice for speed. The output codec matters here too: H.265 and AV1 encoders, and particular presets and bitrate settings, ask the hardware encoder to do different work, and a setting that the hardware encoder handles badly can leave visible defects in a file that otherwise exported without complaint.

The deciding test for this layer is the software-encode comparison: export the same section with the software encoder, using the processor instead of the hardware encoder. If the artefacts vanish, the fault points at the hardware encoder layer. If they are still there, the fault is elsewhere, and the investigation moves on. This is a comparison test, not a repair. Exporting with the software encoder is far slower, and treating it as a permanent workaround means giving up the hardware encoding that the export normally relies on.

Layer Five: The VRAM, Driver, and Cache Layer

The last layer gathers the conditions that only a full export creates. A high-resolution timeline with several layers of effects puts far more pressure on graphics memory during export than during preview, and memory pressure can show up as artefacts that wander from place to place between exports. The render cache is part of the same layer: the cache stores pre-computed frames so the timeline can play smoothly, and a damaged cache entry can be read back into the export while the preview, playing from a different path, looks fine. Damaged optimised media or proxy files can do the same thing, because the export may be reading the optimised copy rather than the original footage.

The driver sits in this layer as well, because the export exercises the driver at full load in a way the preview does not. A driver version that does not sit well with the editing software in use can produce artefacts only at export time. The evidence here is change in the driver version, checked against the current official release — never a version number written down as a permanent standard.

The Deciding Fork: Play the Finished File, Then Re-Export with Software Encoding

The whole guide turns on two tests, and they should be done before any setting is changed in anger.

First, play the finished file three times and note whether the artefacts sit at the same timecode every time. Then play the same file in a different media player, and, if convenient, on a different computer. If the same timecode is damaged every time, in every player, the damage is in the finished file itself, and the fault is locked to the export path. If the file plays cleanly in another player or on another computer, leave the export path behind: the fault is in the playback and decoding layer on the first machine, not in the export.

Inside the export path, the second fork is the software-encode comparison. Export the same section with the software encoder, using the processor. If the artefacts vanish, the fault points at the hardware encoder layer. If they are still there, the fault points at the rendering or memory layers, and the investigation continues through the effects and cache tests.

There is a third fork, on position. If the artefacts sit at the same timecode and on the same effect every time, they point at the source-media or effects layer. If they wander to different places in each export, they point at the memory or driver layer. Fixed damage and wandering damage are different evidence, and they must not be mixed up.

A fourth fork sits in the cache layer. Clear the render cache, disable optimised media and proxies, and re-export from the original media. If the export comes out clean, the fault points at the cache layer. If it is still damaged, the cache layer is not where the fault lives. Clearing the cache means the first playback afterwards has to recompute the frames, so the timeline may stutter for a while — that is normal, and it is not a new fault.

One caution applies to every fork in this guide. Menu names change between releases, and the paths given here should be checked against the release actually installed. The official manual for the software in use is the authority for the current menu paths, and it should be read before any setting is changed. The manual was consulted through a mirror copy for this guide, so its menu paths and wording should be verified against the current official manual rather than taken as certain from the mirror.

What the Published Sources Say, and What They Do Not Prove

The published sources for this guide describe individual failures, individual machines, and individual tutorials, and none of them can be turned into a general rule. They are worth naming honestly, because a reader who only sees one of them can easily mistake a single tutorial's advice for the standard.

The Blackmagic DaVinci Resolve user manual, in its chapter on improving performance, proxies, and the render cache, describes how the Smart and User render cache pre-computes effects into the timeline, how the optimised-media option can make the export use optimised media instead of the original footage, and how the Deliver page still exports at the highest quality even when Performance Mode is on. That manual was reached through a mirror copy rather than the official Blackmagic site, so its menu paths and wording should be verified against the current official manual, and its page numbers should not be quoted.

A third-party guide on export errors describes a failure-shape table: a failure at the same timecode points at the media, effects, Fusion, or plug-ins, while failures at different positions point at the graphics card, the driver, the hardware encoder, the cache, or storage. It also describes a short-clip diagnostic export of roughly ten to thirty seconds, and a comparison export using an intermediate codec such as ProRes or DNxHR. It lists a separate shape — an export that finishes but leaves an incomplete file or a file that will not play — and that shape is not this guide's shape, which is a finished file that plays but contains visible artefacts. The two must not be mixed.

Another third-party guide on export errors states that a damaged render cache, damaged optimised media, or damaged proxies can make an export go wrong even when the timeline plays normally — direct support for this guide's shape. It gives a cache-clearing path reported as Playback, then Delete Render Cache, then All, and it suggests switching the encoder from H.265 to H.264 as a comparison, noting that some hardware encoders fail at particular 10-bit, HDR, or 4:4:4 settings. Those menu paths should be checked against the version installed.

A further third-party guide, about the software crashing during rendering, lists six causes of mid-render crashes including the graphics driver, a damaged render cache, and codec or hardware-encoder mismatches, especially with H.265. That guide is about crashes, not about artefacts in a finished file, so only its cache and encoder reasoning apply here — its crash causes are not artefact causes.

A video about a DaVinci Resolve setting that damages film grain describes a finished export with a visual defect traced to a hardware encoder preset, specifically an NVENC AV1 preset. That shows a hardware encoder setting can leave a visible defect in a completed export. It is a video source, so it carries less weight than written documentation, and it can only be written as an example, not as general guidance.

Three conflicts in the sources are set out plainly below, because glossing over them would mislead the reader. First, the in-library routing conflict: one neighbouring guide suggests that an export with artefacts in the finished file should follow the export-failure route, while the export-failure guide itself states in its own boundary section that a finished export containing artefacts, with no failure during the process, is a different shape and not its subject. The two statements do not agree, and the honest position is that no existing guide in the library covered this shape before this one. Second, comparison tests against repairs: the third-party tutorials write clearing the cache, switching to software encoding, and changing the codec as repair steps, while this library treats all three as comparison tests only, because using them permanently means losing GPU acceleration or accepting far slower exports. This guide follows the library's position. Third, an old community discussion from 2018 about preview artefacts, cited in the neighbouring preview guide, describes the preview picture going wrong and clearing when the renderer is switched to software only — that is a preview shape, not an export shape, and its driver and software version numbers are long out of date and must not be quoted in support of any export claim.

The Seven Steps

Work through these steps in order, changing one thing at a time and writing down the result after each step. A test that changes two things at once proves nothing about which change mattered, and the artefacts will return the next time only one of those conditions is present.

Step 1: Record the Baseline

Before changing anything, write down the editing software and its version, the GPU processing mode or renderer setting, the timecode where the damage appears, the shape of the damage — green screen, coloured blocks, tearing, flicker, or black frames — the export settings including format, codec, and whether hardware or software encoding was used, and whether the preview is genuinely clean. That note is the baseline every later step is compared against, and it is also the record an in-shop inspection will need.

Step 2: The Finished-File Comparison

Play the finished file three times and note whether the artefacts sit at the same timecode every time. Then play it in a different media player, and on a different computer if one is available. If the same timecode is damaged every time, the damage is in the finished file, and the fault is locked to the export path. If the file plays cleanly elsewhere, the fault is in playback decoding on the first machine, and the export investigation stops here.

Step 3: The Short-Clip Comparison Export

Copy the timeline and export a short section, roughly ten to thirty seconds around the damaged timecode. If the short clip is also damaged, the fault is narrowed to that section of the timeline. If the short clip comes out clean, the fault may sit in a layer that only appears during a full export — the load on memory, or the cache over the whole project — and the investigation moves to those layers.

Step 4: The Software-Encode Comparison

Export the same section again, this time with the software encoder, using the processor instead of the hardware encoder. If the artefacts vanish, the fault points at the hardware encoder layer. If they are still there, keep going down the steps. This is a comparison test, not a repair: software encoding is far slower, and treating it as a permanent workaround is not a fix.

Step 5: Disable Effects One at a Time, Then Isolate Sections

On the timeline, disable one effect at a time and re-export the same short section after each change. Whichever effect, when disabled, makes the artefacts disappear is the trigger condition. Then isolate the timeline section by section to find which part of it produces the damage. Change only one thing between exports, and write down the result each time.

Step 6: The Cache Comparison

Clear the render cache — reported in one third-party guide as Playback, then Delete Render Cache, then All, a path that should be checked against the version installed — disable optimised media and proxies, and re-export from the original media. If the export comes out clean, the fault points at the cache layer. If it is still damaged, the cache layer is not where the fault lives. Clearing the cache means the first playback afterwards has to recompute the frames, so the timeline may stutter for a while — that is normal.

Step 7: The Driver Comparison, Then Write the Three-Sentence Conclusion

Check the driver version against the current official release from the card manufacturer's website, and compare driver versions if the symptom began after a driver change. Then write the conclusion in three sentences: what the symptom is, which change made the symptom appear or disappear, and which possibilities are still not ruled out. That note is the record that makes any further step — including an in-shop inspection — start from evidence instead of from the beginning.

Six Common Misconceptions

Misconception 1: "The preview is clean, so nothing is wrong"

Wrong. The preview and the export are two different paths. The preview may use optimised media, lower playback resolution, and cached frames, while the export renders every frame at full quality. A clean preview proves nothing about the export, and the export-failure and preview guides both make the same point in the other direction.

Misconception 2: "Artefacts in the finished file mean the footage is ruined"

Wrong. The same file played cleanly in another player, or on another computer, proves the footage itself is intact. Until the finished-file comparison has been done, do not declare the footage damaged — the fault may be in the export path or in the playback decoding on one machine.

Misconception 3: "Switching to software encoding fixed it"

Wrong. Switching to software encoding is a comparison test that locates the fault in the hardware encoder layer. It does not repair whatever is wrong with that layer, and exporting with the software encoder permanently is far slower. The toggle is a test, not a fix.

Misconception 4: "Clearing the render cache always fixes it"

Wrong. Clearing the cache only helps when the fault sits in the cache layer. If the artefacts survive a cache clear and a re-export from the original media, the cache was not the cause. And the first playback after a cache clear has to recompute the frames, so the timeline stuttering for a while afterwards is normal, not a new fault.

Misconception 5: "An export failure and artefacts in a finished export are the same thing"

Wrong. An export failure stops the process with an error or a halted progress bar; artefacts in a finished export mean the process completed and the file itself is damaged. The failure shapes are different, the layers they point at are different, and they belong to different diagnoses.

Misconception 6: "A stronger graphics card will fix export artefacts"

Wrong. Artefacts can come from the renderer setting, an effect, the codec, the hardware encoder, or the cache — and buying a stronger card does nothing about any of those five. A faster card still runs the same renderer setting, the same effect, the same codec, and the same cache, so the artefacts would follow it. Buying a stronger card without separating the layers first spends money on a fault that may have nothing to do with the card at all.

Boundaries: Problems That Look Similar but Are Not This One

Several problems look like a damaged export but belong to other guides, and naming them here saves the reader from following the wrong diagnosis.

An export that fails partway through, with an error message or a halted progress bar, belongs with the export-failure diagnosis. A timeline preview that is itself damaged while the export comes out clean is the exact mirror of this guide, and it belongs with the preview-artifact diagnosis. A timeline that plays back slowly, with stuttering rather than visible damage, is a preview-performance shape, not an export shape, and it belongs with the preview-stutter diagnosis. Creative software that cannot find the graphics card at all — no GPU option, a greyed-out option, or work running on the processor despite the card being selected — belongs with the software-cannot-find-the-card diagnosis. And artefacts that appear while a live stream or recording is being encoded in real time belong with the live-encoding diagnosis, because real-time encoding has a deadline that a file export does not. This guide only covers the shape where the preview is clean, the export completes, and the finished file contains visible artefacts.

When to Stop and Bring the Machine In

Stop when all seven steps have been worked through, one variable at a time, and the layers still cannot be separated. Stop sooner if any step involves opening the machine or changing firmware, or if the export problem appears together with artefacts across the whole display, a burning smell, or visible damage — those belong to professional inspection.

Bring the machine in with the notes from the seven steps: the editing software and its version, the GPU processing mode or renderer setting, the damaged timecode and the shape of the damage, the export settings used, the result of the finished-file comparison, the result of the software-encode comparison, which effect, if any, cleared the artefacts when disabled, and the result of the cache comparison. That record is what makes an in-shop inspection efficient, because it shows exactly which layers were tested and which evidence each one produced.

In-store inspection takes place at Room 1209, Dali Plaza, Shek Mun. You can call 2186 8010, or reach the shop on WhatsApp at 6558 6806. Inspection is charged at the site's published three-tier fees of HK$400–2,800 (Tier 1 HK$400–780, Tier 2 HK$480–1,380, Tier 3 HK$680–2,800), with the actual price subject to a post-inspection quote. There is no home-visit service and no Mong Kok shop; inspection is carried out in the shop.

A diagnosis that ends at the stop line is not a failed diagnosis. A note that says "timeline plays clean, finished file has green blocks at the same timecode in three players, software encode clears it, cache clear made no difference" is a precise description of where the fault lives, and it is exactly what an in-shop inspection needs to start from the right place instead of from the beginning.

FAQ

The timeline plays perfectly but the finished export has green blocks — is the footage damaged?

Not proven. The same footage plays back correctly in the timeline, which argues against damage at its core. Play the finished file in a different player and on a different computer first: if it plays cleanly elsewhere, the fault is in playback decoding on the first machine. If the same timecode is damaged everywhere, the fault is in the export path, and the software-encode comparison is the next test.

The export finished without any error — how can the file still be damaged?

Because finishing and being correct are two different things. The export process can complete every step — rendering, encoding, and writing — while one of those steps introduces visible damage into the frames. An export failure stops the process with an error; artefacts in a finished export mean the process ran to the end and the file itself came out damaged.

I re-exported with software encoding and the artefacts vanished — is that the fix?

No. Software encoding is a comparison test that points at the hardware encoder layer. It is far slower than hardware encoding, and using it permanently means giving up the hardware encoder rather than finding out what is wrong with it. Note the result, then work through the effects, cache, and driver layers to find the underlying cause.

The artefacts are always at the same timecode — what does that tell me?

It tells you the fault is tied to that part of the timeline: the clip, the effects sitting on it, or the media at that point. Work through the effects one at a time, disabling each and re-exporting the same short section. If the artefacts wander to different places in each export instead, the fault points at the memory or driver layer, not at the media.

The artefacts move to a different place in every export — what does that mean?

It means the fault is not tied to any one clip or effect, and it points at a layer that varies between exports: memory pressure at full export resolution, the driver, or the render cache. Run the short-clip export and the cache comparison next, and note whether the wandering damage follows the length of the export or the cache state.

Should I clear the render cache first?

It is one of the seven steps, but it should not be the first one. Do the finished-file comparison and the short-clip export first, so you know whether the damage is in the file at all and which section it belongs to. Clearing the cache is a comparison test for the cache layer, not a general repair, and the first playback after clearing it will stutter while the frames are recomputed — that is normal.

My export uses H.265 — should I switch to H.264?

Only as a comparison test. Some hardware encoders handle particular settings — such as 10-bit, HDR, or 4:4:4 output — badly, and a third-party guide notes this as a reason to compare codecs. If switching to H.264 clears the artefacts, the fault points at the hardware encoder layer for that codec and setting. It does not prove H.264 is the correct choice for every export.

The preview is clean, so is my graphics card fine?

Not proven either way. A clean preview only shows that the lighter preview path works. The export exercises the card harder — full resolution, every effect, the hardware encoder — and a fault can live in that heavier path while the preview stays clean. The card is not proven broken, and it is not proven fine; the layers have to be separated first.

Will a stronger graphics card fix my export artefacts?

Not necessarily, and probably not on its own. Artefacts can come from the renderer setting, an effect or plug-in, the codec, the hardware encoder, or the cache — and a faster card leaves all five of those exactly where they are. Separate the layers with the seven steps before spending money on hardware, and bring the notes from those steps to an inspection if the layers cannot be separated.

If all seven steps still cannot separate the layers, what should I bring for inspection?

The notes from the seven steps: the editing software and version, the GPU processing mode or renderer setting, the damaged timecode and the shape of the damage, the export settings, the finished-file comparison result, the software-encode comparison result, which effect, if any, cleared the artefacts when disabled, and the cache comparison result. The shop is at Room 1209, Dali Plaza, Shek Mun, telephone 2186 8010, WhatsApp 6558 6806. Inspection is charged at the site's published three-tier fees of HK$400–2,800, quoted after inspection. There is no home-visit service and no Mong Kok shop.

Related articles

Related services

If you need VRAM upgrade / repair, see these service pages: