Quickly Jump To: Key Features • Hardware Requirements • Test Breakdown • Scoring • Update Log • Legacy & Beta Versions

Adobe Photoshop is one of the leading applications for photography and graphic design. It is also a critical component of many video editing, motion graphics, and VFX workflows, making it one of the most common pieces of software for content creation.

PugetBench for Photoshop runs on top of your installed copy of Adobe Photoshop, 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 Photoshop daily, to ensure that they are representative of real-world workflows.

Key Features

Test Breakdown

Our Photoshop benchmark is divided into two categories: Filter-based tests, and general performance tests. The breakdown below includes up to five categories:

• Details – basic explanation of what is being tested
• Processing Type – what type of hardware or technology is primarily being used (CPU, GPU, AI)
  • For CPU/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.
  • Note that for Photoshop, even if the task is technically GPU-accelerated, it is often still CPU bottlenecked. A more powerful GPU will not necessarily give higher performance results even for these tests, and our test flags are dependant on actual performance.
  • AI features are marked according to what Adobe has publicly declared as using Adobe Sensei technology.
• Source – either the file or history snapshot being used as a base for test
• Pre Test – information on any tasks required to set up for the main test. These steps are not timed
• Test Settings – settings used for the timed portion of the test
• Post Test – any tasks run after the test is completed. Most often, the creation of history states that are used later in the benchmark. These steps are not timed.

All testing is done in RGB color mode, at 16 bits/channel.

General Tests

File Open – RAW
Details	Times how long it takes Photoshop to open the RAW file into Photoshop
Processing Type	CPU
Source	39MB (7360×4912) .NEF RAW file from a Nikon D810 camera
Test Settings	Task: Open
Post Test	After the test is complete, creates an “Original” history snapshot for use in the other tests
Resize to 150MP – Preserve Details
Details	Resizes the image to 150MP (exact dimensions 15000×10000) using the Preserve Details sampling method
Processing Type	GPU
Source	“Original” snapshot
Test Settings	Task: Image Size – Width: 15000 pixels – Height: 10000 pixels – Resample: Preserve Details (enlargement) – Reduce Noise: 0%
Post Test	After the test is complete, creates a “150MP” history snapshot for use in the other tests
Resize to 150MP – Bicubic Smooth
Details	Resizes the image to 150MP (exact dimensions 15000×10000) using the Bicubic Smooth sampling method
Processing Type	CPU
Source	“Original” snapshot
Test Settings	Task: Image Size – Width: 15000 pixels – Height: 10000 pixels – Resample: Bicubic (smooth gradients)
Rotate
Details	Rotates the image
Processing Type	CPU
Source	“150MP” snapshot
Test Settings	Task: Image Rotation Angle: 20 degrees
Select Subject
Details	Selects the subject within a specified bounds
Processing Type	CPU, AI
Source	“150MP” snapshot
Test Settings	Task: Select->Subject – Bounds-Left: 2.3% – Bounds-Right: 30% – Bounds-Top: 34% – Bounds-Bottom: 93% – Hard Edge: True
Select and Mask
Details	Selects the subject within a specified bounds
Processing Type	CPU, GPU
Source	“150MP” snapshot
Pre Test	Task: Create Selection – Bounds-Left: 20% – Bounds-Right: 20% – Bounds-Top: 80% – Bounds-Bottom: 80%
Test Settings	Task: Select & Mask – Radius: 10px – Smooth: 10 – Feather: 2.5px – Shift Edge: 20% – Output To: Mask
Convert to Smart Object
Details	Converts 100 shape layers into a smart object
Processing Type	CPU
Source	“150MP” snapshot
Pre Test	Create and select 100 shape layers of various colors and blend modes
Test Settings	Task: Convert to Smart Object
Paint Bucket
Details	Fills an entire layer with the paint bucket
Processing Type	CPU
Source	“150MP” snapshot
Pre Test	Create a new layer. Set the foreground color to – Red: 19 – Green: 12 – Blue: 100
Test Settings	Task: Paint Bucket – Horizontal: 50% – Vertical: 50% – Tolerance: 32
Smudge Tool
Details	Runs the Smudge tool brush along a pre-defined path
Processing Type	CPU
Source	“150MP” snapshot
Pre Test	Import brush (Benchmark-Brushes.abr in photoshop assets folder) Create a rectangle work path: – Top: 20% – Left: 20% – Bottom: 80% – Right: 2080 Select brush “Benchmark Smudge 200_0_Normal_50”
Test Settings	Task: Smudge Tool – Stroke Path: Work Path
File Save – JPG
Details	Saves the main benchmark document as a JPG file
Processing Type	CPU
Source	“150MP” snapshot
Pre Test	Create an empty layer
Test Settings	Task: Export As – Format: JPG – Quality: 8
File Save – PNG
Details	Saves the main benchmark document as a PNG file
Processing Type	CPU
Source	“150MP” snapshot
Pre Test	Create an empty layer
Test Settings	Task: Export As – Format: PNG – Compression: 6
File Save – PSD
Details	Saves the main benchmark document as a PSD file
Processing Type	CPU
Source	“150MP” snapshot
Pre Test	Create an empty layer
Test Settings	Task: Save As
File Open – PSD
Details	Opens a PSD file
Processing Type	CPU
Source	“File Save – PSD” file
Test Settings	Task: Open

Filter Tests

Adaptive Wide Angle
Details	Applies Adaptive Wide Angle filter
Processing Type	CPU, GPU
Source	“150MP” snapshot
Test Settings	Task: Adaptive Wide Angle – Correction: Auto – Scale: 100%
Camera Raw
Details	Applies Camera Raw filter
Processing Type	CPU
Source	“150MP” snapshot
Test Settings	Task: Camera Raw Filter – Exposure: -0.05 – Contrast: 34 – Highlights: -18 – Shadows: 20 – Whites: -30 – Blacks: 3 – Temperature: 26 – Tint: 50 – Vibrance: 37 – Saturation: 19
Lens Correction
Details	Applies Lens Correction filter
Processing Type	CPU
Source	“150” snapshot
Test Settings	Task: Lens Correction – Setting: Auto
Content-Aware Fill
Details	Applies Content-Aware Fill to remove background objects
Processing Type	CPU
Source	“150MP” snapshot
Pre Test	Task: Create Selection – Bounds-Left: 25.2% – Bounds-Right: 81.5% – Bounds-Top: 7% – Bounds-Bottom: 40.5%
Test Settings	Task: Content-Aware Fill – Setting: Auto
Reduce Noise
Details	Applies Reduce Noise filter
Processing Type	CPU
Source	“150MP” snapshot
Test Settings	Task: Reduce Noise – Setting: Default – Strength: 5 – Preserve Details: 60% – Reduce Color Noise: 50% – Sharpen Details: 20%
Smart Sharpen
Details	Applies Smart Sharpen filter
Processing Type	GPU
Source	“150MP” snapshot
Test Settings	Task: Smart Sharpen – Setting: Default – Amount: 200% – Radius: 2 px – Reduce Noise: 10% – Remove: Lens Blur
Iris Blur
Details	Applies Iris Blur filter
Processing Type	CPU
Source	“150MP” snapshot
Test Settings	Task: Iris Blur – Blur Amount: 15 px – Location: Centered
Field Blur
Details	Applies Field Blur filter
Processing Type	GPU
Source	“150MP” snapshot
Test Settings	Task: Field Blur – Blur Amount: 15 px – Location: Centered

How does the Scoring Work?

All of the scores in our Photoshop 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 small results are not unfairly weighted and 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.

Major Scores

For the score calculations, we divide the results based on whether they are a “General” or “Filter” test. Since our scores are based on a “Higher is Better” method, each result is converted from a result in terms of time in seconds to complete (lower is better) to the performance rate (higher is better) by dividing 1 by the result (example: 1/1.17 = .855).

A score is generated for each group by taking the geometric mean of all the test performance rates and applying a scoring coefficient to bring the scores across all our benchmarks roughly in line.

General Score = geomean((1/General_Test_1), (1/General_Test_2), ...) * 250
Filter Score = geomean((1/Filter_Test1), (1/Filter_Test_2), ...) * 690

Overall 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. 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 (General Score, Filter Score) * 100

Assuming there is no thermal or other performance throttling occurring on the system, this method results in an Overall Score with a typical run-to-run variance of about 1-2%, and Major Scores with a variance of about 5%.

Benchmark Update Log

This includes updates to the benchmark itself. Changes to the desktop application are recorded on the PugetBench for Creators page.

Version 1.0.1

• Set the supported Creators app version to 1.2.0-1.2.99
• Updates to support the new Creators app version
• Added code to ensure that the “Select Subject” test is running on the local device (not cloud)

Version 1.0.0 (Major Update)

• Major update – Results cannot be compared to previous benchmark versions.
• Changing 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.
• Increased scoring coefficient for the Overall Score to differentiate the score from previous benchmark versions.
• Added scoring coefficient modifiers to bring the Overall Score in-line with other 1.x PugetBench benchmarks.
• Minimum application support changed to Photoshop 24.2 due to changes in the internal API and significant application performance optimizations.
• Added support for Apple silicon versions of Photoshop.
• Moved to Photoshop UXP API.
• Tests revamped based on new (or dropped) functionality made available via UXP. Test breakdown available here.
• Integrated into “PugetBench for Creators” benchmark application. The Photoshop benchmark is no longer available as a stand-alone Photoshop plugin.

Version 0.93.6 BETA

• Added plugin and CLI support for Photoshop 24.0
• Updated benchmark upload/view URLs to match web hosting changes
• Required application information for the CLI moved to an .ini file that resides alongside the CLI in the plugin folder. This information was previously baked into the CLI itself, but by having it in an editable file, end users can add support for things like beta and pre-release versions of Photoshop. The .ini requires the following entries:
  • Main section title: The major version of Photoshop. This is used by the CLI for the “/app_version” argument
  • prefLoc: Location of the application preferences folder
  • prefFile: Specific preferences file that needs to be adjusted for automation
  • appLoc: Path to the Photoshop application
  • appEXE: Name of the Photoshop .exe when it has been launched

Version 0.93.3 BETA

• Added CLI support for Photoshop version 23.x
• Changed CLI /app_version argument to use the Photoshop version number (22, 23,  etc) rather than the year (2021, 2022, etc)

Version 0.93 BETA

• Added support for Photoshop 2021
• Added code to handle random times when the API decides to return a string instead of a number or boolean

Version 0.92 BETA

• Moved to using node-wmi to gather system specs on Windows systems. This should be significantly faster and more reliable than the previous command line method
• Added GPU driver and motherboard BIOS to the system specs for Windows systems
• Misc bug fixes

Version 0.91 BETA

• Improved system spec gathering reliability
• System specs on MacOS now gather properly even if the system drive’s name has been changed from the default “Macintosh HD”

Version 0.9 BETA (Major Update)

• Results are now uploaded to our online database. This is required for the free version, but opt-in if you have a commercial license.
• Removed the result screen at the end of the benchmark run now that the full results can be viewed on our benchmark listing page.
• Moved from a script to a full plug-in. This was required for the result uploading, but also allows us much more flexibility for configurable settings and increases consistency between our various Adobe benchmarks.
• License validation moved from the CLI utility to the plugin itself.
• Added ability to set the location for any disk-based tests (opening and saving).
• Added tooltips for the various settings that can now be configured.
• Status logs and configuration settings moved to “~Documents\PugetBench\Photoshop\TIMESTAMP” since we cannot log directly to the plugin folder.
• Removed “Progress” text layer since this information is now reported in the plugin UI.
• Dropped photomerge tests. This was not actually used that often from what we understand, and removing it greatly reduces the download size and run times. Based on demand, we may add these tests back as an additional testing module for Photoshop.
• Scoring has been adjusted based on the test changes. Due to this, the Overall Score will not be consistent with previous versions, although the General, Filter, and GPU scores should be the same.
• General bug fixes and stability improvements.

Version 0.8 BETA (Major Update)

• Renamed benchmark to “PugetBench for Photoshop”
• Switching from “year.mon.day” version format to a more typical version scheme so that we can more easily show when things like the scoring has changed enough to not be interchangeable with previous versions.
• Dropping 8 bpc tests since there is little relative difference in performance between hardware at 8 and 16 bpc. Because of this, scores will not be 100% comparable to previous versions. They will be close enough for rough comparisons (since we aren’t changing the tests themselves), but not completely accurate.
• Verified support for Photoshop 2020
• Added motherboard and RAM speed (Windows only) to the results page
• Added a “Progress” text layer that updates automatically so you can visually see how far along the benchmark is.
• There is now a “Benchmark Results” screen that comes up at the end of the benchmark that displays a bunch of useful information including: benchmark version, cores, results for each individual test, and system information like CPU, RAM, OS, GPU, and Photoshop version
• The benchmark now also makes a jpg of the “Benchmark Results” screen for easy sharing
• Removed .csv log file support in the free edition (log files will be a feature in the commercial use version)
• Removed “start” .exe applications (automation will be a feature in the commercial use version)
• More code to ensure consistency between benchmark runs (setting the selected tool, FG/BG color, etc.)
• Miscellaneous bug fixes and improvements

Version 18.10.0

• Updated to support Photoshop CC 2019
• Added Extended mode which adds testing in 16 Bits/Channel mode
• Added Applescript applications to make running on MacOS easier

Version 18.4.0

• First release

Legacy Benchmark Versions

Modern versions of our Photoshop benchmark are available via the PugetBench for Creators application. However, older versions of the benchmark are available via ZXP plugins. Note that these versions may not have support for recent versions of Photoshop.

• Ver. 0.93.6 BETA | ZXP Plugin
• Ver. 0.93.3 BETA | ZXP Plugin
• Ver. 0.93 BETA | ZXP Plugin

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