Format of text serialized files

Unity’s Scene format uses a custom subset of the YAML data serialization language. YAML is an open format with documentation about it available on the YAML website. For more information about the YAML used in unity, read the documentation on UnityYAML.

The file writes each Object in a Scene as a separate YAML document. The --- sequence introduces each Object in the file. In this context, the term “Object” refers to GameObjects, Components and other scene data collectively: each of these items needs its own YAML document in the scene file. The following example shows the basic structure of a serialized object:

--- !u!1 &6
GameObject:
  m_ObjectHideFlags: 0
  m_PrefabParentObject: {fileID: 0}
  m_PrefabInternal: {fileID: 0}
  importerVersion: 3
  m_Component:
  - 4: {fileID: 8}
  - 33: {fileID: 12}
  - 65: {fileID: 13}
  - 23: {fileID: 11}
  m_Layer: 0
  m_Name: Cube
  m_TagString: Untagged
  m_Icon: {fileID: 0}
  m_NavMeshLayer: 0
  m_StaticEditorFlags: 0
  m_IsActive: 1

The first line contains the string !u!1 &6 after the document marker. The first number after !u! indicates the class of the object (in this case, it is a GameObject). The number following the ampersand is an object ID number unique within the file, although the number is assigned to each object arbitrarily. Each of the object’s serializable properties is denoted by a line like the following:

m_Name: Cube

Properties are typically prefixed with m_ but otherwise follow the name of the property as defined in the script reference. The following example shows how a second object, defined further down in the file looks:

--- !u!4 &8
Transform:
  m_ObjectHideFlags: 0
  m_PrefabParentObject: {fileID: 0}
  m_PrefabInternal: {fileID: 0}
  m_GameObject: {fileID: 6}
  m_LocalRotation: {x: 0.000000, y: 0.000000, z: 0.000000, w: 1.000000}
  m_LocalPosition: {x: -2.618721, y: 1.028581, z: 1.131627}
  m_LocalScale: {x: 1.000000, y: 1.000000, z: 1.000000}
  m_Children: []
  m_Father: {fileID: 0}

The following example shows an attached Transform component to the GameObject defined by the YAML document above. {fileID:6} is used to represent the GameObject as the GameObject’s object ID within the file was 6.

m_GameObject: {fileID: 6}

…

Decimal representation or hexadecimal numbers in IEEE 754 format (denoted by a 0x prefix) can be used to represent floating point numbers. Unity uses the IEEE 754 representation for lossless encoding of values and to write floating point values which don’t have a short decimal representation. When Unity writes numbers in hexadecimal, it always writes the decimal format in parentheses for debugging purposes, but only the hex is actually parsed when loading the file. To edit these values manually, remove the hex and enter a decimal number. The following example shows a valid representation of floating point values (all representing the number one):

myValue: 0x3F800000
myValue: 1
myValue: 1.000
myValue: 0x3f800000(1)
myValue: 0.1e1

Arrays of primitive types

Unity writes array and list fields of integer, character, and boolean element types as a single compact hexadecimal scalar instead of a YAML sequence. Unity writes each element as the hexadecimal representation of its raw bytes, in little-endian byte order and with lowercase digits. It then appends one character that identifies the element type. The following example shows an array of two 32-bit signed integers with the values 1 and 2:

m_Array: 0100000002000000i

Every element occupies an even number of hexadecimal characters, so a scalar that ends with a type character has an odd length. Unity treats the last character of an odd-length scalar as a type character only if it matches one of the type characters in the following table. Everything before that character is hexadecimal data.

The following table lists each type character, the element type it identifies, and the number of hexadecimal characters each element of that type occupies. The last column lists the C# element type that produces each type character, or None for the type characters that only Unity’s built-in types write. Unity converts some C# types before it writes them, so a bool field serializes as an 8-bit unsigned integer and a char field as a 16-bit unsigned integer.

Unity writes an empty compact array as an empty scalar with no type character, and uses YAML sequences rather than compact hexadecimal scalars for arrays of float and double.

An array of an enum type uses the type character of the enum’s underlying integer type. For example, an array of an enum with a byte underlying type produces the type character y.

Note: Unity reads compact arrays both with and without the type character. If you parse text serialized files with external tools, such as a merge tool or a validation script, make sure those tools accept the trailing type character.

Additional resources

• An example of a YAML scene file
• YAML class ID reference