PugetBench for DaVinci Resolve
Our benchmarks are designed in partnership with hardware and software industry leaders, as well as end users and influencers who use DaVinci Resolve daily, to ensure that they are representative of real-world workflows.
Quickly Jump To: Key Features • HW Requirements • Free vs Studio • Test Breakdown • Scoring • Update Log • Legacy & Beta Versions
Blackmagic DaVinci Resolve is an industry-leading NLE, including video editing, motion graphics, VFX, and audio capabilities, and is known for its ability to leverage the power of your GPU (and multiple GPUs in some cases). From simple video cuts to advanced color grading and effects, DaVinci Resolve is used by both beginners and experienced editors.
PugetBench for DaVinci Resolve runs on top of your installed copy of Resolve, providing benchmark data directly from the application. Our benchmarks are designed in partnership with hardware and software industry leaders, as well as end users and influencers who use DaVinci Resolve daily, to ensure that they are representative of real-world workflows.
Key Features
Realistic Testing
Interfaces with DaVinci Resolve and benchmarks real-world codecs & effects.
Hardware Requirements
Windows
- DaVinci Resolve or DaVinci Resolve Studio 18.5 or newer
- Intel or AMD CPU meeting the DaVinci Resolve System Requirements
- ARM-based processors are not currently officially supported
- 16GB (Basic preset) or 32GB (Standard/Extended) of RAM recommended
- Discrete GPU with 6GB of VRAM (Basic preset) or 8GB of VRAM (Standard/Extended preset)
- Compatible with both Windows 10 & 11
- DaVinci Resolve must be installed to the default install location
- DaVinci Resolve/OS language must be set to English
MacOS
- DaVinci Resolve or DaVinci Resolve Studio 18.5 or newer
- 16GB (Basic preset) or 32GB (Standard/Extended) of RAM recommended
- MacOS 13 or newer
- DaVinci Resolve must be installed to the default install location
- DaVinci Resolve/OS language must be set to English
For accurate AI test results, we recommend launching DaVinci Resolve manually at least once after any GPU or driver changes and allowing Resolve to complete the “Optimize DaVinci Neural Engines” process.
A Note on DaVinci Resolve Free vs Studio
Blackmagic has two versions available for DaVinci Resolve – a Free version and a paid “Studio” version. In the context of benchmarking, the primary differences between these two versions is the following:
| Free | Studio | |
|---|---|---|
| Maximum GPUs | 1 | 8 |
| H.264/HEVC GPU Decoding | MacOS Only | Yes |
| H.264/HEVC GPU Encoding | MacOS Only* | Yes |
| Maximum Timeline Resolution | 4K | 32K |
| OpenFX | Limited | Yes |
| Noise Reduction | No | Yes |
| AI Features | Limited | Yes |
While the “Basic” benchmark presets can be run on either version, the lack of GPU decoding/encoding and full OpenFX and AI support limits the “Standard” and “Extended” benchmark presets to those with DaVinci Resolve Studio. In addition, if you want to test multiple GPUs, you will need the Studio version.
In general, we highly recommend using the Studio version of DaVinci Resolve for the most relevant and accurate representation of hardware performance in Resolve.
Test Breakdown
Due to the wide variety of workloads DaVinci Resolve can be used for, our benchmark is broken down into three categories:
- Encoding – performance when exporting to various codecs
- Processing – performance when working with different types of source media
- Fusion – performance for motion graphics and VFX based in the “Fusion” tab
- GPU Effects – performance for the most common GPU-accelerated OpenFX in Resolve
- AI – performance for many of the AI-based features
These tests are divided into three presets depending on what you want to test, and how in-depth you want that testing to be:
- Basic – Includes only tests that can be run in the “Free” version of DaVinci Resolve. Please note if you are using the Free version of Resolve, macOS supports hardware encoding for H.264/HEVC, while Windows is limited to Native encoding. Due to this, the Free version of Resolve is not suitable for comparing pure hardware performance between Mac and Windows machines.
- Standard – Includes all the Basic tests, and adds additional H.264/HEVC tests as well as the full “GPU Effects” test set.
- Extended – Includes all Basic/Standard tests, and adds additional codec tests and the full “AI” test set.
Currently, we are using the export/render process in DaVinci Resolve as a basis for the majority of our tests. The measured FPS is calculated based on the number of frames rendered, divided by the render time as reported by the DaVinci Resolve API. The “Runtime AI” tests are run directly through the API, with the results also reported from the API.
The breakdown for each test below includes a “Processing Type” entry that indicates what hardware is the primary contributor to performance (Hardware Encoding/Decoding, CPU, and GPU). This was determined by comparing results between an Intel Core i5 and Core i9 CPU, as well as an NVIDIA RTX __60 and RTX __80 GPU.
Encoding Tests
For evaluating the performance of your system when exporting to various codecs, our benchmark is designed to make the encoding portion of a render as big of a bottleneck as possible.
To do this, we are using a source DNxHR LB 480×270 clip, scaled up into a UHD (3840×2160) timeline. DNxHR LB is a very easy codec to process (especially at this low of a resolution), and doesn’t have hardware decoding support on any platform, making it a good baseline codec to use. In order to make sure that each pixel is unique and prevent codecs like H.264 or HEVC from getting too “smart”, we are also applying a simple fractal noise PNG image (NOT the fractal noise effect) on top of the clip to ensure that we do not have any repeating pixels.
From this UHD timeline, we export to the range of codecs we want to test encoding performance for and calculate the FPS based on how long it takes relative to the number of frames rendered. While not a 100% pure encoding test (some resources are still being used to process the DNxHR clip, scale it, and process the noise overlay), this is about as close as a pure encoding test that we can do in Resolve without getting into highly artificial setups.
In total, we are currently testing the following export codecs:
| Test Name | Codec Type | Benchmark Preset | Processing Type | Export Settings |
|---|---|---|---|---|
| H.264 50Mbps 8-bit (Hardware) UHD | LongGOP | Basic, Standard, Extended | Hardware Encoder | Format: QuickTime Codec: H.264 Encoder: Varies* Resolution: 3840 x 2160 Ultra HD Quality: Restrict to 50000 Kb/s Encoding Profile: Main Rate Control: Constant Bitrate Preset: Medium Tuning: High Quality Two Pass: Disable |
| HEVC 50Mbps 8-bit (Hardware) UHD | LongGOP | Basic, Standard, Extended | Hardware Encoder | Format: QuickTime Codec: H.265 Encoder: Varies* Resolution: 3840 x 2160 Ultra HD Quality: Restrict to 50000 Kb/s Encoding Profile: Main Rate Control: Constant Bitrate Preset: Medium Tuning: High Quality Two Pass: Disable |
| HEVC 60Mbps 10-bit (Hardware) UHD | LongGOP | Extended | Hardware Encoder | Format: QuickTime Codec: H.265 Encoder: Varies* Resolution: 3840 x 2160 Ultra HD Quality: Restrict to 60000 Kb/s Encoding Profile: Main10 Rate Control: Constant Bitrate Preset: Medium Tuning: High Quality Two Pass: Disable |
| DNxHR LB UHD | IntraFrame | Basic, Standard, Extended | CPU | Format: QuickTime Codec: DNxHR Type: DNxHR LB Resolution: 3840 x 2160 Ultra HD Use Constant Bitrate: Enabled |
| DNxHR SQ UHD | IntraFrame | Basic, Standard, Extended | CPU | Format: QuickTime Codec: DNxHR Type: DNxHR SQ Resolution: 3840 x 2160 Ultra HD Use Constant Bitrate: Enabled |
| DNxHR HQX UHD | IntraFrame | Extended | CPU | Format: QuickTime Codec: DNxHR Type: DNxHR HQX 10-bit Resolution: 3840 x 2160 Ultra HD Use Constant Bitrate: Enabled |
MacOS: Hardware
Windows w/ Studio: NVIDIA/AMD/Intel
Windows w/ Free: Native (Windows API vs Vendor-optimized APIs)
If you wish to examine the settings in more detail, you can download the export presets here.
Processing Tests
On the opposite side of encoding, we are also evaluating how fast your system is able to decode different codecs in DaVinci Resolve. We use a wide range of codecs for these processing tests at different resolutions; creating a timeline at the clip’s native resolution. We then export each timeline to DNxHR LB at HD (1920×1080) resolution with “Force debayer to highest quality” enabled, which impacts the RAW codecs in particular. Similar to the encoding tests, we standardized on DNxHR LB for the export codec as it is a very easy codec to process and doesn’t have hardware decoding support on any platform.
This method’s benchmark results are highly consistent and accurately reflect the relative performance between two systems when working with different codecs. The raw FPS results do tend to be higher than what you will see during live playback or preview since it does not include all the additional steps required for Resolve to show the video in the preview monitor, but we found that the relative performance between two CPUs or GPUs largely aligns with relative performance during live playback.
The base media we are currently testing is:
| Test Name | Codec Type | Benchmark Preset | Processing Type |
|---|---|---|---|
| 4K H.264 150Mbps 4:2:0 8-bit | LongGOP | Basic, Standard, Extended | Hardware Decoder* |
| 4K HEVC 100Mbps 4:2:2 10-bit | LongGOP | Standard, Extended | Hardware Decoder* |
| 8K HEVC 100Mbps 4:2:0 8-bit | LongGOP | Extended | Hardware Decoder* |
| 4K ProRes 422 Proxy | IntraFrame | Basic, Standard, Extended | CPU |
| 4K ProRes 422 | IntraFrame | Basic, Standard, Extended | CPU |
| 4K DNxHR LB | IntraFrame | Basic, Standard, Extended | CPU |
| 4K DNxHR SQ | IntraFrame | Basic, Standard, Extended | CPU |
| 4K Cinema RAW Light ST | RAW | Extended | CPU & GPU |
| 4K ARRIRAW | RAW | Extended | GPU |
| 5K Sony X-OCN | RAW | Extended | CPU |
| 4.6K BRAW | RAW | Basic, Standard, Extended | CPU & GPU |
| 4K RED | RAW | Basic, Standard, Extended | CPU & GPU*** |
| 8K RED | RAW | Extended | CPU & GPU*** |
** Depends on the configured “Use GPU for R3D” setting
Special thanks to those who have helped us by providing test clips!
- Linus Media Group for the 4K and 8K RED clips which were also transcoded to create the HEVC, and ProRes clips.
- Neil Purcell (Lighting Cameraman / Camera Operator) for the 4K H.264 clips from his Panasonic GH5.
GPU Effects Tests
This category of tests looks at performance for GPU-accelerated OpenFX. DaVinci Resolve is known for how well it can utilize the GPU, and for some of the tests, we apply the effect multiple times in order to stress the GPU adequately.
As a base, we are using a DNxHR LB UHD (3840×2160) clip, and export to DNxHR LB HD (1920×1080) – just like the “4K DNxHR LB” processing test. The difference here is that we also apply the following effects for each test:
| Test Name | Benchmark Preset | Processing Type |
|---|---|---|
| Temporal NR (2 Frames Better) x3 | Standard, Extended | GPU |
| Temporal NR (2 Frames Better) | Standard, Extended | GPU |
| Film Grain | Standard, Extended | GPU |
| Spatial NR (Better) | Standard, Extended | GPU |
| Lens Blur x5 | Standard, Extended | GPU |
| Lens Flare | Standard, Extended | GPU |
| Optical Flow (50% Enhanced Better) | Standard, Extended | GPU |
| Sharpen x3 | Standard, Extended | GPU |
| Color Node x30 | Standard, Extended | GPU |
Fusion Tests
Fusion is used for motion graphics and VFX workflows in Resolve, and we test performance with a variety of compositions. Each focuses on different aspects of Fusion, and performance is measured by the export performance to DNxHR LB at the same resolution as the comp.
| Test Name | Benchmark Preset | Processing Type |
|---|---|---|
| 3D Backlit Text | Basic, Standard, Extended | CPU |
| 3D Lower 3rd | Basic, Standard, Extended | CPU & GPU |
| 3D Title | Basic, Standard, Extended | GPU |
| Digital Glitch | Basic, Standard, Extended | GPU |
| Phone Composite UHD | Basic, Standard, Extended | GPU |
| Turbulant Particles | Basic, Standard, Extended | CPU |
AI Tests
The last category of tests examines the performance of the various AI-based features in DaVinci Resolve. These include effects that are applied on render (in the case of our benchmark, on export), and those processed at runtime.
The base media varies in order to effectively utilize the specific AI feature, but is designed so the media itself is a minimal bottleneck.
These tests will give low results if you do not allow Resolve to go through the process of Optimizing the DaVinci Neural Engines. For accurate results, we recommend launching DaVinci Resolve manually at least once after any GPU or driver changes, verify that neural engine optimization is enabled, and allow Resolve to complete the optimization process.
| Test Name | Benchmark Preset | Type | Processing Type |
|---|---|---|---|
| Super Scale (2x Medium) | Extended | Render | GPU |
| Face Refinement | Extended | Render | GPU |
| Person Mask (Faster) | Extended | Render | GPU |
| Person Mask (Better) | Extended | Render | GPU |
| Depth Map (Faster) | Extended | Render | GPU |
| Depth Map (Better) | Extended | Render | GPU |
| Relight | Extended | Render | GPU |
| Optical Flow (50% Speed Warp) | Extended | Render | GPU |
| Audio Transcription* | Extended | Runtime | CPU & GPU |
| Video Stabilization | Extended | Runtime | GPU |
| Smart Reframe | Extended | Runtime | GPU |
| Magic Mask Tracking (Faster) | Extended | Runtime | GPU |
| Magic Mask Tracking (Better) | Extended | Runtime | GPU |
| Create Subtitles from Audio | Extended | Runtime | GPU |
| Scene Cut Detection | Extended | Runtime | GPU |
How does the Scoring Work?
All of the scores in our DaVinci Resolve benchmark are calculated using geometric means rather than averages or performance relative to a reference result. This helps to normalize the scores so that larger or smaller results are not unfairly weighted. It also allows for the benchmark to be more flexible and better able to handle large performance shifts due to either application optimizations or the launch of more powerful hardware.
For the actual score calculations, we start by dividing the tests by codec and whether they are encoding, processing, or runtime-based tests. A score is generated for each group by taking the geometric mean of all the test results. This score is not logged and is only used behind the scenes to calculate the major scores.
Test Group Scores (not logged)
LongGOP Encoding Score = geomean (LongGOP Encoding test1, LongGOP Encoding test2, ...)
LongGOP Processing Score = geomean (LongGOP Processing test1, LongGOP Processing test2, ...)
IntraFrame Encoding Score = geomean (IntraFrame Encoding test1, IntraFrame Encoding test2, ...)
IntraFrame Processing Score = geomean (IntraFrame Processing test1, IntraFrame Processing test2, ...)
RAW Processing Score = geomean (RAW Processing test1, RAW Processing test2, ...)
GPU Effects Processing Score = geomean (GPU test1, GPU test2, ...)
Fusion Processing Score = geomean (Fusion test1, Fusion test2, ...)
AI Processing Score = geomean (AI Processing test1, AI Processing test2, ...)
AI Runtime Score = geomean (AI Runtime test1, AI Runtime test2, ...)Major Scores
The group scores are combined into the LongGOP, IntraFrame, RAW, and GPU Effects scores. For LongGOP and IntraFrame, this is done by calculating the geometric mean of the encoding and processing scores. RAW and GPU Effects scores, however, are used as-is since there are no encoding-based tests for RAW or GPU Effects. Each score is multiplied by a different scoring coefficient to bring the scores across all our benchmarks roughly in line with each other.
LongGOP Score = geomean (LongGOP Encoding Score, LongGOP Processing Score) * 0.85
IntraFrame Score = geomean (IntraFrame Encoding Score, IntraFrame Processing Score) * 0.38
RAW Score = RAW Processing Score * 0.92
GPU Effects Score = GPU Effects Processing Score * 2.3
Fusion Score = Fusion Processing Score * 3.5
AI Score = geomean (AI Processing Score, AI Runtime Score) * 1.5Overall Score
These major scores are then combined into the Overall Score using a geometric mean and multiplied by 100 to differentiate the Overall Score from the Major Scores. Currently, we do not weigh any of the major scores more than any of the others, so each contributes equally to the Overall Score.
Overall Score = geomean (LongGOP Score, IntraFrame Score, RAW Score, GPU Effects Score, Fusion Score, AI Score) * 100This method results in an Overall Score with a typical run-to-run variance of about 2-3%, and Major Scores with a variance of about 5-10% assuming there is no thermal or other performance throttling occurring on the system.. If you plan to examine individual categories or specific tests, we recommend running the benchmark at least three times and using the fastest result.
Benchmark Update Log
Version 1.0.0 (Major Update)
- Major update – Results cannot be compared to previous benchmark versions.
- Increased scoring coefficient for the Overall Scores to differentiate the score from previous benchmark versions.
- Adjusted scoring coefficient modifiers to bring the Overall Scores in-line with other 1.x PugetBench benchmarks.
- Integrated into the “PugetBench for Creators” benchmark application. The DaVinci Resolve benchmark is no longer available as a stand-alone benchmark.
- Added MacOS support.
- Support dropped for older versions of Resolve due to test requirements. 18.5 is the oldest version now supported.
- Added ability to select what hardware encoder to use for H.264/HEVC tests.
- Completely overhauled codec test sets:
- Added “Encoding” tests.
- These new tests focus on the encoding portion of an export.
- The tests are based on a DNxHR LB 480×270 clip upscaled to UHD with an image overlay to ensure each pixel is unique.
- Timeline is exported to a range of codecs at UHD.
- Current export codecs include variations of H.264/HEVC (with both software and hardware encoding), and DNxHR
- Adding “Processing” tests. These are intended to measure how good the system is at processing (decoding) different types of codecs.
- Tests are based on a timeline with a range of codecs at their native resolution with no effects.
- Timelines are exported to DNxHR LB at 1920×1080. This allows the export to be primarily bottlenecked by how fast DaVinci Resolve is able to decode the source media.
- Current source codecs include variations of H.264, HEVC, DNxHR, ProRes, BRAW, RED, Cinema RAW Light, ARRIRAW, and X-OCN.
- Note: This test is indicative of how good your system is at working with these codecs, but the FPS results tend to be higher than what you will see during live playback / preview since it does not include all the additional steps required for Resolve to show the video in the preview monitor.
- Added “Basic” benchmark preset that is limited to features included in the free version of Resolve. This includes basic codec testing and Fusion. GPU Effects and AI features are not tested.
- Added “Encoding” tests.
- Adjusted GPU Effects tests:
- Added “Optical Flow (50% Enhanced Better)”
- Added “Sharpen x3”
- Added “Color Node x30”
- Moved “Face Refinement” to AI test set
- Adjusted Fusion tests:
- Upgraded “Phone Composite” test from 1080p to UHD
- Added “Digital Glitch” test
- Added “AI” tests featuring many of the recently added features in DaVinci Resolve 18. These are divided into effects that are processed on render (playback/export) and those done during runtime.
- Changed the major scores (Live Playback, Export, Effects) to be based primarily on the codec being tested rather than the media resolution, as that is what most often dictates what type of hardware will be best for different workflows. New major scores:
- LongGOP (H.264/HEVC)
- IntraFrame (DNxHR/ProRes)
- RAW (RED/BRAW/Cinema RAW Light/ARRIRAW/X-OCN)
- GPU Effects
- Fusion
- AI
- Changed all scores to be based on the geometric mean of the individual results (or major scores in the case of the Overall Score). This method helps to normalize the scores so that larger or small results are not unfairly weighted.
Version 0.93.1
- Fixed detection of multi-CPU systems
- Preliminary support added for DaVinci Resolve (Studio) 18.
- This version of Resolve is currently in beta, and may change before the official release. Due to this, we highly recommend continuing to use the 17.x version of Resolve for any performance testing until the new version comes out of beta.
Version 0.93.0
- Added H.264 encoding support for Intel GPUs for both Standard and Extended tests
- Added string filters for system specs to remove “(C)”, “(TR)”, and “(R)” to improve consistency
- Misc bug fixes and improvements
Version 0.92.3
- Fixed bug that caused benchmark results to sometimes be uploaded when they are not supposed to
- Updated application version detection due to changes in DaVinci Resolve 17.x
Version 0.92.2
- Added support for DaVinci Resolve 17
Version 0.92.1
- Fixed tests for AMD GPUs – a few tests had incorrect names that resulted in the overall scores not being generated.
- Improved DaVinci Resolve type and version parsing in order to work with the DR 17 beta.
Version 0.92 BETA (major update)
- Complete re-wrote benchmark from the ground up.
- Complete re-vamp for the tests – results are not comparable to previous versions.
- Results are now uploaded to our online database. This is required for the free version, but opt-in if you have a license.
- Improved method used to gather system specs. This should break less often on unusual or older system configurations.
- Licensed options added.
- Status logs and configuration settings moved to “~Documents⧵PugetBench⧵DaVinci Resolve⧵TIMESTAMP”
- General bug fixes and stability improvements.
Version 0.61 BETA
- Minor update to fix issue when running the benchmark from a non C: drive
Version 0.6 BETA
- Replaced H.264 media with 150mbps footage straight from a Panasonic GH5
Version 0.5 BETA
- First release.
Legacy Benchmark Versions
Modern versions of our DaVinci Resolve benchmark are available via the PugetBench for Creators application. However, older versions of the benchmark are available as a stand-alone benchmark. Note that these versions may not have support for recent versions of Resolve.
- Ver. 0.93.1 | Download | Extended Assets
Beta Benchmark Branch
In addition to the main benchmark versions, licensed users also have access to a beta branch. This is where we trial tests, often for the purpose of taking advantage of new features that have been added into the base applications. These benchmark builds should not be compared to the main branch, as they include different tests and can have differences in how the scoring is calculated.
Current notes on the beta branch:
- No beta builds currently available