Jatify Asset Shelf All Jatify projects

Asset Shelf

Every asset of every 3D pack you own in one grid — Fab, itch.io or loose files — and one click to send it to Unreal, Blender or Unity.

A desktop browser for your library of 3D asset packs: every asset of every pack in one grid with its picture, filters by kind, tag, pack and licence, and buttons to send what you picked to Unreal, Blender or Unity, with everything it needs.

It reads Unreal packs (from Fab or the old Unreal Marketplace) and loose files (FBX, glTF, OBJ, .blend, Unity packages, from itch.io or anywhere). Unreal packs are indexed without Unreal: the asset list, details, dependencies and the Content Browser’s own pictures are read straight from the .uasset files.

Status: 0.1, used daily on Linux; Windows and macOS are untested.

What it does

  • One grid for everything. Kinds as tabs (meshes, characters, animations, effects, sounds, blueprints, maps, materials, textures), tags, packs and licences as filters, search, collections, favourites, notes and saved filters.
  • What comes with an asset. Each asset lists the packages it needs (followed through the pack) and what works with it (animations on the same skeleton, blueprints that use it). Duplicates shipped in several packs are linked.
  • Packs view. Every pack with its store pictures, description and licence, and a preview of its assets.
  • Send to Unreal. Copies the asset and everything it needs into the project’s Content at the same paths, after a preview of what will be copied. Never overwrites. Flags packs saved with a newer Unreal than the project, packs with C++ code or plugins, and anything that could run code (the safety scan).
  • Send to / Open in Blender. Imports into the open Blender (through the add-on) or a new Blender window, with the materials wired: base colour, normal (DirectX for Unreal assets), roughness, metallic, packed ORM maps, emission.
  • Send to Unity. The model, the textures its materials use, and Unity materials for the project’s pipeline (URP, HDRP or Built-in), with the import settings written so normal maps and data maps come in right.
  • Send to Groundwork. Meshes become self-contained .glb files (textures embedded, capped at 2048 px; origin at the base, metres, Y up) delivered to Groundwork’s inbox (~/.local/share/Groundwork/inbox, %LOCALAPPDATA%\Groundwork\inbox on Windows); the open map takes them in, and the status bar shows Groundwork’s answer.
  • Sounds by what they sound like. Measured from the audio (no AI): length, loudness, pitch, brightness, attack, clean loops, channels. Filter and order the Sounds tab by them and play a sound from its details.
  • Prepare a model (with Blender). Check it for holes, inside-out faces and stray specks; repair, lighten, add LODs and a collision shape; export for Unreal, Godot, Groundwork or Blender, with a report. The asset is never changed.
  • Spin in 3D. A turntable rendered once by headless Blender, turned by dragging.
  • Free sources. Poly Haven (models and textures; powered by Poly Haven) and ambientCG (materials), all CC0: pick from their catalogs, and the assets come in with their provenance filled in. Kenney’s packs come through itch.io: claim the free ones on kenney.itch.io, and the itch.io sync brings them in.
  • Library sync. Fab (sign in with your Epic account) and itch.io (an API key): what is new or updated, downloaded and checked file by file, then indexed. A preview first; nothing is downloaded until you say so.
  • Debug log (View > Debug log, Ctrl+Shift+L): every step with its timing.

Download

Releases have packages for Linux (x64: an .AppImage, or a .tar.gz) and Windows (x64, .zip). The AppImage is one file: make it executable and run it (an AppImage launcher such as Gear Lever adds it to the app menu). The archives unpack anywhere; run AssetShelf (AssetShelf.exe), and on Linux ./install-desktop-entry.sh adds it to the app menu with its icon (run it again after moving the folder; --remove takes it out). .NET and Python are included. Blender, Python and Unreal are found on the PATH or set in settings.json (Blender). Windows builds are made by the same CI but not yet tested on Windows; reports are welcome.

To make a release: push a tag such as v0.2.0 (.github/workflows/release.yml builds the packages with scripts/package.sh and publishes them).

Requirements

ForNeeds
The appnothing for a release package; the .NET 10 SDK to build from source
Indexing Unreal packsnothing more (ShelfIndex, .NET)
Exporting Unreal meshes, characters and animations to Blender/Unity/Groundworknothing more: meshes, skinned characters with their skeleton, animations (UE 4 and UE 5, including 5.2+ sequencer data) and textures wired as each material uses them are read straight from the packages (ShelfIndex)
Exporting other Unreal assets (effects, blueprints, maps)Unreal Engine 5.8 or later. On Windows the app offers to install it through Epic’s launcher (installing the launcher too) when none is found; elsewhere put it in ~/UnrealEngine or set UnrealEngine in the settings
Loose files, materials, turntables, Unity prepBlender 5.1 or later on the PATH
Fab and itch.io syncsecret-tool (libsecret) on Linux; the first sync offers to set up its packages (legendary-gl, requests) in ~/.local/share/asset-shelf/venv
Unitya Unity project (tested with Unity 6; glTF models are not handled yet)

Setup

git submodule update --init   # third_party/CUE4Parse
dotnet build app -c Release
dotnet build tools/ShelfIndex -c Release
python3 -m venv tools/.venv && tools/.venv/bin/pip install -r tools/requirements.txt

The Blender add-on is blender/asset_shelf_bridge.py (Edit > Preferences > Add-ons > Install from Disk). The Unreal plugin in unreal/AssetShelf is only needed for the older Unreal-based indexing path (index_library.py --unreal) and for rendered pictures of effects.

Settings live in ~/.config/asset-shelf/settings.json (most are also in the File menu):

{
  "Packs": "/path/to/library/packs",
  "Index": "/path/to/library/index",
  "UnrealProject": "",
  "UnityProject": "",
  "UnityFolder": "Assets/AssetShelf",
  "UnityMirrorPack": false
}

Run with dotnet run --project app -c Release (add --debug to open the log on start).

Sharing a library with a team

Put the library folder (holding packs/ and index/) on a file server (SMB, such as a NAS) and give each team member an account there with read-only access to it. Each member uses File > Connect to a shared library… with \\server\share\folder, a user name and a password. The password is kept by the system (Windows Credential Manager; on Linux the keyring, and the share is mounted with GNOME’s gvfs-smb). A library the user cannot write to opens in member mode: Sync and sign-in are hidden, so only the owner syncs and indexes it. The connection is kept as Share and ShareUser in the settings.

A team library server

On a team whose machines share a Tailscale network, the library can be served by server/ShelfServer instead (see server/README.md). Nobody signs in: the server asks Tailscale who is connecting and finds them in the team list. Asset Shelf uses the server given by File > Team server…, or by JATIFY_TEAM (host or host:port, port 8781 by default) when it is started by a launcher. It mirrors the index into ~/.cache/asset-shelf/team/<host>, fetches pictures as they are shown and pack files when an asset is sent, and opens in member mode. The same server keeps maps and props that teammates publish from other tools.

From the command line

shelf (beside the app in a release; dotnet run --project cli/Shelf -- in a checkout) searches the same library, shows a pack or an asset, and pulls an asset into a project, with a line in AssetShelf.provenance.jsonl and the pack’s licence text beside it:

shelf search tavern table --kind Mesh
shelf show <asset id>
shelf pull <asset id> --to ~/my-game/assets            # a model file (glTF) with its textures
shelf pull <asset id> --to ~/MyUnrealProject --format unreal

Search by meaning (“a person wielding a sword”, whatever the files are called) is an add-on, shelf-meaning (addons/ShelfMeaning, its own download on the release page, shelf-meaning-<version>-<platform>), installed on its own: it runs Google’s SigLIP 2 on this computer (downloaded once, about 1.5 GB) over each asset’s picture. Asset Shelf and shelf carry no model and no AI library; with the add-on beside shelf or on the PATH, shelf search --meaning "…" and --like <asset id> work, otherwise they say so. shelf-meaning embed --pack <id> reads a pack’s pictures once (vectors kept beside its index).

shelf install-skill adds a Claude Code skill (skills/asset-shelf/SKILL.md) so a coding agent in a game project finds and pulls assets the same way, and never copies from the library by hand.

Library layout

<packs>/<pack>/unreal/Content/...        an Unreal pack (or a whole sample project)
<packs>/<pack>/unreal.manifest           the Epic manifest it was downloaded from (Fab sync, verify_pack.py)
<packs>/<pack>/raw/<format>/...          loose model files and archives (unpacked beside themselves)
<index>/<pack>/index.json                one entry per asset: class, details, dependencies, who uses it, picture
<index>/<pack>/thumbs/                   pictures
<index>/<pack>/pack.json                 store data: title, seller, licence, url, description, cover, gallery
<index>/<pack>/safety.json               the safety scan's findings

Tools

ScriptDoes
tools/index_library.pyindexes every pack that has no index yet (`—kind unreal
tools/ShelfIndexindexes one Unreal pack without Unreal (CUE4Parse; only the files’ headers are read); export --job writes a mesh, character or animation as .glb, its textures as PNG and how its materials use them (materials.json), also without Unreal
tools/index_raw.pyindexes one pack of loose files with headless Blender
tools/safety_scan.pylists what in a pack can run code (startup scripts, binaries, C++, plugins, config commands)
tools/export_fbx.pyexports one Unreal asset to FBX and its textures, in a small throwaway project
tools/fab_sync.pyEpic sign-in and the Fab library sync
tools/itch_sync.pyitch.io sign-in and library sync
tools/verify_pack.pychecks a downloaded Fab pack against its manifest
tools/picture_report.pywhich assets have a picture, and from where

Run heavy ones under a memory cap, for example systemd-run --user --scope -p MemoryMax=6G -p MemorySwapMax=0 ....

Notes

  • Licences. Asset Shelf shows each pack’s licence as the store states it; reading and following it is up to you. Store-bought assets may not be redistributed: keep your library out of public repositories.
  • Fab sync uses the Epic launcher’s sign-in and Fab’s launcher endpoints, as legendary and Heroic do. They are not documented by Epic and can change. The launcher client credentials in fab_sync.py are the public ones those projects use; your own token is kept in the system keyring.
  • itch.io sync uses itch.io’s public API with your API key, also kept in the keyring.

Contributing

Contributions are welcome: see CONTRIBUTING.md.

License

MIT, see LICENSE. Third-party parts and their licences are listed in NOTICE.md.

Changelog

What each Asset Shelf release lets you do, in plain words. The team server, ShelfServer, has its own versions and its own list: server/CHANGELOG.md. Each release’s notes on GitHub are its section below.

Entries before 0.2.0 were written afterwards, from the git history.

[0.3.0] - 2026-11-18

New

  • shelf, Asset Shelf from the command line: search the library, show a pack or an asset (licence, credit, conditions, original source, picture), and pull an asset into a project as a model file with its textures, into an Unreal project, or as its loose files. Each pull records where it came from and copies the pack’s licence text. It refuses a pack whose safety scan found code unless you insist. It uses the team library when a team server is set.

  • Search by meaning, as an add-on: shelf-meaning, installed on its own (its own download on the release page), finds assets by a description or by likeness to another asset, from their pictures, with a model run on this computer. Asset Shelf and shelf work without it and carry none of its libraries; shelf search --meaning uses it when it is there.

  • A sound browser. A pack’s sounds can be measured from their own audio, no AI involved: length, how loud they get, a pitch estimate, how bright they sound, attack, whether they loop cleanly, mono or stereo. The Sounds tab then filters and orders by those (a new Sound group), a sound’s details show them, and Play plays it through the system’s player. shelf search --sound long,low,oneshot … does the same for an agent. You still pick every sound. Packs are measured by tools/index_library.py --sounds (new packs as they are indexed).

  • Mesh prep (optional, with Blender): Prepare… on a mesh or character looks the model over (holes, faces turned the wrong way, stray specks, separate parts, triangles, size), and can repair it, lighten it to a triangle budget keeping the shape, make lighter LODs and a collision shape, and export it for Unreal, Godot, Groundwork or Blender. A report says what was found and done, and the axes and units used. The asset itself is never changed: everything goes into a folder you choose. shelf prep does the same. Without Blender the button is not there.

  • Free assets from Poly Haven and ambientCG (File > Get free assets…): search a source’s catalog, tick what you want, choose the texture resolution, and the ticked assets are downloaded (every file checked), indexed, and filed with where they came from, who made them and their CC0 licence (a copy of the text is kept). An asset already downloaded is marked, and one changed since shows as updated. A pack of texture maps becomes a material in the grid.

  • A Claude Code skill (shelf install-skill), so a coding agent in a game project finds and pulls assets the same way.

  • Crash reports. If Asset Shelf closed unexpectedly, the next start asks whether to send that run’s log to your team’s server. You can see exactly what is sent first. Nothing is sent unless you click Send, and nothing is asked when no team server is set. Each run now keeps its log in ~/.cache/asset-shelf/runs (the last 10 runs).

  • Assets from sites that collect other people’s assets. Mark a pack’s site as one in Origin…, or let Asset Shelf recognise a known one. Each of its assets then gets an “Original” field in its details, for the creator and the page where it was first published, which also goes into the project’s provenance record when you send it. A new Origin filter, “Originals not recorded”, shows the packs with assets still missing one. Such sites have been found mixing in assets they had no right to, and the original source is what lets you trace and remove one.

Not tested yet

  • None of this has been tried on real Windows. The Windows build is made and packaged, but crash reports, shelf, the meaning add-on, the sound browser’s Play, mesh prep and free sources were tested on Linux only.

[0.2.0] - 2026-11-17

New

  • Use your team’s library from a team server. Set the address in File > Team server…, or let the Jatify Launcher pass it on (JATIFY_TEAM). The server knows who you are through Tailscale, so there is no account to make and no password to type. The status bar shows who you are connected as and your role. If the server can’t be reached, Asset Shelf says so and lets you retry or carry on with the library on your computer.
  • No file share needed for teammates. Asset Shelf keeps a copy of the library’s index on your computer, fetches pictures as they come into view, and downloads a pack’s files only when you send one of its assets.
  • Your team’s maps and props in the grid. Maps published from Groundwork and props published from Prop Generator appear as two packs, “Team maps” and “Team props”, with a new Props tab. Each one shows its picture (when it has one), who published it, when, and every kept version. “Save the zip…” puts a copy in your Downloads folder.
  • Delete from the team. The team’s owner and admins can delete one version, or a whole map or prop.
  • Where each pack came from. Record a pack’s origin, its licence text and its receipts (Origin… in the pack’s details), with filters for packs whose origin, licence or receipt is missing.
  • Asset Shelf says when the team server is older than it needs, and what won’t work until it is updated.

Fixed

  • Names the team server sends are checked before anything is written to disk, so a misbehaving server can’t write outside Asset Shelf’s own cache folder.

Not tested yet

  • The team connection has not been tried on real Windows. It was tested on Linux against a real team server.

[0.1.5] - 2026-11-15

New

  • Export without Unreal. Meshes, characters and every kind of animation can go to Blender, Unity and Groundwork without Unreal Engine installed. Unreal is only needed for Send to Unreal and for effects, blueprints and maps.
  • A new look shared with the other Jatify tools: top bar, a split Send button that remembers the last target, tabs, tiles and status bar.

Fixed

  • Finding Unreal Engine trusts only Program Files. An install anywhere else is shown and asked about, also during the guided install. Paths with hidden or reversed characters are ignored, so the confirmation shows the real path.

[0.1.4] - 2026-11-15

New

  • Nothing to install for the tools. The release carries its own Python, used before any Python on your system.
  • Unreal Engine installed for you on Windows. When an export needs Unreal and none is found, a window installs the Epic Games Launcher (from Epic’s official installer) and opens the engine’s install. Asset Shelf waits for it, then carries on with the send. Exports use Unreal Engine 5.8 or later.

[0.1.3] - 2026-11-15

Fixed

  • Shared libraries connect on Windows. Connecting opens the share with the account you give, replaces an older connection to the same server made under another account, and shows Windows’ own error message instead of an empty library. The password is kept in Windows Credential Manager and used to connect again at start.

Not tested yet

  • Not tried on a real Windows machine when it was released.

[0.1.2] - 2026-11-15

New

  • Send to Groundwork. Meshes become self-contained .glb files (textures inside, at most 2048 px; origin at the base, Y up) that go straight into Groundwork’s inbox. The status bar shows Groundwork’s answer.
  • Connect to a shared library (File menu): a folder on a file server such as a NAS, with an account there. The password is kept by the system and used to reconnect at start. A library you can only read opens in member mode, so only its owner syncs and indexes it.

Not tested yet

  • Connecting on Windows, and on Linux through GNOME’s gvfs-smb, had not been tried when it was released.

[0.1.1] - 2026-11-14

New

  • A new icon: an orange library folder with a cube on the front.
  • Linux AppImage, and an install-desktop-entry.sh in the tar.gz that adds Asset Shelf to your app menu.

[0.1.0] - 2026-11-14

The first public release, for Linux and Windows.

  • One grid for your whole asset library (Fab/Unreal packs and loose files), with kinds as tabs, filters by tag, pack and licence, search, collections, favourites, notes and saved filters.
  • What comes with an asset (the packages it needs) and what works with it. Duplicates across packs are linked.
  • A Packs view with each pack’s store pictures, description and licence.
  • Send to Unreal, Send to / Open in Blender (with materials wired), Send to Unity (URP, HDRP or Built-in materials), and Spin in 3D.
  • Library sync from Fab and itch.io, with a preview before anything is downloaded.
  • A safety scan that flags anything in a pack that could run code. Pictures are checked for size before they are decoded, and the Blender add-on strips scripted drivers from what it imports.