A .unitypackage is a compressed archive that stores each asset in a folder named after an identifier, along with its original path and its Unity metadata. The official way to see what is inside is to import it into a Unity project. But if you only want to know what a pack contains, which models it offers and what they look like textured, there is a much more direct route.
You have probably been there: a pack bought on the Unity Asset Store, a free kit downloaded for a prototype, and the urge to check in two minutes whether it fits your game's style. Open Unity, create a test project, import, wait, then clean up: that is a lot for a quick look.
Unity's documentation defines asset packages as collections of files and data from Unity projects, compressed and stored in a single file with the .unitypackage extension. It is one of the distribution formats accepted by the Unity Asset Store. Besides the files themselves, a package carries metadata: import settings and links to other assets.
Unity does not publish a formal specification of this format, but its structure is well known. It is a gzip-compressed tar archive. Inside, each asset has its own folder, named with a string of 32 hexadecimal characters, the asset's GUID. That folder contains:
| File | Role |
|---|---|
asset | The actual content: the FBX, the PNG texture, the material, the prefab… |
asset.meta | The asset's Unity metadata, including its identifier and its import settings |
pathname | A line stating where the asset should land, for example Assets/Props/Barrel.fbx |
preview.png | Sometimes, a thumbnail of the asset |
The project's folders are present as entries too, but without an asset file: they only carry metadata.
The key part is the .meta file. According to Unity's documentation, it contains the asset's unique identifier, which Unity uses internally to refer to it. So a material does not point to ‘Barrel_BaseColor.png’, but to that texture's GUID. If a texture's .meta disappears, the materials that use it lose their reference.
Extracting the archive is not enough. You get one folder per asset, each named with an unreadable GUID, and even if you rename each asset file after its pathname, the essential part is still missing: the assembly.
In a Unity pack, the object you want to see is often a prefab. Unity describes it as a GameObject saved with all its components, their property values and its child GameObjects, as a reusable asset. Prefabs can also be nested inside one another to form complex hierarchies. A lantern might be made of a base, a glass and a handle, each placed at its position, each with its own material.
The full chain looks like this:
Lantern.prefab → mesh (FBX GUID + sub-mesh identifier)
→ material (.mat GUID)
Lantern.mat → textures (GUID of each image) + tint
asset.meta → GUID ↔ actual file pathOpening the FBX on its own in a 3D application can therefore give you a grey or badly textured model: in a Unity pack, the information ‘which texture goes on which mesh’ is carried by the prefab and the material, not necessarily by the FBX. That is why people end up importing the pack into a project. Unity's documentation describes the steps: open a project, go to Assets > Import Asset Package, choose the items in the import window, and Unity places the content in the project's Assets folder.
Eyemesh reads the .unitypackage directly, without Unity and without a project. There are two ways to start:
.unitypackage then appears in the sidebar. Select one: Eyemesh shows its name, its size and an ‘Open’ button. Extraction comes with a percentage progress bar.Once opened, the package appears as an overview: all its models gathered in a single grid of thumbnails, however deep the original folder tree. The sidebar shows the folders rebuilt from the pathname files, if you would rather drill down into Assets/Props/ or Assets/Characters/. A button takes you back to the overview at any time.
A tip for your Unity Asset Store purchases: Unity's documentation states that on macOS, downloaded packages are cached in ~/Library/Unity/Asset Store-5.x, with one subfolder per vendor. Eyemesh finds packages even inside subfolders. In the Finder, Go > Go to Folder takes you there, and you just drag that folder onto Eyemesh to browse all your packs in one place.
The extraction is kept between sessions, so reopening a large pack the second time is almost instant. The size of this cache can be set in the settings (2 GB by default), with the least recently opened packages deleted first, and a ‘Clear Unity cache’ button resets it. A .unitypackage stored inside another one opens the same way.
This is where it all comes together. Eyemesh follows the same chain as Unity: prefab, then material, then texture, resolving each GUID through the .meta files read during extraction.
_Color tint is applied to the base texture, which is what tells apart, for instance, a ‘brown’ door and a ‘grey’ door built on the same image.Eyemesh also does a bit of tidying for you. Raw FBX files already used by a prefab are hidden from the grid, since the prefab shows the textured version. Prefabs that contain only particle effects, with no geometry, are left out too. So the grid shows what matters: one asset, one thumbnail.
With the content in front of you, you can make an informed decision. A few quick reflexes:
Once you have chosen a pack, you import it into Unity knowing exactly what you want from it, instead of filling up a test project. This is the same logic as the inventory step described in our guide to organising your 3D game asset library: look before you tidy, and before you import.
A prefab found in a package can leave the archive in a standalone form.
Remember to record the pack's provenance when you take a model from it: the method is in tracking your asset licences. All the details of the support are on the Unity packages page.
You can extract it, since it is a gzip-compressed tar archive. You will get one folder per asset, named after its GUID, with the asset, asset.meta and pathname files. You then have to rebuild the folder tree from the pathname files, and the most important part is still left to do: linking prefabs, materials and textures. That is exactly the work Eyemesh does automatically.
Because the link between mesh and texture is described by the pack's Unity files: the prefab designates a material, the material designates textures, all by GUID. The FBX alone does not necessarily carry that information. By opening the prefab rather than the FBX, you get the model as the vendor put it together.
Depending on the macOS version, Preview and QuickLook display some 3D formats (USDZ, OBJ, STL, glTF…), but FBX and .unitypackage are not among them. For the other 3D formats in your library, the Eyemesh QuickLook extension adds a space bar preview in the Finder.
On macOS, Unity's documentation gives the folder ~/Library/Unity/Asset Store-5.x, with one subfolder per vendor. This cache covers asset packages in the .unitypackage format. Open that folder in Eyemesh to see all your purchases as thumbnails.
No. Eyemesh extracts a copy into its own cache and reads that copy. The original .unitypackage stays exactly as you downloaded it, ready to be imported into Unity.
Open your first .unitypackage in Eyemesh and browse its prefabs, assembled and textured, without Unity or a test project. 7-day free trial.