ASSET File Documentation

---

Technical details

Feature	Value
Full name	Unity Asset File
File extension	.asset
MIME type	application/octet-stream
Format type	Unity-serialized object (YAML text or binary), project-internal
Most common content	ScriptableObject (designer-authored data container)
Developer	Unity Technologies
Introduced	Unity 1.0 (2005); text/YAML serialization since Unity 3.5 (2012)
Serialization modes	Force Text (YAML), Force Binary, or Mixed
Text header	%YAML 1.1 + %TAG !u! tag:unity3d.com,2011:
Binary signature	None fixed — Unity-internal blob with no readable header
Companion file	.asset.meta sidecar holding the asset’s GUID and import settings
References	By GUID + fileID (resolved only within the project)
Editor	Unity Editor (Inspector); text form readable in any editor
Not the same as	.assets build bundles (e.g. sharedassets0.assets)
Open standard	No — Unity-proprietary serialization
Related extensions	.meta, .unity, .prefab, .mat, .unitypackage, .assets
Specification URL	docs.unity3d.com/Manual/FormatDescription.html

What is an .asset file?

In Unity, “asset” is the general word for any resource in a project (textures, models, audio, scripts, scenes), but a file with the literal .asset extension is something specific: a Unity Asset File, a single serialized Unity object. Most often it is a ScriptableObject, a designer-authored data container that lives as its own file rather than inside a scene, holding things like item stats, dialogue tables, game configuration or tunables. Unity also uses .asset for certain built-in data such as lighting settings and render settings. These files are created and consumed by the Unity Editor, first released in 2005 by Unity Technologies.

The key property is that a .asset only makes sense inside the project that owns it. Every .asset has a companion .asset.meta file holding its GUID, and references between assets are made by GUID and fileID rather than by path. Pull a lone .asset out of its project and its links break. This article explains Unity’s two serialization modes, the YAML structure you see under Force Text, how the GUID/fileID reference system works, and the common confusion between a project .asset and a shipped .assets bundle.

Two serialization modes: Force Text and Force Binary

Whether an .asset is human-readable depends entirely on a project setting, found under Edit › Project Settings › Editor › Asset Serialization. There are three choices, and they change the bytes on disk.

Asset Serialization mode      on-disk result
─────────────────────────     ─────────────────────────────────────
Force Text     (default)      YAML text — readable, diff-able, merge-able
Force Binary                  compact binary blob — no readable header
Mixed                         some assets text, some binary

Force Text is the default for new projects and the mode teams use with version control, because a YAML file can be diffed and merged in Git. Force Binary produces smaller files that load faster but cannot be inspected in a text editor. So the same ScriptableObject can be legible YAML in one project and an opaque blob in another; the difference is the project’s setting, not the object. Unity’s own documentation warns that hand-editing .asset files is unsupported and easy to corrupt.

The YAML structure: %TAG, classID and fileID

Under Force Text, an .asset is a Unity-flavoured YAML document. It opens with two directive lines and then one YAML document per serialized object.

%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!114 &11400000
MonoBehaviour:
  m_ObjectHideFlags: 0
  m_Script: {fileID: 11500000, guid: a1b2c3..., type: 3}
  m_Name: EnemyStats
  maxHealth: 120
  moveSpeed: 3.5

The %TAG !u! directive maps the shorthand !u! to Unity’s tag namespace tag:unity3d.com,2011:. Each object then begins with --- !u!<classID> &<fileID>. The classID is Unity’s internal class number (114 is MonoBehaviour, which is what a ScriptableObject serializes as), and the fileID after the ampersand is the object’s local anchor within this file. The body that follows is the serialized data: every public field and every field marked [SerializeField] on the object, which is the actual game data a designer set in the Inspector. Because this is standard YAML anchors and mappings, a merge tool can resolve most conflicts line by line, which is the whole point of Force Text.

GUID and fileID: how assets point at each other

Unity never references another asset by filename or path, because paths change when files move. Instead it uses a two-part reference: a GUID that identifies the target file, and a fileID that identifies the specific object inside that file. In the YAML above, m_Script: {fileID: 11500000, guid: a1b2c3...} points at the C# script that defines this ScriptableObject’s type. The GUID is not stored in the .asset itself; it lives in the sibling .asset.meta file, which is why the .meta file must travel with the asset. Delete or lose the .meta and Unity assigns a new GUID on reimport, breaking every reference that pointed at the old one. This reference model is exactly why a .asset copied out of its project is near-useless on its own: the GUIDs it references resolve to nothing without the rest of the project’s .meta files.

.asset versus .assets: two different files, two different tools

A frequent and costly confusion for modders is that a project .asset is not the same as a build-time .assets archive. A project .asset is a single serialized object that exists at edit time inside the Unity project. A .assets file (with an s), such as sharedassets0.assets or resources.assets found in a shipped game’s data folder, is a compiled asset bundle that packs many resources together for the runtime. You open the compiled bundles with tools like AssetStudio or UABE (Unity Assets Bundle Extractor), which is a completely different workflow from opening a project .asset in the Unity Editor. Trying to open a shipped .assets bundle in the Editor, or trying to read a project .asset with AssetStudio, is the wrong tool for the file.

Opening and editing an .asset the right way

The supported way to work with an .asset is to open its containing project in the free Unity Editor (via Unity Hub) and select the file in the Project window; it appears in the Inspector, where you edit its fields safely. If the project uses Force Text, you can additionally read the raw YAML in an editor like VS Code to inspect values, but hand-editing is risky because the fileIDs, GUIDs and exact YAML formatting all matter. To pull data out as JSON, do it inside Unity with a small script calling JsonUtility.ToJson on the object, rather than converting the file externally, because GUID references will not survive outside the project. To share an .asset with its dependencies, select it and use Assets › Export Package, which bundles it and its links into a .unitypackage.

Frequently asked questions

Why does my .asset file look like readable text (YAML)?

Because the project’s Asset Serialization is set to Force Text, the default for new Unity projects and the recommended mode for version control. Under Force Binary the same file would be an unreadable blob instead.

Can I edit a .asset file by hand?

You can, but Unity officially does not support it and it is easy to corrupt, because fileIDs, GUIDs and exact YAML formatting all matter. Prefer editing through the Unity Inspector or a script.

What is the difference between .asset and .assets files?

An .asset is a single serialized object inside a Unity project at edit time. A .assets file, like sharedassets0.assets in a shipped game, is a compiled runtime bundle you open with AssetStudio or UABE, not the Unity Editor.

References

• Unity Manual — Format of text-serialized (YAML) files
• Unity Manual — Script serialization (ScriptableObject)
• Unity Blog — Understanding Unity’s serialization language, YAML

Feedback

Was this page helpful?

Yes No

Glad to hear it! Please tell us how we can improve.

Sorry to hear that. Please tell us how we can improve.