UNITY3D File Documentation

Summary

A .unity3d file is a packaged build from the Unity game engine, historically the data file for a browser game that ran in the now-dead Unity Web Player plugin. Browsers removed the NPAPI plugin interface in 2015–2016 and Unity ended Web Player support with Unity 5.4, so a .unity3d will not play in any modern browser. It is a serialized asset container (the same format as a Unity AssetBundle), not a file you open by hand. To recover its meshes, textures and audio, use an extractor such as AssetStudio.

Technical details

FeatureValue
Full nameUnity Web Player Data File
File extension.unity3d
MIME typeapplication/vnd.unity
Format typeBinary serialized container of Unity assets (the AssetBundle build)
DeveloperUnity Technologies
IntroducedMid-2000s (Unity Web Player)
StatusDeprecated — Web Player ended with Unity 5.4 (2016)
Cause of deprecationBrowsers removed NPAPI plugin support (Chrome, 2015)
Successor deliveryUnity WebGL builds (plugin-free)
Open standardNo — proprietary, undocumented serialization
Signature (older builds)55 6E 69 74 79 57 65 62 (ASCII UnityWeb)
Signature (newer bundles)ASCII UnityFS
CompressionLZMA / LZ4 asset blocks
HoldsScenes, meshes, textures, materials, audio, compiled scripts
Related extensions.unity, .assets, .bundle
Extraction toolAssetStudio (open source)
Specificationdocs.unity3d.com/Manual/AssetBundlesIntro.html
File signature (magic bytes)
55 6E 69 74 79 57 65 62

Offset 0. In ASCII this reads UnityWeb, the tag on older Web Player .unity3d builds. The same serialized container later evolved into the Unity AssetBundle, whose newer builds begin with the ASCII tag UnityFS instead. In both cases a version string follows the tag. The rest of the byte layout is proprietary and undocumented, so the leading ASCII tag is the reliable way to identify the file and its build era.

What is a .unity3d file?

A .unity3d file is a build artifact from the Unity game engine made by Unity Technologies. Its classic meaning is the Unity Web Player data file: when Unity could publish games to the web, an entire project was compiled into a single streamed .unity3d that the Unity Web Player browser plugin downloaded and ran. Technically it is a serialized, usually LZMA-compressed container holding all of a game's assets — scenes, 3D meshes, textures, materials, audio clips and compiled scripts — in Unity's proprietary binary serialization format.

The same underlying container is what Unity later exposed as the AssetBundle, which is why modern Unity bundles share the format and simply carry a different tag (UnityFS rather than the older UnityWeb). Understanding a .unity3d therefore means understanding two things: the serialized bundle layout, and the fact that the runtime meant to load it — the Web Player — no longer exists.

Why the Web Player is dead: NPAPI removal

The Unity Web Player relied on NPAPI, the old Netscape Plugin Application Programming Interface that browsers used to embed native plugins. Google removed NPAPI support from Chrome in 2015, and Mozilla and Microsoft followed. Without NPAPI there is no mechanism for the plugin to run inside a page. Unity officially ended Web Player support with Unity 5.4 in 2016 and steered developers to WebGL builds, which run plugin-free by compiling the game to run directly in the browser's own runtime.

The practical consequence is blunt: a .unity3d Web Player file from that era will not run in any current browser, and there is no plugin to reinstall to make it work. This is not a missing-codec problem that a download fixes; the entire delivery mechanism was removed from the web platform. The only ways to run an old Web Player game are an archived standalone Web Player runtime or a game-preservation project that re-hosts the title, both outside the browser.

The bundle layout: tag, header and compressed blocks

A .unity3d begins with an ASCII signature tag that identifies both the format and its era. Web Player builds start with UnityWeb (hex 55 6E 69 74 79 57 65 62); the AssetBundle evolution starts with UnityFS. A version string follows, naming the Unity engine version that produced the file.

Signature tag     'UnityWeb' (Web Player) or 'UnityFS' (AssetBundle)
Version string    the Unity engine version that built the bundle
Bundle flags      compression method and block layout
Compressed blocks LZMA/LZ4-compressed serialized asset data
Serialized objects scenes, meshes, textures, materials, audio, scripts
Type/object tables internal tables mapping object IDs to serialized data

After the header, the payload is a set of compressed blocks. Decompressing them yields Unity's serialized objects: each asset (a mesh, a texture, an audio clip, a MonoBehaviour script) is written as a typed object, and internal tables map object IDs to their positions so the runtime can resolve references between them. The exact byte layout is proprietary and undocumented on purpose — part of the point of the serialized container is to make casual extraction harder — but the leading tag and the object-table structure are well understood by the community tools that read it.

Extracting meshes, textures and audio

Because there is no consumer viewer, the realistic thing to do with a .unity3d is extract its contents. The standard tool is AssetStudio (free, open source): load the file, and it lists the meshes, textures, sprites, audio clips and other objects it found. From there you export 3D models to FBX or OBJ and textures and sprites to PNG. This is extraction, not a one-click file conversion — you are pulling individual objects out of the serialized bundle, not transforming the bundle into another format.

Two conversions people ask about do not exist. You cannot turn a .unity3d into a runnable .exe: the bundle is asset data, not a program, and only the original Unity project (with its source scripts) can be built into a standalone executable in the Unity Editor. And there is no Unity-to-Revit path — a .rvt is an Autodesk BIM model in an unrelated domain, so any tool claiming to convert one is bogus.

The developer's side: AssetBundles from a Unity project

For a Unity developer, the same format is a normal part of the pipeline rather than a dead browser artifact. The Unity Editor builds AssetBundles from a project so that assets can be downloaded and loaded at runtime, keeping the initial game download small and letting content update without shipping a new binary. The Editor is the tool that creates these bundles; it does not “open” an arbitrary third-party .unity3d as a project to play, because the bundle contains built assets, not the editable source project. That distinction is why a datamined bundle can be inspected and extracted but not simply loaded back into the Editor as a working game.

Frequently asked questions

How do I play a .unity3d Web Player game?

In a modern browser you cannot. The Unity Web Player relied on NPAPI, which browsers removed in 2015–2016, and Unity discontinued Web Player support with Unity 5.4. The only options are an archived standalone Web Player runtime for offline play, or a preservation project that re-hosts the game.

How do I extract models or textures from a .unity3d file?

Load it in AssetStudio, browse the asset list, and export meshes to FBX or OBJ and textures and sprites to PNG. AssetStudio reads Unity's proprietary serialized format, which normal image and 3D tools cannot.

What is the difference between UnityWeb and UnityFS?

They are the leading ASCII tags of the same container at two points in its history. UnityWeb marks an older Web Player .unity3d; UnityFS marks the newer AssetBundle format the container evolved into. Both are followed by the Unity engine version that built the file.

References