PSD Format: Photoshop Documents & Design Workflow

Origin and purpose

PSD (Photoshop Document) is Adobe Photoshop's native file format. It was introduced with the first version of Photoshop in 1990 and has evolved continuously alongside the application. Like most application-native formats, PSD's design priority is preserving every editable element of a Photoshop project rather than optimising for delivery or interchange.

A PSD file is not really a single image. It's a project container that holds:

The full layered composition (each layer stored separately and editable).
Layer styles, blend modes, opacity settings.
Adjustment layers (curves, hue/saturation, levels, etc.) stored as parametric edits rather than baked-in changes.
Smart objects with embedded source files.
Layer masks, vector masks, clipping masks.
Selections, paths, channel data.
Type layers with editable text and font references.
Smart filters and filter masks.
Embedded ICC colour profiles.
Metadata (XMP, EXIF, copyright).
A flat composite preview for tools that don't understand layers.

The flat preview is what most non-Photoshop applications display when they "open" a PSD. The full editable structure is only accessible to Photoshop, Affinity Photo, GIMP, or other tools that implement enough of the PSD specification.

File structure

A PSD file is a binary format with four main sections:

File header — magic bytes, version, channels, dimensions, colour mode, bit depth.
Colour mode data — palette for indexed-colour PSDs, ICC profile for managed colour.
Image resources — version-specific blocks for thumbnails, paths, layer compositions, slice information, more than 150 defined resource types.
Layer and mask data — the actual layered content, individual layer pixel data, layer masks, channel data.
Image data — the flat composite, often stored last so tools can display it without parsing the layer structure.

The format supports two variants:

PSD — files up to 30,000 × 30,000 pixels and 2 GB.
PSB (Large Document Format) — extends both limits for very large compositions, used in print and special effects work.

Both variants are stored in essentially the same structure with extended addressing in PSB.

Compression

PSD supports two compression methods within layers and the composite:

Uncompressed — raw channel data.
RLE (run-length encoding) — simple lossless compression that works well on content with flat regions. Default for layer storage.
ZIP without prediction — DEFLATE-based, used in newer PSD versions for some content.
ZIP with prediction — DEFLATE with a predictor pass, slightly better compression.

The compression is lossless. PSDs are large not because of compression inefficiency but because they store every layer, every adjustment, and every editable element separately. A composition with 50 layers contains 50 stored layer images.

Why PSD files are large

A typical web banner project — final dimensions 1920×600, perhaps 20 layers, some adjustment layers — easily produces a 50–200 MB PSD file. The same content as a flattened JPEG would be 200–600 KB.

The reason: the PSD preserves every state that can be edited. Each layer's pixels are stored at full resolution even when the layer is mostly empty or covered by other layers. Smart objects contain their source files in full. Editable text references the font and renders on demand.

For a working file that may be edited again, this overhead is the entire point. For a delivered file, all that state is wasted.

Modern relevance

PSD is the de facto industry standard for layered raster image projects. Despite competition from Affinity Photo (which uses its own .afphoto format), Procreate (.procreate), and various web-based tools, PSD remains the most-asked-for delivery format when designers hand off layered files to clients or production teams.

The format matters for:

Design source files — designers' working files, kept editable for revisions.
Client deliverables — when the contract specifies "source PSDs", that's what gets delivered.
Print production handoff — PSDs go into print workflows alongside or instead of TIFF.
Texture and asset pipelines — game development and 3D rendering pipelines often consume PSDs and bake out individual layers as separate textures.
Photography retouching — non-destructive retouch workflows use PSD to preserve adjustment history.

PSD does not matter for:

Web delivery — browsers don't render PSDs.
End-user consumption — only Photoshop and a handful of other tools open them properly.
General file sharing — recipients almost certainly want a JPEG, PNG, or WebP instead.
Storage of final images — flatten and export to a delivery format.

What other tools support PSD

PSD is officially a proprietary format, but the broad strokes are well-documented and widely supported in third-party tools:

Photoshop — full native support (obviously).
Affinity Photo — opens PSDs including most layer types. Saving back to PSD is supported with some limitations.
GIMP — opens PSDs, handles most common layer types. Saves to PSD but loses some Photoshop-specific features.
Pixelmator Pro — opens PSDs with layer support.
Krita — opens PSDs, primarily for digital painting workflows.
Sketch, Figma, XD — accept PSD import for migration purposes, with varying fidelity.

What tools other than Photoshop typically cannot reproduce perfectly:

Smart filters and smart object references.
Some advanced layer styles (multiple stroke effects, complex bevel/emboss).
Adjustment layer types unique to recent Photoshop versions.
Compositions with hundreds of layers (performance degrades).
Embedded camera RAW data.

For workflows that need cross-tool fidelity, simpler PSD files (fewer layer types, no smart objects) port more reliably.

Web rendering

PSD is not a web format. No browser renders PSD natively. Files served as .psd typically prompt a download dialog.

For web display of PSD content, the workflow is:

Open the PSD in Photoshop or equivalent.
Export the relevant composition or individual layer(s) as JPEG, PNG, WebP, or AVIF.
Reference the exported file in HTML.

For automated extraction from PSD files in a content pipeline:

psd-tools (Python) — parses PSD and extracts layers as PIL images.
ag-psd (JavaScript) — pure-JS PSD reader for Node and browser.
ImageMagick — converts PSD to other formats (PSD layers can be addressed individually).
photoshop-api cloud services — for large-scale extraction without running Photoshop.

# Convert PSD's flat composite to WebP via ImageMagick
convert input.psd[0] -quality 80 output.webp

# Extract a specific layer (PSD layers addressed by index)
convert input.psd[3] -quality 80 layer-3.webp

The [0] suffix selects the flattened composite. Higher indices reference individual layers (numbering depends on layer order).

When to use PSD today

Choose PSD when:

The file is a working design document that will be edited further.
The client or downstream team has explicitly requested PSD format.
You need to preserve editable layer structure for handoff.
The project is part of a Photoshop-centric pipeline.

Choose other formats when:

The file is final and won't be edited further (export to PNG/JPEG/WebP for delivery).
The file is for web display (always; never serve PSDs directly).
The recipient doesn't have Photoshop or equivalent (most people).
File size matters for transfer or storage.

File hygiene

Working PSD files accumulate cruft over time:

Layers that were tried and abandoned but not deleted.
High-resolution smart objects when the composition is much smaller.
Multiple history snapshots embedded as layers.
Embedded fonts and resources that are no longer used.

Before archiving or handing off a PSD, flatten unused layers, replace large smart objects with rasterised versions where editability isn't needed, and run "Reduce File Size" if available. A 200 MB working PSD often reduces to 30–50 MB after cleanup with no visible loss.

For final delivery (where editing is not needed), export to TIFF (lossless, editable in many tools) or directly to a web format.