The OpenEXR file (.exr)

An EXR file stores an image as numbers that describe light, not as colours ready for a screen. Industrial Light & Magic developed the format in 1999 because its own file format held 8 bits per channel, too few for visual effects work, where images are brightened, darkened and combined many times over. ILM released OpenEXR as open source in 2003, it became a project of the Academy Software Foundation in 2019, and it's now the standard interchange format for rendered and composited images in film, TV and animation.

Where a PNG or JPG stops at white, an EXR pixel can be 0.001 or 500. That lets a compositor change the exposure, add motion blur or glow, or grade the colours long after rendering, without running out of detail at either end. A single file can also hold many images at once: the beauty render plus separate passes for lighting, reflections, depth or object IDs.

Three things an EXR file is not:

• Not a finished picture. An EXR is a working file. Its values are meant to be converted for a particular display, so it can look wrong when opened as-is (see below).
• Not a web format. No browser displays EXR, and the files are large. Export a JPG or PNG to show the result.
• Not the same as an "HDR photo" from a phone. Those are JPEG or HEIC files made for HDR screens. Radiance HDR files are a different, older high-dynamic-range format.

Most EXR files store each channel as a half: a 16-bit floating-point number with 1 sign bit, 5 exponent bits and 10 fraction bits. A half can hold values from about 0.00006 up to 65,504, and every doubling of brightness gets 1,024 steps. For comparison, an 8-bit sRGB image has 256 levels in total. Halves take half the space of 32-bit floats and are precise enough for colour, so 32-bit float is kept for data such as depth or positions.

The values are usually scene-linear: proportional to the amount of light in the scene. Twice the light gives twice the number. A mid-grey card might be about 0.18 and a lamp 50 or more. A screen can't show that directly; software has to apply a view transform (an sRGB curve, a film-like tone curve, or an ACES output transform) to turn light into display colours.

Channels have names, not fixed positions. R, G, B and A are the main image; render passes are named with a prefix, such as diffuse.R or specular.G, and grouped into layers by applications. That's what people mean by a multilayer EXR.

The flags in the version field say which kind of EXR a file is. Readers that only handle the first kind are still common, which explains many "can't open" errors.

Multi-part files differ from a multilayer single-part file: a single-part file can hold dozens of channels, but every channel must be read together. Parts can be read one at a time, which saves time when a compositor needs only the beauty pass.

Every part of an EXR names one compression method. Some are lossless, some lossy, and they differ a lot in speed and file size. The number in brackets is the value stored in the compression attribute.

OpenEXR 3.5, released in September 2026, added lossless Zstandard compression and a lossy method based on HTJ2K. The OpenEXR project notes that files with lossy HTJ2K written by versions 3.5.0 and 3.5.1 lack a lookup table that 3.5.2 adds, and recommends regenerating them.

An EXR stores numbers, and the file doesn't force a meaning on them. Most EXRs hold scene-linear values with the same red, green and blue primaries as sRGB (often called linear Rec.709), but the same structure can hold ACES colour, camera log footage, depth in metres or anything else. An optional chromaticities attribute can record the primaries; many files leave it out, and studios rely on naming conventions and colour management (usually OpenColorIO) instead.

ACES, the Academy Color Encoding System used for film and TV mastering, defines an archive and interchange file based on EXR: the ACES image container (SMPTE ST 2065-4). It's a constrained EXR, registered as image/aces with the extension .exr. According to its IANA registration it is uncompressed and starts with 76 2F 31 01 02 00 00 00 or 76 2F 31 01 02 04 00 00, and an acesImageContainerFlag attribute is set to 1. Its values are linear ACES2065-1, a colour space with very wide primaries.

• It looks too dark, with harsh contrast. The viewer showed linear values as if they were display values. A mid-grey of 0.18 should appear at about 46% brightness (118 out of 255) after the sRGB curve, but without it, it's shown at 18%. Use a viewer that applies a view transform, set the image's colour space to linear in your application, or convert with a colour-managed tool.
• It looks flat and washed out. The file probably holds log-encoded footage (ACEScct, LogC and similar), or a program applied an sRGB curve to values that already had one. Tell the application the correct input colour space.
• Colours look dull. ACES2065-1 values are being read as sRGB primaries. Set the input to ACES2065-1 (or ACEScg, if that's what the renderer wrote).
• Highlights are a flat white. Values above 1.0 clip on a normal screen. Lower the exposure in the viewer, or apply a tone curve, to see the detail that's there.
• The image is black or transparent. Possible causes: an alpha of 0 with premultiplied colour, a data window that doesn't overlap the display window, or the viewer showing a data pass or the wrong part of a multi-part file. List what's inside with oiiotool --info -v file.exr (OpenImageIO) or exrheader file.exr (from OpenEXR's tools).
• It won't open at all. The application may not support deep data, multi-part files, tiles or a newer compression method such as HTJ2K. Re-save it from a current tool as a single-part scan-line file with ZIP compression.

• Compositing and editing: Nuke, DaVinci Resolve, After Effects and Blender's compositor read EXR with all its layers.
• Painting and retouching: Photoshop opens EXR in 32-bit mode; layered EXRs need a plug-in such as EXR-IO to come in as separate layers. Krita, Affinity Photo and GIMP (since 2.10) also open EXR files.
• Rendering: Blender, Houdini, Maya, 3ds Max and most renderers write EXR, including multilayer files with every render pass.
• Just looking: free HDR viewers such as tev show EXRs with exposure control and let you flip through channels.

To turn an EXR into an ordinary picture, apply a view transform first, so that it looks the way it did in the application. On the command line, OpenImageIO (pip install OpenImageIO) can do it:

# inspect: size, channels, compression, metadata
oiiotool --info -v render.exr

# linear EXR to an 8-bit sRGB PNG (values above 1.0 clip)
oiiotool render.exr --tocolorspace sRGB -d uint8 -o render.png

# a PNG or JPEG into a linear half-float EXR
oiiotool photo.png --colorconvert sRGB linear -d half -o photo.exr

Converting a photo to EXR doesn't add dynamic range: the highlights a JPEG clipped stay clipped. Real HDR content comes from renders, RAW photos, bracketed exposures merged together or cinema cameras.

EXR files contain no scripts or macros. The risks are those of any complex binary format:

• Parser bugs. The OpenEXR library is continuously fuzz-tested, and its releases regularly fix memory-safety bugs found that way; version 3.5.0 alone fixed four. Keep applications and libraries that read EXR up to date, especially on servers that process uploads.
• Huge declared sizes. A small file can declare an enormous data window or many channels. Check the dimensions and channel count before decoding uploaded files.
• Metadata travels along. The header can hold any attribute. Renderers and compositors often add their own, which can include file paths, machine names, project names or the software that made it. Check with oiiotool --info -v before sending files outside your organisation.