Skip to content

Asset Browser ​

The Asset Browser lists everything in your project - scenes, meshes, textures, UI images, fonts, materials, prefabs, effects, animations, and scripts - and is where you import new content, create new assets, and drag things into your scene or onto objects.

It has two ways to organise the same assets: Type view (grouped by kind) and Folders view (grouped by the folder each asset was imported from).

Type view ​

The default view groups assets by kind. The left column is a set of tabs, each with a live count:

TabContents
AllEverything
ScenesSaved scenes (▣) - the entry scene is marked ★
MeshesImported meshes (◼) - built-in primitives (cube, sphere, …) aren't listed here; add them from the Viewport or Hierarchy menus
TexturesImages, shown as thumbnails (▦)
UI ImagesImage files kept for UI elements only (◩), shown as thumbnails. See UI images and fonts
FontsFont faces (A), listed by file and family. See UI images and fonts
MaterialsLegacy PBR presets, shown as colour swatches (●)
ShadersHook-based and node-graph shaders (◈)
Particle EffectsAuthored particle effects (✷)
PrefabsSaved prefabs (❖)
AnimationsImported rig-space clips (➤)
Anim GraphsAnimation state machines (◫) - see Animation
AudioImported sounds (♪) - recordings and MIDI. Double-click to audition
DocsPDFs, READMEs and licences that came with an imported pack (⧉)
ScriptsEverything in the Code panel (ƒ): TypeScript behaviours and libraries, editor scripts, plugins, and AssemblyScript/C modules

An empty tab tells you how to fill it - the Particle Effects tab points at + New Effect, the Meshes tab at + Import, and so on.

The Asset Browser in Type view after importing four character models: the category column (All / Scenes / Meshes / Textures …) with counts, the grid of mesh tiles, the search box and + Import.

Folders view ​

Toggle to Folders to browse assets by their import-source path - the pack a mesh came from, the folder a texture lived in. The left column becomes a folder tree (click a folder to open it, use the twisties to expand); the main area shows a breadcrumb trail and the current folder's subfolders and assets. Drag the splitter between the two columns to resize (the width is remembered).

Folders view is the fastest way to find one asset inside a large imported pack - narrow to a folder rather than scrolling thousands of items.

Searching and sizing ​

  • The search box filters the current view by name; Esc clears it.
  • The item-size slider (▤ … ▦) ranges from a tight list (leftmost) to a large icon grid (rightmost). Your choice is remembered.

Everything matching is rendered - there is no "+N more" cap - but a 600-clip animation library is still far easier to work through by narrowing with search or by switching to Folders view.

Opening and dragging assets ​

A single click does the primary action for each kind; a double-click adds or opens where that makes sense.

A texture asset selected in the Asset Browser: its inspector shows the image, its size, Always include in exports, Apply to Selection and Create Material.

AssetClickDouble-click
SceneOpen it (asks to confirm - it replaces the current scene)-
ScriptOpen it in the Code Panel-
Anim GraphOpen it in the Anim Graph tab-
PrefabSelect it (shows in the Inspector)Add an instance to the scene
ShaderSelect it (Inspector)Open it in the Shader Editor
Particle EffectSelect it (Inspector preview + stats)Open it in the Particle Editor
AnimationSelect it (Inspector)Apply the clip to the selected character's Animator
DocumentOpen it - PDFs in a browser tab, text/Markdown in the InspectorSame
Mesh / Texture / MaterialSelect it (Inspector)-
UI Image / FontSelect it (Inspector)-

Selecting a mesh, texture, UI image, font, material, prefab, shader, particle effect, animation, or document shows it in the Inspector for a preview and per-kind actions. Scenes, scripts, and anim graphs have no Inspector view - clicking them acts, opening the scene or the relevant editor tab.

Right-click any asset for Delete (it confirms, and it can't be undone). A prefab also offers Export as package…, writing a self-contained .awakenpkg package that carries the prefab plus every asset it references; a particle effect offers Export…, writing a portable .awakenfx file.

Drag an asset out to use it - where you drop it decides what happens:

  • Prefabs and meshes drop into the scene - onto the Viewport to place them surface-snapped under the cursor, or onto the Hierarchy to instance them at the camera focus.
  • Everything else - scripts, materials, shaders, textures, UI images, fonts, animations, anim graphs, particle effects - drops onto a matching field in the Inspector. Each picker only accepts its own kind, so a particle effect can be dropped on a ParticleEmitter's effect slot but not on a mesh field. A UI image or a texture drops on a UI element's image field, a font on its font field. Editor scripts aren't draggable at all (they're run from the Code panel, not attached to objects).

UI images and fonts ​

The UI Images and Fonts tabs hold what in-game UI draws with.

A UI image is an image file kept as its own bytes. It is drawn only by UI elements (their image field, or api.ui.setImage(name, id)), is never decoded or uploaded to the GPU, and ships in the exported game as the same file. Every UI image ships, so one named only in a script still arrives. A font file is one face of a family: a UI element's font field names the family, and the text's weight and style pick the face.

Getting files in:

What you doPNG, JPEG, WebP, GIFSVGTTF, OTF, WOFF, WOFF2
Drop on the UI Images tab, or + Import UI ImageUI imageUI imageImported normally (a font)
Drop on the Fonts tab, or + Import FontImported normally (a texture)Imported normally (a UI image)Font
Drop anywhere else, or + ImportTextureUI imageFont

A file of another kind dropped on either tab goes through the ordinary import, so a model dropped there is still a model. An imported file takes its file name (without the extension) as its id. Importing a file whose id is already in the project replaces that UI image or font, so re-importing an edited icon updates every element that draws it; two files in one import that would share an id become "name" and "name 2". Importing, deleting and every edit below can be undone.

The inspector for a UI image shows it with its format, pixel size and file size, and renames it: a rename updates every UI element that uses it, in the open scene, the scene library and prefabs. A script that names the old id is not rewritten.

The inspector for a font edits the face:

  • Family - the name UI elements use. Guessed from the file name (Fredoka-Bold.ttf is family Fredoka at weight 700); blank means the font's id.
  • Weight - 100 to 900, or Variable (every weight) for a variable font.
  • Style - normal or italic.
  • Licence - free text (for example "SIL OFL 1.1"), kept in the project and not shipped.

It also lists the family's other faces and shows a sample line drawn in the face.

Always include in exports ​

An export ships the textures that something in a scene or prefab uses. A texture that only a script names (api.ui.setImage(name, "id"), a sprite swapped at runtime) is invisible to that check. Tick Always include in exports in the texture's inspector to ship it anyway. The list is saved with the project. UI images do not need it: they always ship.

Keyboard navigation ​

With an asset selected in the grid you can move without the mouse:

  • ↑ / ↓ - select the previous / next asset.
  • ← / → - move through the folder hierarchy (into / out of folders) or across the type tabs, whichever the current view shows.
  • Enter - activate the focused entry: enter a folder, open a scene, apply an animation, and so on.

This makes scrubbing through a large imported pack (say, a folder of animation clips to preview) quick from the keyboard.

Importing and creating ​

The main toolbar (above the grid) carries + Import plus a set of create buttons. Which create buttons you see depends on the current type tab:

ButtonShown onWhat it does
+ ImportAlwaysA file picker for models (.glb / .gltf / .obj / .fbx), images, fonts (.ttf / .otf / .woff / .woff2), sounds, engine asset packs (.zip / .unitypackage), documents, and Awaken asset files (.awakenmat, .awakenscript, .awakenanimgraph, .awakenfx, .awakenprefab, .awakenpkg). You can also drag files straight into the editor window. See Importing assets
+ Import UI ImageUI ImagesA file picker for .png, .jpg, .webp, .gif and .svg files, each imported as a UI image
+ Import FontFontsA file picker for .ttf, .otf, .woff and .woff2 files, each imported as one font face
Export Package…AlwaysOpens the Create Package dialog: tick any assets across types, and it bundles them plus their dependencies into one self-contained .awakenpkg package
+ MaterialAll · MaterialsSnapshots the selected object's current material values into a reusable legacy preset
+ New ShaderAll · ShadersCreates a WGSL-hook shader and opens it in the Shader Editor
+ New Shader GraphAll · ShadersCreates a node-graph shader and opens it in the Shader Editor
+ New GraphAll · Anim GraphsCreates an animation state machine and opens it in the Anim Graph tab
+ New EffectAll · Particle EffectsCreates a particle effect and opens it in the Particle Editor
+ New ScriptAll · ScriptsCreates a game script - a behaviour you attach with a Script component - and opens it in the Code Panel
+ New Editor ScriptScriptsCreates an editor script: a one-off tool you Run over the open scene
+ New PluginScriptsCreates a plugin: an editor extension (panels/tools/commands) you package to share

Each of these creates the asset, selects it, and brings the matching editor tab to the front, so you land in the right place to author it.

Why creation lives here ​

The Code, Material, Anim Graph and Particles tabs are data-gated: with an empty project none of them has a tab in the tab bar - they sit under the … overflow menu. The Asset Browser is therefore the discoverable entry point for every asset type: it is where you make your first script, material, graph, or effect, and creating it is exactly what promotes that tab out of … and into the bar.

See also ​

Awaken: browser-native WebGPU game engine.