AEP File Format Specification¶

This page describes the binary After Effects project format (.aep): how the file is laid out, what every chunk holds, and the rules a program must follow to write a file After Effects opens. It is the reference behind py_aep's binary layer, but it is written for anyone who needs to read or write .aep files. The CLI tools aep-inspect and aep-compare print a file's chunk tree and diff two files chunk by chunk, which is the quickest way to follow along.

The format is undocumented by Adobe. Everything here was reverse-engineered from files After Effects writes - the py-aep sample corpus of about 1,350 projects saved by After Effects CC 2018 to AE 2026 on Windows and macOS - and from After Effects' behaviour when it opens, resaves and renders files crafted to differ in one field. Unless a section says otherwise, the description matches AE 2026 (file version 97). Fields nobody has decoded are listed as Unknown, with the values the samples show; meanings that rest on inference rather than a test are marked (inferred).

The XML variant of the format (.aepx) and the other RIFX files After Effects writes (keyframe clipboards, favourites, templates) are out of scope.

Conventions¶

Byte order and types¶

The file is big-endian. A handful of chunks, and a few fields inside big-endian chunks, are written little-endian; their type carries an LE suffix (see Little-endian data).

Offsets are hexadecimal from the start of the chunk body, lengths are decimal byte counts. Bits are numbered from the least significant (bit 0 = mask 0x01).

Times and rates¶

After Effects stores most times as a rational pair - a dividend and a divisor, seconds = dividend / divisor - and most frame rates as fixed 16.16. Keyframe times are integers in the time base of the layer that owns the property (its tdb4 time base, see tdb4). Durations of 600ths of a second also appear (markers).

Version notation¶

"AE 2022", "AE 23" ... name After Effects releases. "File version 93.43" names the major.minor pair stored at the start of head (see File versions).

File structure¶

An .aep file is a single RIFX chunk followed by an XMP packet:

Chunks¶

Every chunk has an 8-byte header and a body:

Most chunks hold data, laid out per tag as documented on this page; the others are containers whose body is a sequence of chunks.

LIST¶

A LIST chunk groups chunks. Its body starts with a four-character list type that says what the list is, followed by the child chunks:

This page names lists by their type: LIST:Item is a LIST chunk whose list type is Item. The root RIFX chunk has the same layout with list type Egg!.

One list breaks the rule: LIST:btdk (a text document) holds raw bytes after its list type instead of chunks.

Wrapper chunks¶

Five tags are containers without a list type: their body is a chunk sequence - in practice a single Utf8 - and the tag says what the string is.

tdsn¶

A property's display name, in LIST:tdgp and LIST:tdbs. AE writes -_0_/- for a property that has not been renamed; its name then comes from the match name. py_aep: TdsnChunk

pdnm¶

An effect parameter's name, or a popup's items separated by |, in LIST:parT. py_aep: ContainerChunk

fnam¶

The match name of an effect instance, in LIST:sspc. py_aep: ContainerChunk

vfdn¶

A variable font axis name (e.g. Font Axis Weight), after the stream of an ADBE Text VF Axis property in a text animator (AE 26 on). py_aep: VfdnChunk

The fifth, RCom, holds a render-queue item's comment.

Utf8¶

A UTF-8 string: the whole body, with no length prefix, no terminator and no BOM. An empty body is an empty string.

Parent: many lists · Size: variable · py_aep: Utf8Chunk

Most strings are Utf8 chunks placed right after the chunk they belong to: an item's name after its idta, a layer's name after its ldta, a property stream's expression in its LIST:tdbs, and the JSON payloads that follow the colour management flags (pcms, PwCs, pdvc, mcsp, Mcsp, ocsp, hdrm). Two strings are not Utf8 chunks: wsnm is UTF-16LE and cmta is a NUL-terminated UTF-8 chunk.

Little-endian data¶

These chunks are little-endian as a whole: CsCt, EfDC, dwga, idpc, idpi, iide, linl, mrid, sfid, StVS, strt, btov, mtov, mdlv and mdld. Little-endian fields also sit inside big-endian chunks (shph at 0x14, tdb4 at 0x3C, NmHd at 0x10), in orientation values (LIST:otst), and in some plug-in payloads (the OpenEXR opti and Ropt). Each table marks them.

How After Effects reads a file¶

These rules come from opening files with one chunk removed, moved or added (AE 2026). They are what makes chunk order matter:

• AE reads the children of a list by tag, scanning forward from the last chunk it read. A chunk it does not know is skipped: an unknown tag inside a LIST:Item opens fine.
• Most chunks are required. When one is missing AE refuses the file with "missing data in file". This also happens when a required chunk is present but out of order: placing cdrp before cdta hides it from the forward scan, so AE reports it missing.
• Some chunks are optional and AE falls back to a default (a viewer's missing ppSn reads as 0.0).
• Some optional chunks end the scan when they are missing: without otln, AE also loses the seq, LIST:LSIf and ppSn chunks that follow it in the same list.
• A few chunks are verified: without linl in a footage colour list, AE stops with an "internal verification failure".

A writer should therefore emit chunks in exactly the order After Effects does, never drop a chunk it does not understand, and may add chunks of its own (they are skipped). AE also regenerates some purely visual state: the root LIST:LSIf and LIST:PTRE panel records can be left out of a new file.

File versions¶

The first four bytes of head hold the file version, a u2 major and a u2 minor. After Effects refuses a file whose major is higher than its own - AE CC 2018 opening a file stamped for AE 2022 reports: "The file you are attempting to open was created with After Effects version 22.0 (Windows 64) and cannot be opened with this version".

From AE 2022 on, the major is the release number plus 71. The minor differs between builds of one release (AE 26.0 writes 97.2, later 26.x builds 97.7). After Effects decides which chunks to read - and what size some of them have - from the full version, so a writer must stamp the version of the release whose layout it writes. Version-dependent layouts are noted where they occur, for example ldta: 160 bytes before AE 23, 164 from AE 23. Every After Effects release refuses a composition whose layer records are 164 bytes in a file stamped 93.x ("chunk in file too big").

svap¶

Parent: root · Size: 4 bytes · py_aep: SvapChunk

AE does not use it to decide whether it can open the file.

head¶

The file header: file version, the saving application, the next item id.

Parent: root · Size: 20 bytes · py_aep: HeadChunk

The build word packs the version of the After Effects that saved the file:

For AE 26.0x67 on Windows the word is 0x0F100643. The OS bits only record where the file was saved: AE rewrites them on every save and opens files stamped for the other platform.

nhed¶

A compact copy of some project settings; it mirrors nnhd.

Parent: root · Size: 32 bytes · py_aep: NhedChunk

AE keeps the shared fields of nhed and nnhd equal; a writer should update both.

nnhd¶

Project settings: time display, frame counting, colour depth.

Parent: root · Size: 40 bytes · py_aep: NnhdChunk

Root chunk order¶

The children of the root, in the order After Effects writes them (bracketed chunks are optional). This order holds across every AE 2022-2026 sample:

XMP packet¶

After the RIFX chunk, the file ends with an XMP packet in UTF-8 (<?xpacket begin="..." id="W5M0MpCehiHzreSzNTczkc9d"?> ... <?xpacket end="w"?>) carrying the project's metadata, including an editing history that AE extends on every save. Its length is not recorded anywhere: it runs to the end of the file. The packet is optional - AE opens a file that ends with the RIFX chunk.

Project settings and colour management¶

Between the file header chunks and the item tree, and again after it, the root of every .aep holds a run of small project-level chunks: the Project Settings (audio sample rate, GPU renderer, expression engine, colour management), a few bookkeeping ids (the Solids and Media Replacement folders, the active item, Essential Graphics panel state), an ICC profile pool, and Project panel state that AE regenerates. Most are fixed-size chunks. Colour settings follow a common pattern: a 1-byte marker chunk immediately followed by a root-level Utf8 chunk holding JSON, described in Root-level settings strings and Colour-profile envelope.

Multi-byte integers are big-endian except in sfid, mrid and dwga, which AE writes little-endian. "Required" below means AE refuses to open a project that lacks the chunk ("missing data in file"); because AE finds root chunks by scanning forward (see the reading rules in the overview), these chunks must also keep the order AE writes them in:

"Written by" is the oldest AE whose samples contain the chunk (the corpus holds CC 2018 = 92.14 files and AE 2022-2026 files) or, where known, the file-version gate. A writer targeting an older file version should leave out the chunks newer than it.

A new project saved by AE 2026 (File > New, then Save) contains: adfr = 48000, empty LIST:Pefl, qtlg = 0, LIST:gpuG = CUDA on Windows, LIST:sfnm = "Solids" with sfid 0, mrid 0, acer 1, empty LIST:CPPl, cpid = FF x 16, no lnrb/lnrp, dwga 1, settings JSON {"lutInterpolationMethod":1}, {} after PwCs and pdvc, expression engine javascript-1.0, workspace "Default", fcid 0, oacc 0, and a zero-filled ftwd.

adfr¶

Project audio sample rate (File > Project Settings > Audio).

Parent: root · Size: 8 bytes · py_aep: F8Chunk

LIST:Pefl¶

The effects used in the project, one match name per child.

Parent: root

In AE-written files the entries are unique and sorted by byte value, and they match the effects applied on layers (exactly, in all but 25 of about 1,360 samples; the exceptions leave out pseudo-effects such as the Dropdown Menu Control, or list an effect that has no ordinary layer instance, e.g. ADBE FreePin3). Files whose list does not match the effects in use open normally, so a writer can leave it empty. Up to 98 entries in the samples.

pjef¶

One effect match name, e.g. ADBE Gaussian Blur 2 or S_BlurDirectional.

Parent: LIST:Pefl · Size: variable (5-31 bytes in samples) · py_aep: Utf8Chunk

qtlg¶

Legacy QuickTime gamma flag.

Parent: root · Size: 1 byte · py_aep: U1Chunk

LIST:gpuG¶

The project's GPU renderer (File > Project Settings > Video Rendering and Effects; Project.gpuAccelType).

Parent: root

The gpuAccelType column is what AE 2026 reports for a project holding the GUID, whether or not the machine can use that renderer. Setting gpuAccelType to a renderer the machine lacks silently stores the default one instead (AE 2026 with only CUDA and Software available saved the CUDA GUID for OpenCL, Metal, Vulkan and DirectX).

The value is not rewritten when the project is saved on another platform: a Metal project saved by Windows AE keeps the Metal GUID.

LIST:sfnm¶

The Solids folder: its name and its item id.

Parent: root

sfid¶

Item id of the Solids folder.

Parent: LIST:sfnm · Size: 4 bytes · py_aep: U4LeChunk

Measured on AE 2026: a new solid goes into the folder with this id even after that folder was renamed or moved. When the id is 0 or names no folder, AE uses a root-level folder whose name equals the LIST:sfnm name, and otherwise creates one and records its id here.

mrid¶

Item id of the "Media Replacement Comps" folder, the folder AE files the compositions it creates for Essential Graphics media replacement into.

Parent: root · Size: 4 bytes · py_aep: U4LeChunk

Written and read for file versions above 93.18 (AE 2020, which added media replacement, saves 93.22); the CC 2018 samples do not have it.

acer¶

"Compensate for Scene-referred Profiles" (File > Project Settings > Color; Project.compensateForSceneReferredProfiles).

Parent: root · Size: 1 byte · py_aep: U1Chunk

LIST:CPPl¶

The project's ICC profile pool: each ICC profile that a 16-byte profile ID elsewhere in the project refers to, stored once.

Parent: root

The list is present, often empty, in every sample. Entries are unique and sorted by ascending profile ID (all 14 samples with more than one entry). Ids that refer into the pool:

• cpid: in CC 2018 files, the working space lives only here. From AE 2022 on, the working-space ICC is embedded in the PwCs envelope instead (the one AE 2024 sample has it in both places; AE 2025 and 2026 samples only in the envelope).
• The footage profile ids in LIST:CLRS: every embedded (epid) and assigned (apid) profile in CC 2018 files; in AE 2022+ files the embedded profiles (epid, all but one sample), while the assigned profiles travel as envelopes.

AE keeps entries nothing refers to any more (old projects carry dozens of monitor profiles such as "iMac" or "Display"; up to 144 entries).

pprf¶

One ICC profile of the pool.

Parent: LIST:CPPl · Size: variable (508-60,988 bytes in samples) · py_aep: untyped (raw Chunk)

cpid¶

Profile ID of the project working space.

Parent: root · Size: 16 bytes · py_aep: CpidChunk

In every AE 2022+ sample with an ICC working space (699 files) it equals the profile ID of the ICC embedded in the PwCs envelope; with {} or an OCIO envelope it is FF x 16. In CC 2018 files it names a pprf entry of LIST:CPPl: AE 2026 reports the working space "sRGB IEC61966-2.1" for the CC 2018 sample whose cpid names the sRGB entry, and "None" for the CC 2018 File > New sample (FF x 16). AE 2026 rewrites cpid when a script sets workingSpace (to 33bc7f1c156fa0d72f8f717ae5886bd4 for "Adobe RGB (1998)", to FF x 16 for "None"), without adding a pprf; keep it consistent with PwCs. Present in every sample; write it in every file (inferred: when it is missing, AE also misses the root chunks that follow it).

Working spaces seen in samples:

lnrb¶

"Blend Colors Using 1.0 Gamma" (Project.linearBlending). Present only when the setting is on.

Parent: root · Size: 1 byte · py_aep: U1Chunk

The setting is the chunk's presence, not its value. Its slot is right after cpid and before lnrp/dwga; placed anywhere later (for example at the end of the root) AE's forward search finds it there and then reports missing data for the chunks it skipped.

lnrp¶

"Linearize Working Space" (Project.linearizeWorkingSpace). Present only when the setting is on.

Parent: root · Size: 1 byte · py_aep: U1Chunk

Same rules as lnrb; it comes after lnrb when both are present.

dwga¶

Working gamma (File > Project Settings > Color; Project.workingGamma).

Parent: root · Size: 4 bytes · py_aep: DwgaChunk

pcms¶

Marker for the colour-management settings: the next root chunk is a Utf8 holding the settings JSON.

Parent: root · Size: 1 byte · py_aep: U1Chunk

Written by AE 2022 and later, together with PwCs.

Colour-management settings JSON¶

One compact JSON object (no whitespace), keys in alphabetical order. A key whose value is the default is omitted (0 or empty string in every sample pair that differs in one setting), so the object is {} when every setting is at its default and two files can show disjoint key sets, e.g. {"colorManagementSystem":1,"ocioConfigurationFile":"ACES 1.2"} and {"graphicsWhiteLuminance":203,"lutInterpolationMethod":1}. Readers must apply the defaults for absent keys.

The AE 2022 sample stores only lutInterpolationMethod; ocioConfigurationFile first appears in the AE 2023 sample and graphicsWhiteLuminance in AE 2025 files.

Unsampled colour flags¶

AE can also write two more 1-byte chunks in this run, pcsa (after the settings Utf8) and psac (after the working-space Utf8). No sample contains either and their meaning is not known; a reader should skip them, a writer should not write them.

PwCs¶

Marker for the project working colour space (Project.workingSpace): the next root chunk is a Utf8 holding a colour-profile envelope.

Parent: root · Size: 1 byte · py_aep: U1Chunk

The following Utf8 holds:

• {}: no working space ("None"), in either mode.
• an ICC envelope (baseProfileType 2) in Adobe mode: the full working space profile is embedded, and colorProfileName (its desc text) is what Project.workingSpace reports. cpid holds its profile ID.
• an OCIO envelope (baseProfileType 3) in OCIO mode, of any selection kind; Project.workingSpace reports its colorProfileName, e.g. ACES/ACEScg yo for a direct pick.

Written by AE 2022 and later; AE reads it only from file versions above 93.34. Projects from earlier versions keep their working space in LIST:CPPl via cpid.

pdvc¶

Marker for the project display colour space (File > Project Settings > Color, OCIO mode; not exposed to ExtendScript): the next root chunk is a Utf8 holding a colour-profile envelope.

Parent: root · Size: 1 byte · py_aep: U1Chunk

The following Utf8 is {} in Adobe mode (the display uses the operating system's monitor profile, which is not stored) and when the OCIO display is None; otherwise an OCIO display + view envelope, e.g. colorProfileName ACES/sRGB with data {"colorSpace1":"ACES","colorSpace2":"sRGB","ocioColorSpaceType":1}. No other envelope type occurs here. Written by AE 2023 and later (absent from the AE 2022 sample).

LIST:ExEn¶

The expression engine (File > Project Settings > Expressions; Project.expressionEngine).

Parent: root

Absent from the CC 2018 samples: the JavaScript engine arrived in AE 16.0 (CC 2019). A project without it uses the ExtendScript engine (inferred).

wsns¶

Byte length of the workspace name in wsnm.

Parent: root · Size: 2 bytes · py_aep: WsnsChunk

wsnm¶

Name of the UI workspace that was active when the project was saved.

Parent: root · Size: variable (0-24 bytes in samples) · py_aep: WsnmChunk

A root Utf8 with the same name in UTF-8 follows it (identical in every sample). Samples hold Default, Standard, Small Screen and the French Par défaut; 121 samples have an empty name (wsns 0, empty wsnm, empty Utf8).

fcid¶

The project's active item (Project.activeItem).

Parent: root · Size: 4 bytes · py_aep: U4Chunk

AE writes 0 once the active item is deleted. An id that names no item is tolerated: AE opens the project with nothing active.

oacc¶

Count of ocid chunks that follow. Essential Graphics panel state (inferred: the compositions open in the panel).

Parent: root · Size: 2 bytes · py_aep: U2Chunk

When the count is not 0, one acid follows, then oacc ocid chunks; with 0 neither is written.

acid¶

A composition id for the Essential Graphics panel (inferred: the composition the panel shows).

Parent: root · Size: 4 bytes · py_aep: untyped (raw Chunk)

Present only when oacc > 0, directly after it. It is not the active item: in both samples fcid names a different composition.

ocid¶

One composition id of the Essential Graphics panel list (inferred: a composition open in the panel).

Parent: root · Size: 4 bytes · py_aep: untyped (raw Chunk)

Repeated oacc times after acid.

LIST:PTRE¶

Project panel view state (inferred from the tag name).

Parent: root (last chunk before the XMP trailer)

Present in every sample, but optional: AE 2026 opens a project without it and writes a fresh one on the next save.

LIST:CTRE¶

A second panel-state list with the same content as LIST:PTRE, seen once, inside a LIST:FEE of a CC 2018 production project.

Parent: LIST:FEE

ftwd¶

Panel view state record. All zeros in 1,359 of the 1,362 records in the samples; write 56 zero bytes.

Parent: LIST:PTRE, LIST:CTRE · Size: 56 bytes · py_aep: untyped (raw Chunk)

Root-level settings strings¶

Four Utf8 chunks sit directly under the root, each identified by the chunk just before it (no other root-level Utf8 occurs in the samples):

The other project-setting strings are inside lists: LIST:gpuG (GPU renderer), LIST:sfnm (Solids folder name) and LIST:ExEn (expression engine). Find each JSON by its marker, never by position or content: an unset slot holds a literal {}, so "the first envelope in the file" is the display space whenever the working space is unset.

Colour-profile envelope¶

AE stores a colour space as text in one JSON shape, the colour-profile envelope, always in a Utf8 chunk that follows a marker chunk: the project working space (PwCs), the project display colour space (pdvc), and the footage colour slots of LIST:CLRS (mcsp/Mcsp: the colour space the media itself carries; ocsp: the colour space assigned to the footage). Output modules (LIST:LOm) store no envelope, only a 16-byte id (see Profile IDs).

{"baseColorProfile":{"colorProfileData":"<base64>","colorProfileName":"<name>"},"baseProfileType":<n>}

• Compact JSON (no whitespace), keys in exactly this order (alphabetical).
• colorProfileData is standard base64 with = padding.
• {} means the slot is unset.
• No sample has a non-ASCII name, so how AE escapes one is not verified.

Profile types¶

An embedded ICC profile is stored as-is: its own profile-ID field (bytes 84-99) is zero in most samples and equals the computed ID in the rest. Working-space profiles can be large (50,152 bytes for ACEScct).

OCIO selections¶

The baseProfileType 3 data is a compact JSON object with, in this order, colorSpace1 (string), colorSpace2 (string, display + view only) and ocioColorSpaceType (1 = display + view, 2 = role or alias, absent for a direct pick). Which bytes AE writes depends only on what kind of name was picked from the OCIO configuration:

Examples from samples: ACES/ACEScg yo + {"colorSpace1":"ACEScg yo"} (colour space ACEScg yo of family ACES); role mari_int16 stored as sRGB (mari_int16) + {"colorSpace1":"sRGB (mari_int16)","ocioColorSpaceType":2}; sRGB yo/Un-tone-mapped yo (display + view).

• The rule holds for every slot (working space, display, footage, output module ids) and is independent of the AE version: AE 25.6 and AE 26.3 write byte-identical envelopes for the same pick, and one AE build writes both shapes for different picks.
• A role is stored as its target, so the role itself cannot be recovered (several roles often share one target).
• A family can share a display's name (in the built-in ACES 1.2 configuration, ACES is both the only display and the family of ACES - ACEScg). Classify A/B as display + view only when B is a view of display A.
• Footage imported into an OCIO project (measured on AE 2026 with three configurations): AE assigns the colour space chosen by the configuration's file rules, taking the first rule that matches (Default matches every file; a regex rule by regular-expression search on the path; a pattern + extension rule by glob on the stem and the extension, case-insensitively). It stores the rule's colour space as a direct pick even when the rule names a role: colorProfileName = <family of the colour space it resolves to>/<rule value>, data {"colorSpace1":"<rule value>"} (e.g. Utility/scene_linear). A configuration without file rules gives its default role, in the role shape.

Profile IDs¶

Several chunks refer to a colour space by a 16-byte id instead of an envelope: cpid, the key of each pprf, the footage ids epid (embedded profile) and apid (assigned profile) in LIST:CLRS, and the output colour space in the output module settings (LIST:LOm).

ICC colour spaces (Adobe mode) use the ICC profile ID of ISO 15076-1 (ICC.1:2010, 7.2.18): the MD5 digest of the complete profile with bytes 44-47 (profile flags), 64-67 (rendering intent) and 84-99 (profile ID) set to zero. This holds for every id in the samples that has its profile in the file (all 699 cpid/PwCs pairs, and the pool entries that cpid, epid and apid values refer to). Two profiles that differ only in the rendering-intent field get the same id. Test vector: AE's 3,144-byte sRGB IEC61966-2.1 profile gives 1d3fda2edb4a89ab60a23c5f7c7d81dd; more are in the cpid table. An output module names an Adobe output colour space by this id alone, without the profile bytes.

FF x 16 means "no profile / not an ICC colour space": cpid when the working space is None or OCIO, apid for unassigned footage and for all OCIO footage (whose colour space is the ocsp envelope), epid when the media has no embedded profile, and the output module value for "Working Color Space" (together with the module's working-space flag).

OCIO output colour-space id¶

An output module whose colour space is an OCIO selection stores neither an envelope nor a name, only a 16-byte id derived from the selection's envelope (the kinds above). The id depends only on the selection, not on the configuration file's path or date. py_aep computes it (OutputModule.output_color_space) and reads it back by matching the ids of the selections the project's OCIO configuration offers.

Items, folders and compositions¶

The project's items (folders, compositions and footage) live in one tree rooted at LIST:Fold, the root folder. Every item is a LIST:Item whose first fixed-size chunk, idta, gives its type, id and label. Folder contents are purely physical: an item belongs to the folder whose container holds it (the root LIST:Fold or a folder's LIST:Sfdr). There is no parent-folder id anywhere, and moving an item to another folder means moving its whole block of chunks (observed on AE 2026: item.parentFolder = folder relocates the block and appends it at the end of the destination container).

Item ids and layer ids come from one project-wide counter: the next free id is stored in head, and the same counter numbers items, real layers and the composition view layers described below. AE trusts that counter on open and does not rescan the ids (a stale counter made AE hand out duplicate layer ids), so a writer that adds items or layers must keep it above every id in the file.

Besides the data the user edits, the item tree carries a lot of panel state: every composition and footage item is followed by an item UI record (fvdv ... fifl) describing its viewer and Timeline tabs, every composition by a LIST:FEE Timeline panel record, and every layer inside a composition by an Effect Controls record (LIST:Ewst) and two more item UI records. Most of these bytes are opaque, but AE requires several of them to be present.

A composition also carries eleven view layers: hidden layers that hold the cameras of the 3D views (Default, Front, Left, Top, Back, Right, Bottom, Custom View 1-3) and the composition markers. AE cannot open a composition without them (it crashes), so a writer creating a composition has to emit the whole skeleton, see Minimal composition item.

LIST:Fold¶

The root folder of the project. It is not itself an item: it has no idta or name, and its children are the root-level items.

Parent: root · py_aep: ListChunk

An item block is the item's LIST:Item followed by the panel state AE stores for it in the parent container:

The same blocks fill a folder's LIST:Sfdr. AE requires the trailing records: removing a composition's LIST:FEE and item UI record makes AE refuse the file ("missing data in file", probed). Unknown chunks placed between blocks are skipped by AE.

fdta¶

Root folder record.

Parent: LIST:Fold · Size: 14 bytes · py_aep: FdtaChunk

LIST:Item¶

One project item: a folder, a composition or a footage item. The children depend on the item type; the tables below give the order AE writes. AE reads the children in order and skips chunks it does not know, so the order is load-bearing: AE refuses a composition whose cdrp is missing or placed before cdta ("missing data in file", probed on AE 2026), while an unknown extra chunk is ignored.

Parent: LIST:Fold, LIST:Sfdr · py_aep: ListChunk

Folder item¶

Composition item¶

Order written by AE 2022 to AE 2026 (file versions 93.40 to 97.x):

AE 15 (file version 92.14) samples differ: no iide, idpc, comr, LIST:DLay or LIST:CIF3 (so ten view layers), and an extra LIST:OvdG in every layer list, view layers included.

Footage item¶

Item name¶

The first Utf8 after idta is the item name, and when AE writes a non-empty value it is displayed verbatim (a / or AE's own 2 disambiguation suffix included).

• Folders and compositions: always the name (an empty folder name is allowed).
• Solids and placeholders: always empty. The name lives in the source's opti (255 UTF-8 bytes at most); renaming the item in AE rewrites the opti, not this chunk.
• File footage: empty means "derive the name from the source" (the sequence pattern, else layer name/file name for a layer of a layered file, else the file name). AE writes a value only when the user renames the item. Replacing the footage never touches this chunk, so a user-given name survives a replace and an empty one follows the new file.

Minimal composition item¶

AE hard-crashes on a composition item that lacks the view-state skeleton, so a writer must emit the full child list above. What AE 2026 writes for a new, empty composition (items.addComp()), and what a writer can copy:

In the parent container the item is followed by a LIST:FEE holding only ppSn and one default item UI record (fvdv 3, then zeros). Every view layer takes a fresh id from the shared counter, and its ldta must use the record size of the file's version: 160 bytes up to AE 2022 (file version 93.x), 164 bytes from AE 23 (94.9) on. A 164-byte record in a file of version 93.x or older makes the composition unopenable in every AE version ("chunk in file too big").

idta¶

Item header: type, id, label, proxy state and footage-kind flags.

Parent: LIST:Item · Size: 84 bytes · py_aep: IdtaChunk

Flags at 0x17:

Values observed on footage: 0x30 for still images and solids, 0x20 for movies without audio and image sequences, 0x24 for movies with audio, 0x04 for audio files, 0x10 for data files (CSV, TSV, JSON, MGJSON, TXT). A writer sets them from the source's actual content.

Default labels of new items come from AE's label preferences; on a factory install: compositions 15, folders 2, solids 1, video files, sequences and placeholders 3, stills 5, audio-only files 7.

A writer creating an item can leave the timestamp at 0x50 at 0: such files open normally.

cmta¶

Item comment (Item.comment). AE also writes cmta inside a layer list for a layer comment (LIST:Layr).

Parent: LIST:Item, LIST:Layr · Size: variable · py_aep: CmtaChunk

UTF-8 text followed by two NUL bytes in every AE-saved sample (files older than version 92.0 use a legacy multibyte string). In an item it follows the name Utf8; idta byte 0x39 is set when it is present.

iide¶

Item id, little-endian copy.

Parent: LIST:Item · Size: 4 bytes · py_aep: U4LeChunk

Written for file versions above 93.7 (AE 17 / 2020 and later): AE 15 files have none and AE 2022-2026 write one on every new item (AE 16-18 not measured). AE opens files in which iide and the idta id disagree (probed both ways).

idpc¶

Number of idpi chunks that follow.

Parent: LIST:Item · Size: 8 bytes · py_aep: IdpcChunk

Written for file versions above 93.7 (AE 17 and later): absent from AE 15 files, written on every new item by AE 2022-2026 (AE 16-18 not measured). New compositions written with a count of 0 open normally.

idpi¶

One composition this composition depends on.

Parent: LIST:Item (compositions) · Size: 4 bytes · py_aep: raw Chunk

Placed between idpc and idta; file versions above 93.7.

sfdt¶

Folder flag word.

Parent: LIST:Item (folders) · Size: 4 bytes · py_aep: SfdtChunk

LIST:Sfdr¶

A folder's contents: item blocks exactly as in LIST:Fold (each LIST:Item, then LIST:FEE for compositions, then an item UI record for compositions and footage). Empty for an empty folder.

Parent: LIST:Item (folders, last child) · py_aep: ListChunk

fvdv¶

First chunk of an item UI record: the panel state of one item, or of one layer inside a composition. The record is a flat run of sibling chunks (not a list). AE writes one after every composition and footage item in its parent container, and two after every layer list inside a composition (the first for the layer's Effect Controls tab, the second for its Layer panel).

Parent: LIST:Fold, LIST:Sfdr, LIST:Item · Size: 4 bytes · py_aep: U4Chunk

Item UI record¶

A closed, never-viewed item is fvdv 3, fiop 0, ftts 0, foac 0, fiac 0, fipc 0, fifl 0. AE 15 production samples also contain viewer records without fips and records whose viewer records follow fifl. Older versions wrote further record chunks (fiin, fitl, fivd, fivs, fivv, fotl) that current AE still accepts but no longer writes; none appears in the samples.

fiop¶

Parent: item UI record · Size: 1 byte · py_aep: U1Chunk

ftts¶

Parent: item UI record · Size: 4 bytes · py_aep: U4Chunk

foac¶

Parent: item UI record · Size: 1 byte · py_aep: U1Chunk

fots¶

Parent: item UI record · Size: 2 bytes · py_aep: raw Chunk

fott¶

Tab type name of the first tab context, ASCII, no terminator: AE Timeline (items) or AE Effect Controls (layers).

Parent: item UI record · Size: variable · py_aep: raw Chunk

fovc¶

Parent: item UI record · Size: 2 bytes · py_aep: raw Chunk

fovi¶

Parent: item UI record · Size: 4 bytes · py_aep: U4Chunk

fiac¶

Parent: item UI record · Size: 1 byte · py_aep: U1Chunk

fits¶

Parent: item UI record · Size: 2 bytes · py_aep: raw Chunk

fitt¶

Viewer type name, ASCII, no terminator: AE Composition, AE Footage or AE Layer (Viewer.type).

Parent: item UI record · Size: variable · py_aep: AsciiChunk

fivc¶

Parent: item UI record · Size: 2 bytes · py_aep: S2Chunk

fivi¶

Parent: item UI record · Size: 4 bytes · py_aep: U4Chunk

fipc¶

Parent: item UI record · Size: 2 bytes · py_aep: S2Chunk

fidi¶

First chunk of a viewer record.

Parent: item UI record · Size: 4 bytes · py_aep: raw Chunk

fipl¶

Parent: item UI record · Size: 2 bytes · py_aep: raw Chunk

fmpl¶

Parent: item UI record · Size: 2 bytes · py_aep: raw Chunk

Written by AE 23 and later only; AE 2022 and older files have no fmpl.

fimr¶

Parent: item UI record · Size: 2 bytes · py_aep: raw Chunk

fips¶

Options of one view of a viewer (View.options). A Composition viewer record stores four (inferred: one per view of a 4-view layout); Footage and Layer viewer records store one.

Parent: item UI record · Size: 96 bytes · py_aep: FipsChunk

Display flags at 0x0C (bits of the big-endian u4):

Bits 0-3, 5, 6, 8, 10, 13, 21-23 and 27 are set in many samples; their meaning is unknown. The fast-preview mode (ViewOptions.fastPreview) is off when none of bits 12, 16, 18 and 20 is set.

fifl¶

Last chunk of an item UI record.

Parent: item UI record · Size: 4 bytes · py_aep: U4Chunk

LIST:FEE¶

Timeline panel state of a composition. The list type is FEE (with a trailing space). It follows the composition's LIST:Item in the parent container and is required there (see LIST:Fold).

Parent: LIST:Fold, LIST:Sfdr · py_aep: ListChunk

Many sample compositions have only ppSn (or nothing in older files), presumably those never opened in a Timeline panel. The children depend on each other: when otln is missing, AE also ignores the seq, LIST:LSIf and ppSn that follow (probed: AE's resave of such a file kept only ppSn = 0.0).

otln¶

Timeline outline state: one word per Timeline row.

Parent: LIST:FEE · Size: 4 + 4 x count bytes · py_aep: OtlnChunk

seq¶

Timeline view settings. The tag is seq (with a trailing space).

Parent: LIST:FEE · Size: 74 bytes · py_aep: raw Chunk

The two times at 0x12 and 0x1A are the Timeline's zoomed time span (inferred: in 767 of 788 sample compositions the span is 0 to the composition duration, and the others show a shorter span).

ppSn¶

Parent: LIST:FEE · Size: 8 bytes · py_aep: F8Chunk

Written for file versions above 93.29 (AE 2022 and later): AE 15 writes an empty LIST:FEE after a new composition, AE 2022-2026 one holding ppSn (AE 16-18 not measured). When it is missing, AE behaves as if it were 0.0 (probed: AE's resave writes 0.0).

LIST:LSIf¶

Wrapper for one opaque 1,872-byte panel-state record. It appears in three places, each with its own record tag.

Parent: LIST:FEE, root, LIST:LRdr · py_aep: ListChunk

The root LIST:LSIf can be left out entirely: AE rebuilds it (a new-project file written without it opens and saves normally in AE 2022-2026).

ACsi¶

Parent: LIST:LSIf in LIST:FEE · Size: 1872 bytes · py_aep: raw Chunk

Opaque panel state; copy it unchanged. All three records share one shape, seen only through the samples: an 8-byte header, then 21 records of 88 bytes (offsets 0x08 to 0x73F), then 16 bytes. Inside the 88-byte records only the bytes at +0x10 to +0x13 (two u2 that look like an id and a size) and +0x57 (0 or 1) are ever non-zero (inferred: one record per panel column). The rest is 0 in every sample.

AFsi¶

Parent: root LIST:LSIf · Size: 1872 bytes · py_aep: raw Chunk

Same shape as ACsi. Byte 0x01 is 0x04 and byte 0x03 is 0, 1 or 4 in the samples.

ARsi¶

Parent: LIST:LSIf in LIST:LRdr · Size: 1872 bytes · py_aep: ArsiChunk

Same shape as ACsi. Two bytes change when the render queue goes from empty to one item: byte 0x03 becomes 1 (0 while the queue is empty), and byte 0x17B (a byte of the fifth 88-byte record) is rewritten (0x73 in the observed case). The rest can be copied unchanged.

LIST:Ewst¶

Effect Controls panel state of one layer. AE writes one directly after every layer list (LIST:Layr and the view layers) inside a composition, followed by the layer's two item UI records. It is empty unless the layer was shown in an Effect Controls panel.

Parent: LIST:Item (compositions) · py_aep: ListChunk

ewin¶

Parent: LIST:Ewst · Size: 28 bytes · py_aep: raw Chunk

The four u2 at 0x00 look like a panel rectangle (top, left, bottom, right) (inferred).

ewot¶

Effect Controls outline state: one word per row.

Parent: LIST:Ewst · Size: 4 + 4 x count bytes · py_aep: EwotChunk

cdta¶

Composition settings: timing, size, background colour, motion blur and flags.

Parent: LIST:Item (compositions) · Size: 204 bytes · py_aep: CdtaChunk

Flags at 0x88 (bits of the big-endian u4):

Composition timing¶

Every time in a composition is a dividend/divisor pair; the value in seconds is dividend / divisor. AE uses the composition's timebase (0x08) as the divisor for most of them, and 600 for some initial values (a new composition stores its current time and work area start as 0/600 and a pinned work-area end as 0xFFFFFFFF/600; editing them later switches to the timebase).

The timebase and the time scale (0x04) are tied to the frame rate: one frame is 256 x time scale timebase units, so timebase = frame rate x time scale x 256. AE takes the rate to the thousandth (half up) as a reduced fraction p/q, and gives a frame q x 2^k units with the largest k (at least 0) that keeps the timebase under 40000. This reproduces every AE-saved sample (1 to 999 fps) and 90 rates set in AE 2026:

• NTSC rates share timebase 23976: 23.976 fps (2997/125) gets 1000 units a frame (time scale 3.90625), 29.97 gets 800 (3.125), 47.952 500, 59.94 400, 119.88 200.
• Whole and binary-fraction rates get powers of two: 24 fps -> 1024 units (24576), 25 -> 1024 (25600), 60 -> 512 (30720), 19.5 -> 2048 (39936), 37 -> 1024 (37888), 78.125 -> 256 (20000, not 40000), 999 -> 32 (31968).
• Other decimal rates: 7.3 -> 5120 (37376), 23.98 -> 1600 (38368), 29.98 -> 800 (23984), 44.1 -> 640 (28224), 99.99 -> 400 (39996); a rate whose thousandths have no small denominator keeps k = 0, even past 40000 (99.123 -> 1000 units, timebase 99123).
• Past 115200 even at k = 0, AE halves the units per frame until the timebase fits, rounds the timebase down and stores the whole units per frame, so the frame grid runs a hair off the rate: 120.001 fps -> 500 units (60000, a 120 fps grid), 333.333 -> 250 (83333), 750.001 -> 125 (93750), 998.999 -> 62 (62437, computed from 62.5 units).

The stored 16.16 frame rate (0x9C) only approximates timebase / units per frame (29.970001220703125 for 23976 / 800); AE counts frames on the timebase grid. A time's frame number (displayStartFrame, frameTime) is the time in timebase units over the units per frame, rounded away from zero: a display start stored as float32 0.0416666679 s is frame 2 at 24 fps. On the NTSC timebase AE keeps a float32-stored start within about 1/10000 of a frame on that frame (52/29.97 s is frame 52).

Keyframe times inside the composition are counted in the same timebase units (see ldat), so changing the frame rate rescales them.

AE stores whole frames: a duration, work area or current time set through the UI or scripting is snapped to the nearest frame, half a frame rounding up, and stored as frames x units per frame over the timebase (a 10 s composition at 24 fps is 245760/24576). A frame-rate change re-snaps the duration, work area start and end (unless pinned) and the current time to the new frame grid, each independently; the display start is left alone. The work area times are relative to the start of the composition (frame 0), not to the display start. The display start time, when set as a time, is stored as the exact ratio of the 32-bit float value AE holds (1/24 s is stored as 11184811/268435456); when set as a frame it is frames x units per frame over the timebase.

cdrp¶

Drop-frame timecode display (CompItem.dropFrame).

Parent: LIST:Item (compositions) · Size: 1 byte · py_aep: U1Chunk

Required, and it must come after cdta: AE refuses a composition without it, or with it placed before cdta ("missing data in file", probed on AE 2026).

comr¶

Parent: LIST:Item (compositions) · Size: 1 byte · py_aep: raw Chunk

Written for file versions above 93.18 (AE 17 and later), right after cdrp: absent from AE 15 compositions, present in every AE 2022-2026 one (AE 16-18 not measured).

LIST:PRin¶

The composition's 3D renderer (CompItem.renderer) and its options.

Parent: LIST:Item (compositions) · py_aep: ListChunk

prin¶

Parent: LIST:PRin · Size: 104 bytes · py_aep: PrinChunk

prda¶

Options of the renderer named by prin. The first two u4 are shared; the rest depends on the renderer. Unknown renderers or sizes should be copied verbatim.

Parent: LIST:PRin · Size: 12, 16, 20 or 52 bytes · py_aep: PrdaChunk (ClassicPrdaChunk, RayTracedPrdaChunk, Cinema4DPrdaChunk, AdvancedPrdaChunk)

Classic 3D (12 bytes)¶

Ray-traced 3D (16 bytes)¶

Cinema 4D (20 bytes)¶

Advanced 3D (52 bytes)¶

This variant is mixed-endian: the first 20 bytes are big-endian, the rest little-endian, in every sample.

LIST:Layr¶

One layer of a composition. Layers are stored in Timeline order, layer 1 first. The contents (ldta, the layer name Utf8, LIST:tdgp, LIST:Gide and optional trailing chunks such as cmta or mdla) are described with the layers. Inside the composition each LIST:Layr is directly followed by a LIST:Ewst and two item UI records.

Parent: LIST:Item (compositions) · py_aep: ListChunk

LIST:DLay¶

The Default 3D view of a composition: a hidden camera layer named Default. Same contents as LIST:Layr. One per composition in every sample from AE 2022 on; absent from AE 15 (92.14) samples. See Composition view layers.

Parent: LIST:Item (compositions) · py_aep: ListChunk

LIST:SLay¶

The six orthographic 3D views of a composition, as hidden camera layers named Front, Left, Top, Back, Right and Bottom (one list each, in that order). Same contents as LIST:Layr.

Parent: LIST:Item (compositions) · py_aep: ListChunk

LIST:CLay¶

The three custom 3D views, hidden camera layers named Custom View 1 to Custom View 3. Same contents as LIST:Layr.

Parent: LIST:Item (compositions) · py_aep: ListChunk

LIST:SecL¶

A hidden layer named Markers that carries the composition markers (CompItem.markerProperty): the markers are stored in its marker stream, with times in composition time. One per composition. Same container shape as LIST:Layr.

Parent: LIST:Item (compositions) · py_aep: ListChunk

Composition view layers¶

What AE 2026 writes for the eleven view layers of a new composition (W, H = composition size, PAR = pixel aspect, Z = W x PAR / 0.72, which is the 50 mm camera distance; every layer's out point is the composition duration):

The ten camera views share one property layout (a transform group with Anchor Point, the Position above, the separated X/Y/Z positions, Scale on Default and the custom views only, Z rotation, Opacity and Envir Appear, then an empty camera options group). The Markers layer has its own layout (transform group with Orientation and X/Y rotations, layer styles, extrusion and material options). Its material options vary by release: AE 15 to AE 2023 leave out Casts Shadows, Light Transmission, Accepts Shadows, Accepts Lights, Shadow Color and the Ambient, Diffuse, Specular, Shininess and Metal coefficients, which AE 2024 and later write (Shadow Color alpha 0 in AE 2024, 255 from AE 2025); AE 15 also has no ADBE Layer Sets group there. Measured on new compositions in AE 2022-2026 and on the AE 15 sample. The layer records themselves are covered under ldta: view layers need their own layer ids and the record size of the file's version.

LIST:Gide¶

Ruler guides. Every composition item has one (the composition's guides, Item.guides); every footage item and every layer list has one too (inferred: the Footage and Layer panel guides; empty in every sample).

Parent: LIST:Item (compositions, footage), LIST:Layr, LIST:DLay, LIST:SLay, LIST:CLay, LIST:SecL · py_aep: ListChunk

Guide item¶

gdta¶

Parent: LIST:Gide · Size: 8 bytes · py_aep: GdtaChunk

LIST:dats¶

Descriptions of data-driven sources used by the composition. Every sample composition has one, holding only numS = 0.

Parent: LIST:Item (compositions) · py_aep: ListChunk

AE can also write, after numS, a LIST:dtSg holding LIST:dtSd lists made of sTyp (4 bytes), dNam and eNam (strings), minV and maxV (8 bytes each) and prec (4 bytes, file versions above 92.2). No sample contains them, so their layout is unverified.

numS¶

Parent: LIST:dats · Size: 4 bytes · py_aep: raw Chunk

mdls¶

Settings of a 3D model footage item (an FBX file in the samples), written after ftgi.

Parent: LIST:Item (footage) · Size: 64 bytes · py_aep: raw Chunk

mdld¶

Geometry of a 3D model footage item. All values are little-endian doubles inside the big-endian file.

Parent: LIST:Item (footage), after mdls · Size: 176 bytes · py_aep: raw Chunk

LIST:CIFO¶

Essential Graphics definition of a composition (Motion Graphics template), oldest of three copies. LIST:CIF2 and LIST:CIF3 have the same structure; AE 2022 and later write all three in a row, AE 15 wrote CIFO and CIF2 only. CIF3 is the current copy: some samples hold fewer controllers in CIFO and CIF2 than in CIF3. A writer adding or removing a controller should do it in all three.

Parent: LIST:Item (compositions) · py_aep: ListChunk

LIST:CIF2¶

Second copy of the Essential Graphics definition; same structure as LIST:CIFO.

Parent: LIST:Item (compositions) · py_aep: ListChunk

LIST:CIF3¶

Current copy of the Essential Graphics definition (AE 2022 and later); same structure as LIST:CIFO. Readers should prefer it when present.

Parent: LIST:Item (compositions) · py_aep: ListChunk

LIST:CpS2¶

A localized string: one text per locale.

Parent: LIST:CIFO / LIST:CIF2 / LIST:CIF3, LIST:CCtl · py_aep: ListChunk

A new composition's template name is Untitled / en_US; one sample carries two pairs, Unbenannt / de_DE then Unbenannt / en_US. In a LIST:CCtl it holds the controller name.

CsCt¶

Parent: LIST:CpS2, LIST:CapS · Size: 4 bytes · py_aep: CsctChunk

LIST:CapS¶

Caption strings, one per entry.

Parent: LIST:CIFO / LIST:CIF2 / LIST:CIF3, LIST:CCtl · py_aep: ListChunk

CapL¶

Parent: LIST:CapS · Size: 4 bytes · py_aep: U4Chunk

CPTm¶

Parent: LIST:CIFO / LIST:CIF2 / LIST:CIF3 · Size: 8 bytes · py_aep: raw Chunk

Inferred: a time as dividend/divisor (0 s), probably the template's poster time.

CROI¶

Parent: LIST:CIFO / LIST:CIF2 / LIST:CIF3 · Size: 8 bytes · py_aep: raw Chunk

Inferred: a rectangle (top, left, bottom, right).

CcCt¶

Parent: LIST:CIFO / LIST:CIF2 / LIST:CIF3 · Size: 4 bytes · py_aep: S4Chunk

LIST:CCtl¶

One Essential Graphics controller.

Parent: LIST:CIFO / LIST:CIF2 / LIST:CIF3 · py_aep: ListChunk

Type-specific chunks, in order:

The Source Text font options JSON holds capPropFontEdit, capPropFontFauxStyleEdit, capPropFontSizeEdit (booleans), fontEditValue (PostScript font name), fontFSAllCapsValue, fontFSBoldValue, fontFSItalicValue, fontFSSmallCapsValue (booleans) and fontSizeEditValue (number). The alternate-source JSON is {"compId":-1,"isEnabled":false,"layerId":-1} on every sample.

AE can also write CDim (4 bytes) and CSLk (1 byte) inside a LIST:CCtl; no sample contains them. AE 2026 shows a Group "drop zone" in the panel that is not stored in the file.

CTyp¶

Parent: LIST:CCtl · Size: 4 bytes · py_aep: U4Chunk

CVal¶

Current value of the controller. Layout by CTyp:

Parent: LIST:CCtl · Size: 1, 4, 8 or 16 bytes · py_aep: raw Chunk

AE can also write a 32-byte value (no sample). CVal and CDef are equal in every sample, and both are a copy of the source property's value at the time the controller was added. When AE duplicates a composition, it writes zeros in both for the copy's controllers.

CDef¶

Default value of the controller; same layout as CVal.

Parent: LIST:CCtl · Size: 1, 4, 8 or 16 bytes · py_aep: raw Chunk

Smin¶

Parent: LIST:CCtl (sliders) · Size: 8 bytes · py_aep: F8Chunk

Smax¶

Parent: LIST:CCtl (sliders) · Size: 8 bytes · py_aep: F8Chunk

CFEd¶

Parent: LIST:CCtl (Source Text) · Size: 1 byte · py_aep: raw Chunk

Written for file versions above 92.16 (AE 16 and later).

CSEd¶

Parent: LIST:CCtl (Source Text) · Size: 1 byte · py_aep: raw Chunk

Written for file versions above 92.16 (AE 16 and later).

CTov¶

Parent: LIST:CCtl (Source Text) · Size: 4 bytes · py_aep: raw Chunk

Written for file versions above 95.1 (AE 24 and later).

CSGe¶

Parent: LIST:CCtl (Group) · Size: 1 byte · py_aep: raw Chunk

Written for file versions above 92.19 (AE 16 and later).

CSMw¶

Parent: LIST:CCtl (Media Replacement) · Size: 4 bytes · py_aep: U4Chunk

The Media Replacement chunks CSMw to CCEx are written for file versions above 93.12 (AE 17 and later).

CSMh¶

Parent: LIST:CCtl (Media Replacement) · Size: 4 bytes · py_aep: U4Chunk

CSMs¶

Parent: LIST:CCtl (Media Replacement) · Size: 4 bytes · py_aep: U4Chunk

CSMe¶

Parent: LIST:CCtl (Media Replacement) · Size: 4 bytes · py_aep: U4Chunk

CSMt¶

Parent: LIST:CCtl (Media Replacement) · Size: 4 bytes · py_aep: U4Chunk

CSMp¶

Parent: LIST:CCtl (Media Replacement) · Size: 8 bytes · py_aep: raw Chunk

CCEx¶

Parent: LIST:CCtl (Media Replacement) · Size: 1 byte · py_aep: raw Chunk

CSMd¶

Parent: LIST:CCtl (Media Replacement) · Size: 4 bytes · py_aep: U4Chunk

Written for file versions above 93.23 (AE 18 and later).

CprC¶

Count of LIST:CPrp children. Its byte order depends on the parent.

Parent: LIST:CCtl, LIST:OvG2, LIST:OvdG · Size: 4 bytes · py_aep: S4Chunk

LIST:CPrp¶

A property reference. Inside a controller it names the source property the controller exposes; inside an override group it names a controller.

Parent: LIST:CCtl, LIST:OvG2 · py_aep: ListChunk

In a LIST:CCtl:

The path JSON maps the positions "0", "1", ... (root to leaf) to {"index": n, "matchName": "..."}. index 4294967295 (0xFFFFFFFF) means "find by match name"; other values are the property's 0-based position among all children of its parent group, counting hidden ones (so it differs from the ExtendScript index). Example: {"0":{"index":4294967295,"matchName":"ADBE Effect Parade"},"1":{"index":0,"matchName":"ADBE Fill"},"2":{"index":3,"matchName":"ADBE Fill-0002"}}.

In a LIST:OvG2: one Utf8 holding a controller id (the UUID of a LIST:CCtl).

CCId¶

Parent: LIST:CPrp · Size: 4 bytes · py_aep: U4Chunk

CLId¶

Parent: LIST:CPrp · Size: 4 bytes · py_aep: U4Chunk

When AE duplicates a composition, the copy's controllers get fresh UUIDs (the same new UUID in all three containers), CCId becomes the copy's item id and CLId the matching copied layer's id.

LIST:OvG2¶

Override group of a layer's Essential Properties: the controllers of the layer's source composition whose overrides this layer holds. It sits inside the layer's LIST:tdgp, right after the tdmn ADBE Layer Overrides.

Parent: LIST:tdgp · py_aep: ListChunk

LIST:OvdG¶

An older override container found only in AE 15 (92.14) samples, which also have LIST:OvG2: a child of the layer list itself (LIST:Layr, LIST:SLay, LIST:CLay, LIST:SecL), after its LIST:Gide, holding a single CprC = 0. Not written by AE 2022 or later.

Parent: LIST:Layr, LIST:SLay, LIST:CLay, LIST:SecL · py_aep: ListChunk

Footage¶

A footage item is a LIST:Item whose idta says "footage". Its source - a file, an image sequence, a solid or a placeholder - is a LIST:Pin: the cached media properties (sspc), the importer's own record (opti), the file path (LIST:Als2), the colour-management settings (LIST:CLRS) and the media timecode (LIST:mnfo). A proxy is a second LIST:Pin of the same shape. The item itself adds ftgi after its main source.

After Effects caches what it knows about the media in the project and does not re-read the file on open while the file's modification time matches the one stored in sspc (0x76): a PNG whose stored size was patched to 7x7 opens as 7x7, footage found and all (AE 2026). A writer therefore has to put correct dimensions, duration, frame rate, alpha, pixel depth and audio information into sspc. AE does check the structure against its own importer, in both directions: an sspc that claims a video track the importer cannot decode opens as missing footage, one that claims audio only for a file whose video AE can decode opens with a "problem accessing the audio or video data" warning and renders nothing (AE 2026, MP4 files).

Layouts below were reverse-engineered from the files AE writes; the samples are the 5,359 LIST:Pin of the py-aep sample corpus (file versions 92.14 - the AE CC 2018 era samples - up to 97.7).

LIST:Pin¶

One footage source (list type Pin with a trailing space).

Parent: LIST:Item (footage items and, for a proxy, compositions)

Child orders in the samples: sspc Utf8 LIST:Als2 opti pgui LIST:CLRS LIST:mnfo Utf8 (file footage, 2,379), sspc Utf8 opti pgui LIST:CLRS LIST:mnfo Utf8 (solids and placeholders, 2,051), sspc Utf8 LIST:Als2 Utf8 Utf8 opti ... (numbered sequences, 621) and sspc Utf8 LIST:Als2 LIST:StVc opti ... (alphabetical sequences, 126). Write them in this order.

Main source and proxy. In a footage item the first LIST:Pin sits right after the item's name Utf8 and before ftgi: it is the main source. A proxy is a second LIST:Pin placed as the very last child of the LIST:Item, after LIST:Gide. A composition has no main source; when it has a proxy, that proxy is its only LIST:Pin, again the last child. Whether the proxy is in use is a flag of idta (AVItem.useProxy). Sample: models/item/proxy.aep (a QuickTime movie with a PNG proxy, and two compositions with PNG proxies).

Source kinds¶

How each kind of footage is represented:

• File footage. sspc holds the importer's source format code (0x16), 01 01 at 0x40, 1 at 0x4F and the file's modification time at 0x76. LIST:Als2 holds the absolute path. The item's display name is the item-level Utf8, written only when the user renames the item; empty means "derived from the file" (sequence pattern, else layer/file for a layer, else the file name).
• Solid. sspc code Soli, the solid's size, a zero duration, alpha byte 3 (no alpha), 00 00 at 0x40, 0 at 0x4F, 0x00010000 at 0x68 and 0x6C, 1 at 0x86; 0x76 holds a time stamp in the same encoding as a file's (dates in the samples suggest the creation or last edit of the solid). No LIST:Als2. The colour and the item's name live in the solid record of opti; the item-level Utf8 stays empty. LIST:CLRS has ipws 1, dcui and prgb.
• Placeholder. sspc code is four NUL bytes; size, duration in seconds and the placeholder's frame rate in the native-rate slot (0x3A, conform 0); bit 0 of byte 0x73 (missing) set; no time stamp; layer index (0xC0) 0xFFFFFFFE for a placeholder created with Import > Placeholder, 0xFFFFFFFF on others seen in AE 2026 files. No LIST:Als2. The name lives in the placeholder record of opti. ExtendScript reports it as missing footage.
• Numbered image sequence. sspc 0xA8 = 2, first and last frame numbers, digit count and zero-padding flag (0xAC-0xB8), 01 01 at 0xBA; AE 2026 opens a sequence written without 0xA8 and these flags as missing. The path is the folder (target_is_folder true), followed by the two Utf8 (prefix, extension). The time stamp is the folder's modification time. The sequence's rate is the native rate (0x3A) with conform 0; the stored duration is frame count over that rate, unreduced (3 frames at 30 fps = 3/30). A new sequence's rate comes from AE's "Sequence Footage" import preference (factory 30), not from the project.
• Alphabetical image sequence (imported with "Force alphabetical order"): sspc 0xA8 = 1, first and last frame 0xFFFFFFFF, digit count 0, 0xB8 and 0xBA 0, byte 0x74 = 1. The frames are listed by name in LIST:StVc: every file of the same extension in the folder (extension compared case-insensitively), sorted by lower-cased name (n_10 before n_2). The item is named after the folder. Sample: models/footage/sequence_alphabetical.aep.
• One layer of a layered file (Composition import, or a layer chosen in the import dialog). sspc 0xBC (Photoshop layer id), 0xC0 (layer index), 0xC7 (full frame or cropped) and 0xC9 (layer-style handling); the layer's name in the Utf8 after sspc; the layer is described again in opti (Photoshop / Illustrator). Every layer is its own footage item pointing at the same file.
• Missing footage. Stays file footage with all its cached values; only bit 0 of sspc byte 0x73 is set when the file was missing when the project was saved (models/footage/footage_missing.aep and footage_not_missing.aep differ in that bit only). FileSource.missingFootagePath is the stored path.

sspc¶

Cached properties of the footage source (Interpret Footage settings included). Not to be confused with the effect list LIST:sspc.

Parent: LIST:Pin · Size: 222 bytes · py_aep: SspcChunk

Every sample is 222 bytes. AE also reads a 286-byte form used by older project versions; no sample contains it.

Source flags at 0x70 (a big-endian u4; byte 0x73 holds bits 0-7):

All other bits are 0 in every sample.

Interpretation flags at 0x9C (a big-endian u4; byte 0x9F holds bits 0-7):

All other bits are 0 in every sample.

Scripted imports. AE 2026's scripted importFile of an image sequence and every scripted replace/replaceWithSequence write 0xC7 = 0, 0xC9 = 0 and bit 11 of 0x70, and keep 0x4F from the old source; the Import dialog writes 1 / 2 / clear for the same files. Stills and movies get 1 / 2 / clear either way. Rendering does not change (AE 2026 render comparison); a writer should use the dialog values.

Alpha¶

The alpha byte (0x49) and bit 0 of the alpha flags (0x45) must agree: Premultiplied (1) goes with the bit set, Straight (0) and Ignore (2) with it clear. When the byte says Premultiplied and the bit is clear, AE 2026 resets the footage to Straight alpha on open. The exception is an FBX scene (LDOM): AE sets the bit while the byte stays Straight. Six items in an older production sample carry byte 1 with the bit clear.

AE's own import picks Straight for most formats with alpha and Premultiplied for OpenEXR; a source without alpha stores 3.

Pixel depth¶

0x3E is the source's pixel depth as an AE SDK AEIO_InputDepth value: 24, 48 and 96 for RGB at 8, 16 and 32 bits per channel, 32, 64 and 128 with alpha; 40, -16 and -32 for 8, 16 and 32-bit grayscale; 34 and 36 for 2 and 4-bit grayscale; 1 for 1-bit; 8 for indexed colour; 0 for media without video. What AE 2026 writes:

The depth is load-bearing for rendering: with 0 AE 2026 renders TIFF, merged PSD/PSB and AI/EPS/PDF footage (and compositions made from them) with their alpha ignored, and an FBX scene with stray content, while ExtendScript still reports hasAlpha true. Formats whose opti is the generic media record re-read the file and are not affected.

Modification time¶

0x74-0x7C: byte 0x74 is the alphabetical-sequence marker, 0x76 a big-endian u4 of seconds since 1904-01-01, the other bytes 0. AE compares 0x76 with the file (a sequence: its folder) on open. When they match, AE trusts the values cached in sspc. When they differ, or 0x76 is 0, AE re-reads the media and takes the dimensions from the format's own reader, which is not always what its importer recorded: an OpenEXR frame whose data window (2354x1000) is smaller than its display window (2356x1002) is imported at the display window but opens at the data window from an unstamped file (AE 2026). A writer should stamp every source whose file it can see. A stamp also means AE no longer corrects a wrong cached value on open.

Source format codes¶

0x16 names the importer AE used. It must match an importer that can read the file; AE does not use it to find the file.

opti¶

The importer's own record for the source. The layout depends on the importer; the first four bytes identify it.

Parent: LIST:Pin · Size: variable (0, 30, 46, 48, 58, 66, 266, 282, 322, 596, 600, 602, 8466, 9750 in the samples) · py_aep: OptiChunk (SoliOptiChunk, PsdOptiChunk, TextOptiChunk, PlaceholderOptiChunk)

Every non-empty record starts with the same 10-byte header:

What a writer must write. AE accepts a record that differs from its own in many bytes, but not every kind can be left out. Measured on AE 2026: an empty opti is accepted for an FBX scene and an OpenEXR still; a PNG still with an empty opti opens but crashes AE as soon as it is rendered, while the 58-byte generic record (code png!) renders like AE's own import; JPEG, BMP/GIF, Targa, movies and audio need at least the generic record; TIFF needs the 602-byte record (empty or generic crashes AE, still or sequence); DPX/Cineon need their 48-byte record; Radiance HDR refuses an empty or generic record; Camera Raw crashes AE with an empty record but accepts the generic one (AE rewrites it on save); AI/EPS/PDF need the 596-byte record; an OpenEXR whose data window differs from its display window needs the 9750-byte record (see below). AE's own 322-byte PNG record copied onto an sspc that AE did not write rendered with alpha ignored, so do not transplant a format-specific record on its own.

Generic media record¶

Used by AE's media importers: QuickTime and MP4, audio, JPEG, BMP/GIF, HEIC, MPEG, WMV, SWF and data files. The kind is the source format code, except for data files whose sspc code is four NUL bytes (\0vsc for a .csv, \0vst for a .txt).

An older 66-byte form (version 5, MPEG sources in 92.14 projects) appends a u4 LE 1 and FF FF FF FF. AE re-derives the bytes from 0x1E to 0x31 from the media: a record with the reversed source format code at 0x1E, FF FF FF FF, no codec and the two 1 words opens and renders like AE's own (AE 2026, MP4/MP3/MPEG/WMV included); the kind at 0x00 is what has to be right.

PNG record (png!)¶

OpenEXR record (oEXR)¶

Without this record AE places an image whose data window differs from its display window wrongly, and crashed rendering one whose data window is larger than the display window; the first 0x30 bytes with zeros after them are enough (AE 2026).

Photoshop and TIFF record (8BPS, TIF)¶

Used for whole Photoshop files (PSD and PSB), for each layer of a Photoshop file imported as layers, and for TIFF stills and sequences. The file-info fields from 0x12 copy the Photoshop file header, little-endian.

AE does not re-derive the channel count, bit depth, colour mode or layer count from the file: it keeps the stored values when it saves, and footage whose record carries other values (all four wrong for grayscale, CMYK, palette and bilevel files) renders the same as AE's own import (AE 2026 render comparison).

Older TIFF record (TIF_)¶

Seen only in 92.14 projects (48 items).