# Write

> Renders its input to files on disk (Render > Render All, F5).

| Node | Write |
|---|---|
| Menu | Input/Output › Write |
| **Names in each format** | |
| .oink comp (JSON) | `"type": "OC_N_write"` |
| .nk script | `Write` ([how .nk import works](/docs/nuke-users/nk-import)) |
| Python | `nuke.createNode("Write")` |
| Assistant (MCP) | `create_node(type="Write")` |
| Tab search | `write` |

![Write properties](/shots/nodes/write@2x.webp)

Pick the file name and file type (typing a name with an extension sets the type). Use #### or %04d for the frame number. Image types: exr, dpx, tiff, png, jpeg. Movie types: mov, mxf, webm, gif, animated webp and avif, written as one file per render. The output transform defaults by file type (movies Rec.1886, web formats sRGB).

Each frame is written to a hidden temporary file and renamed when complete, so a stopped render never leaves a half file. Frames with NaN or infinite pixels, or all black, are flagged in the render report. The proxy file is written instead when rendering with proxy. Views takes a list of views to render.

## Inputs and outputs

| Port | Name | Type |
|---|---|---|
| input 0 | Image | image |

## Knobs

Panel tab **Write**, in panel order.

| Knob | Label | Type | Default | Range / values | .nk knob | Description |
|---|---|---|---|---|---|---|
| `channels` | channels | menu | `rgb` | rgb, rgba, all | `channels` |  |
| `filepath` | file | file |  |  | `file` | Output path; #### or %04d = frame number |
| `proxy` | proxy | file |  |  | `proxy` | File written instead when rendering in proxy mode |
| `frame_mode` | frame | menu | `EXPRESSION` | EXPRESSION (expression), START_AT (start at), OFFSET (offset) | `frame_mode` |  |
| `frame` |  | text |  |  | `frame` | Expression (e.g. frame-1000), start number, or offset of the file number; empty = frame |
| `colorspace` | output transform | menu | `default` | default (default (by file type)) | `colorspace` | OCIO colorspace to write; 'default' = by file type (float=linear, dpx=compositing_log, 8/16-bit=sRGB) |
| `premultiplied` | premultiplied | bool | `false` |  | `premultiplied` | Unpremultiply around the colorspace conversion |
| `raw` | raw data | bool | `false` |  | `raw` | Write working-space values unconverted |
| `views` | views | text |  |  | `views` | Views to render (space separated); empty = every project view |
| `file_format` | file type | menu | `EXR` | EXR (exr), DPX (dpx), TIFF (tiff), PNG (png), JPEG (jpeg), MOV (mov), MXF (mxf), WEBM (webm), GIF (gif), WEBP (webp (animated)), AVIF (avif (animated)) |  |  |
| `write_ACES_compliant_EXR` | write ACES compliant EXR | bool | `false` |  | `write_ACES_compliant_EXR` | 16 bit half, no compression, rgb / rgba only, ACES chromaticities + container flag |
| `autocrop` | autocrop | bool | `false` |  | `autocrop` | Data window = the non-zero area of the image |
| `exr_datatype` | datatype | menu | `HALF` | HALF (16 bit half), FLOAT (32 bit float) |  |  |
| `exr_compression` | compression | menu | `zips` | none, zips (Zip (1 scanline)), zip (Zip (16 scanlines)), rle (RLE), piz (PIZ Wavelet (32 scanlines)), pxr24 (PXR24 (lossy)), b44 (B44 (lossy)), b44a (B44A (lossy)), dwaa (DWAA (lossy)), dwab (DWAB (lossy)) |  |  |
| `dw_compression_level` | compression level | float | `45` | 0 to 500 | `dw_compression_level` | DWAA/DWAB quality (higher = smaller, lossier) |
| `heroview` | heroview | text |  |  | `heroview` | Main view of a multi-view EXR (kept for .nk) |
| `exr_metadata` | metadata | menu | `default` | none (no metadata), default (default metadata), exr (default metadata and exr/*), noinput (all metadata except input/*), all (all metadata) | `metadata` |  |
| `noprefix` | do not attach prefix | bool | `false` |  | `noprefix` | Unknown metadata keys written as they are (else nuke/<key>) |
| `interleave` | interleave | menu | `channels, layers and views` | channels, layers and views, channels and layers, channels | `interleave` |  |
| `first_part` | first part | text |  |  | `first_part` | Layer written as the first part (interleave channels) |
| `standard_layer_name_format` | standard layer name format | bool | `false` |  | `standard_layer_name_format` | layer.view.channel for multi-view files (kept for .nk: one view per file here) |
| `write_full_layer_names` | write full layer names | bool | `false` |  | `write_full_layer_names` | Name the main layer's channels rgba.R ... instead of R ... |
| `truncateChannelNames` | truncate channel names | bool | `false` |  | `truncateChannelNames` | Channel names cut to 31 characters |
| `dpx_datatype` | data type | menu | `10` | 8 (8 bit), 10 (10 bit), 12 (12 bit), 16 (16 bit) |  |  |
| `dpx_fill` | fill | bool | `false` |  | `fill` | 10 / 12 bit filled to 16-bit words (Method A) instead of packed |
| `dpx_big_endian` | big endian | bool | `true` |  | `bigEndian` |  |
| `dpx_transfer` | transfer | menu | `auto` | auto ((auto detect)), User defined (user defined), Printing density (printing density), Linear (linear), Logarithmic (log), Unspecified video (unspecified video), SMPTE 274M (SMPTE 240M), ITU-R 709-4 (CCIR 709-1), ITU-R 601-5 system B or... | `transfer` |  |
| `tiff_datatype` | data type | menu | `8` | 8 (8 bit), 16 (16 bit), FLOAT (32 bit float) |  |  |
| `tiff_compression` | compression | menu | `zip` | none, packbits (PackBits), lzw (LZW), zip (Deflate) |  |  |
| `png_datatype` | data type | menu | `8` | 8 (8 bit), 16 (16 bit) |  |  |
| `jpeg_quality` | quality | float | `0.75` | 0 to 1 | `_jpeg_quality` |  |
| `jpeg_sub_sampling` | sub-sampling | menu | `4:1:1` | 4:1:1, 4:2:2, 4:4:4 | `_jpeg_sub_sampling` |  |
| `mov64_format` | mov format | menu | `mov` | mov (mov (QuickTime / MOV)), mp4 (mp4 (MPEG-4 Part 14)), mkv (mkv (Matroska)) |  |  |
| `mov64_codec` | codec | menu | `appr` | appr (Apple ProRes), AVdn (Avid DNxHD), AVdh (Avid DNxHR), h264 (H.264), hevc (H.265 / HEVC), av1 (AV1), vp9 (VP9), mjpa (Motion JPEG A), png (PNG), rle (Animation) |  |  |
| `mov_prores_codec_profile` | codec profile | menu | `hq` | proxy (ProRes 4:2:2 Proxy 10-bit), lt (ProRes 4:2:2 LT 10-bit), standard (ProRes 4:2:2 10-bit), hq (ProRes 4:2:2 HQ 10-bit), 4444 (ProRes 4:4:4:4 10-bit), 4444xq (ProRes 4:4:4:4 XQ 10-bit) |  |  |
| `dnxhd_codec_profile` | dnxhd profile | menu | `145` | 36 (DNxHD 422 8-bit 36Mbit), 145 (DNxHD 422 8-bit 145Mbit), 220 (DNxHD 422 8-bit 220Mbit), 220x (DNxHD 422 10-bit 220Mbit) |  | Bitrates for 29.97/30 fps; other rates use the matching VC-3 bitrate |
| `dnxhr_codec_profile` | dnxhr profile | menu | `hq` | lb (DNxHR LB 4:2:2 8-bit), sq (DNxHR SQ 4:2:2 8-bit), hq (DNxHR HQ 4:2:2 8-bit), hqx (DNxHR HQX 4:2:2 10-bit), 444 (DNxHR 444 4:4:4 10-bit) |  |  |
| `mov_h264_codec_profile` | h264 profile | menu | `420_8` | 420_8 (High 4:2:0 8-bit), 420_10 (High 10 4:2:0 10-bit) |  |  |
| `mov_hevc_codec_profile` | hevc profile | menu | `main10` | main (Main 4:2:0 8-bit), main10 (Main 10 4:2:0 10-bit), main422_10 (Main 4:2:2 10-bit) |  |  |
| `mov64_encoder` | encoder | menu | `software` | software, nvenc (NVENC (GPU)) |  | H.264 / HEVC / AV1 encoder (not in Nuke: ours) |
| `mov64_quality` | quality | menu | `High` | Low, Medium, High, Best |  | Constant quality of the long-GOP codecs (H.264 crf 18 at High), Motion JPEG, WebP |
| `mov64_limit_bitrate` | limit bitrate | bool | `false` |  |  | Encode at the bitrate knob instead of a constant quality |
| `mov64_bitrate` | bitrate | float | `28000` | 100 to 2000000 (integer) |  | kbit/s (limit bitrate on) |
| `mov64_gop_size` | gop size | float | `12` | 0 to 10000 (integer) |  | Frames between keyframes (H.264 / HEVC / AV1 / VP9); 0 = the encoder's default |
| `mov64_b_frames` | b frames | float | `0` | 0 to 16 (integer) |  | B frames between reference frames |
| `mov64_ycbcr_matrix_type` | ycbcr matrix | menu | `auto` | auto (Auto), rec601 (Rec 601), rec709 (Rec 709), rec2020 (Rec 2020) |  |  |
| `dataRange` | data range | menu | `video` | video (Video Range), full (Full Range) |  |  |
| `mov64_fps` | fps | float | `0` | 0 to 240 |  | Frame rate of the movie; 0 = the script's fps |
| `mov64_audiofile` | audio file | file |  |  |  | Audio muxed into the movie (cut to the movie's length) |
| `mov64_write_timecode` | write timecode | bool | `true` |  |  | QuickTime timecode track: the start timecode knob, else the input's timecode metadata, else the first frame number at the movie's fps |
| `mov64_timecode` | start timecode | text |  |  |  | HH:MM:SS:FF of the first frame; empty = the input's timecode, else frame / fps |
| `mov64_fast_start` | fast start | bool | `true` |  |  | Index at the start of the file (plays while loading) |
| `create_directories` | create directories | bool | `false` |  | `create_directories` | Create missing folders in the output path |
| `render_order` | render order | float | `1` | -100 to 100 (integer) | `render_order` | Writes render in ascending order when several render together |
| `first` | frame range | float | `1` | -100000 to 100000 (integer) | `first` |  |
| `last` | to | float | `100` | -100000 to 100000 (integer) | `last` |  |
| `use_limit` | limit to range | bool | `false` |  | `use_limit` |  |
| `reading` | read file | bool | `false` |  | `reading` | Nuke passes the written file downstream (kept for .nk: this Write has no output) |
| `on_error` | missing frames | menu | `ERROR` | ERROR (error), BLACK (black), CHECKERBOARD (checkerboard), NEAREST (nearest frame) | `on_error` | Read file side (kept for .nk) |
| `read_all_lines` | read all lines | bool | `false` |  | `read_all_lines` | Kept for .nk (Reads always read whole frames here) |
| `key1` | key1 | text |  |  | `key1` |  |
| `value1` | value1 | text |  |  | `value1` |  |
| `key2` | key2 | text |  |  | `key2` |  |
| `value2` | value2 | text |  |  | `value2` |  |
| `key3` | key3 | text |  |  | `key3` |  |
| `value3` | value3 | text |  |  | `value3` |  |
| `key4` | key4 | text |  |  | `key4` |  |
| `value4` | value4 | text |  |  | `value4` |  |
| `beforeRender` | before render | text |  |  | `beforeRender` |  |
| `beforeFrameRender` | before each frame | text |  |  | `beforeFrameRender` |  |
| `afterFrameRender` | after each frame | text |  |  | `afterFrameRender` |  |
| `afterRender` | after render | text |  |  | `afterRender` |  |
| `renderProgress` | render progress | text |  |  | `renderProgress` |  |

### Other knobs (Python, .nk and the assistant; not on the panel)

| Knob | Label | Type | Default | Range / values | .nk knob | Description |
|---|---|---|---|---|---|---|
| `gl_color` | Viewer Controls Color | float ×3 | `0, 0, 0` | 0 to 1 |  |  |
| `postage_stamp_frame` | Static Frame | int | `1` | -2147483648 to 2147483647 |  |  |
| `lifetimeStart` | Lifetime Start | int | `0` | -2147483648 to 2147483647 |  |  |
| `lifetimeEnd` | Lifetime End | int | `100` | -2147483648 to 2147483647 |  |  |
| `useLifetime` | Use Lifetime | boolean | `false` |  |  |  |
| `cached` | Cached | boolean | `false` |  |  |  |
| `bookmark` | Bookmark | boolean | `false` |  |  |  |
| `dope_sheet` | Dope Sheet | boolean | `false` |  |  |  |
| `clone_group` | Clone Group | string |  |  |  |  |
| `link_source` | Link Source | string |  |  |  |  |
| `link_overrides` | Link Overrides | string |  |  |  |  |
| `split_views` | Split Views | string |  |  |  |  |
| `checkHashOnRead` | Check Hash On Read | boolean | `false` |  | `checkHashOnRead` |  |
| `version` | Version | int | `0` | -2147483648 to 2147483647 | `version` | Nuke's Write version counter (.nk) |
| `last_written` | last_written | string |  |  |  |  |
| `last_check` | last_check | string |  |  |  |  |

## Knob names in .nk scripts

| .nk knob | Knob here |
|---|---|
| `file` | `filepath` |
| `_jpeg_quality` | `jpeg_quality` |
| `_jpeg_sub_sampling` | `jpeg_sub_sampling` |
| `metadata` | `exr_metadata` |
| `fill` | `dpx_fill` |
| `bigEndian` | `dpx_big_endian` |
| `transfer` | `dpx_transfer` |

Other .nk knobs use the same name here. See [.nk import](/docs/nuke-users/nk-import).


---
Sources: opencomp_core/nodes/io/write.py, opencomp_electron/src/components/properties/knobSchema.ts, opencomp_core/nodes/help/write.md, opencomp_core/nk/mapping.py