Supported Graphics Formats

Image Formats

This is the list of image file formats supported internally by Blender:

Format Channel Depth Alpha Metadata DPI Extensions
BMP 8bit .bmp
Iris 8bit .sgi .rgb .bw
PNG 8, 16bit .png
JPEG 8bit .jpg .jpeg
JPEG 2000 8, 12, 16bit .jp2 .jp2 .j2c
Targa 8bit .tga
Cineon & DPX 8, 10, 12, 16bit .cin .dpx
OpenEXR float 16, 32bit .exr
Radiance HDR float .hdr
TIFF 8, 16bit .tif .tiff

Hint

If you are not interested in technical details, a good rule of thumb for selecting output formats for your project is:

Use OpenEXR
if you intend to do compositing or color-grading on these images.
Use PNG
if you intend on-screen output or encoding into multiple video formats.
Use JPEG
for on-screen output where file size is a concern and quality loss is acceptable.

All these formats support compression which can be important when rendering out animations.

Note

Quicktime

On macOS, Quicktime can be used to access file formats not natively supported (such as GIF).

Channel Depth

Image file formats support a varying number of bits per pixel. This affects the color quality and file-size.

Commonly used depths:

8 bit (256 levels)
Most common for on-screen graphics and video
10, 12, 16 bit (1024, 4096, 65536 levels)
Used for some formats focusing on photography and digital films (such as DPX and JPEG 2000).
16 bit half float
Since full 32bit float is often more than enough precision, half float can save drive space while still providing a high dynamic range.
32 bit float
Highest quality color depth.

Internally Blender’s image system supports either:

  • 8 bit per channel (4 x 8 bits).
  • 32 bit float per channel (4 x 32 bits) - using 4x as much memory.

Images higher than 8 bits per channel will be converted into a float on loading into Blender.

Note

Floating point is often used for HDRI,

When an image has float colors, all imaging functions in Blender default to use that. This includes the Video Sequence Editor, texture mapping, background images, and the Compositor.

Export

Save As Render
ToDo.
Copy
The Copy checkbox will define if the data-block will reference the newly created file or the reference will be unchanged, maintaining it with the original one.

Format Details

Cineon & DPX

Cineon is Kodak’s standard for film scanning, 10 bits/channel and logarithmic. DPX has been derived from Cineon as the ANSI/SMPTE industry standard. DPX supports 16 bits color/channel, linear as well as logarithmic. DPX is currently a widely adopted standard used in the film hardware/software industry.

DPX as well as Cineon only stores and converts the “visible” color range of values between 0.0 and 1.0 (as a result of rendering or composite).

OpenEXR

ILM’s OpenEXR has become a software industry standard for HDR image files, especially because of its flexible and expandable structure.

An OpenEXR file can store multiple layers and passes. This means OpenEXR images can be loaded into a compositor keeping render layers, passes intact.

Output Options

Available options for OpenEXR render output are:

Color Depth

Saves images in a custom 16 bits per channel floating point format. This reduces the actual “bit depth” to 10 bits, with a 5 bits power value and 1 bit sign.

Float (Half), Float (Full)

Codec
PIZ
Lossless wavelet compression. Compresses images with grain well.
ZIP
Standard lossless compression using Zlib.
RLE
Run-length encoded, lossless, works well when scanlines have same values.
PXR24
Lossy algorithm from Pixar, converting 32 bits floats to 24 bits floats.
Z Buffer
Save the depth information. In Blender, this now is written in floats too, denoting the exact distance from the camera in “Blender unit” values.
Preview
On rendering animations (or single frames via command line), Blender saves the same image also as a JPEG, for quick preview or download.

Radiance HDR

Radiance is a suite of tools for lighting simulation. Since Radiance had the first (and for a long time the only) HDR image format, this format is supported by many other software packages.

Radiance (.hdr) files store colors still in 8 bits per component, but with an additional (shared) 8 bits exponent value, making it 32 bits per pixel.