Importing Assets

Awaken reads Unity, Godot, and Unreal packages - plus glTF, OBJ, and image files - directly in the browser, with no re-export step. This page explains the pipeline, the three ways to start an import, and exactly what comes across from each source.

How importing works

Every engine-package importer - Unity, Godot, and Unreal - funnels its data through one shared import IR (intermediate representation) called SceneImport. A loader's only job is to translate its own file format into that neutral shape - decoded mesh geometry, encoded texture bytes, a node tree with transforms, materials, lights, cameras, and colliders - all already converted into Awaken's coordinate space (right-handed, Y-up, metres). A single consumer then turns that IR into real project assets. (A single .glb/.obj/image takes a lighter, direct path instead - see below.)

Because there is exactly one consumer for engine packs, every one of them benefits from the same treatment: lossless vertex welding, device-neutral texture storage, static-batching flags on scenery, and hardening that clamps out any NaN/Inf that a corrupt file might carry.

The distinction that trips people up first: engine packs import into the Library, not the live scene. A .unitypackage or .zip gives you prefabs to drop and scenes to open - nothing spawns automatically. A single .glb/.obj/image, by contrast, lands directly (a model into the current scene, an image as a texture asset).

Three ways to import

Entry point	Where	Best for
File ▸ Import Model…	The Toolbar menu	A single model file
+ Import	The Asset Browser header	Models, images, or engine packs
Drag and drop	Anywhere on the editor window	Everything, including whole folders

Drag-and-drop is the most capable path. Multiple selected files are imported in sequence, with any .awakenprefab imported last so its dependencies are already present.

All three entry points accept the same file types:

.zip  .rar  .7z  .tar  .tgz  .tar.gz  .tar.bz2  .tar.xz  .unitypackage
.glb  .gltf  .obj  .fbx  .3ds
.png  .jpg  .jpeg  .webp  .bmp  .gif  .tga  .svg
.ttf  .otf  .woff  .woff2
.opus  .ogg  .mp3  .wav  .m4a  .aac  .flac  .mid  .midi
.pdf  .txt  .md  .markdown  .rtf  .nfo
.awakenmat  .awakenscript  .awakenanimgraph  .awakenprefab  .awakenfx

Importing several files, a folder, or any archive

A zip that is not a Godot or Unreal project, a .rar, .7z or tar archive, a dropped folder, or several files dropped together is imported best-effort: everything the editor can read goes into the library, what it cannot is skipped and counted, and one failing file never stops the rest (apps/editor/src/state/importLoose.ts).

• Models (glTF, OBJ, FBX, 3DS) become prefabs, and every image becomes a texture, through one shared import into the library.
• Sounds, fonts, documents and Awaken asset files import as they do when dropped alone.
• Archives inside the set are opened: a zip, .rar, .7z or tar archive is walked as a folder (or imported as a project if it is one), and a .unitypackage takes the Unity path. Nesting is followed 4 levels deep.
• Operating-system litter (__MACOSX/, .DS_Store, Thumbs.db, desktop.ini, ._* files) is ignored and not counted.

A texture is linked to a model only when the model file names it, looked up in this order:

1. the path relative to the model's folder;
2. the same file name anywhere in the set (models often carry their author's absolute paths);
3. the same name in another image format (wood.tga named, wood.png shipped).

The Console gets one summary line: what came in and from where, what was skipped by extension, then one line per failure. This is how a glTF with an external .bin and texture files, or an OBJ with its .mtl and maps, imports with its materials intact.

.rar, .7z and tar archives are read by libarchive compiled to WebAssembly. The reader (about 1 MB) downloads the first time you import one of these archives. A password-protected archive is refused with a message saying so; a damaged one is reported in the Console and nothing is imported from it.

Files from 3D apps

A .blend (Blender), .max (3ds Max), .ma/.mb (Maya), .c4d (Cinema 4D) or .skp (SketchUp) file is the app's own save file, and only that app can read it. Godot and Unity open .blend files by running a copy of Blender installed on the same computer, which a browser page cannot do. Export the model from the app instead:

• Blender: File ▸ Export ▸ glTF 2.0 (.glb/.gltf), keep the format as glTF Binary (.glb), and import the .glb.
• Other apps: export glTF (.glb), FBX or OBJ, and import that file.

Importing one of these files shows the same steps in a dialog.

Audio imports as a sound named after the file. That includes .mid: a score is not a recording and nothing decodes one, so the engine performs it on a built-in General MIDI synthesiser - which is how 18 minutes of music fits in 17 KB.

Support matrix

What actually comes across, feature by feature. ✓ Full · ◐ Partial · – Not supported. These reflect what the importers do today (audited against the source), not aspirations.

Feature	Unity .unitypackage	Godot .zip	Unreal .zip	glTF / GLB	OBJ	Images
Meshes & geometry	✓	✓	◐	✓	✓	–
Materials & textures	✓	◐	◐	◐	–	✓
Scene tree & transforms	✓	✓	◐	✓	◐	–
Lights	✓	◐	✓	–	–	–
Cameras	✓	✓	–	–	–	–
Colliders & physics	✓	◐	–	–	–	–
Terrain	✓	–	✓	–	–	–
Sky & post-FX	✓	◐	◐	–	–	–
Particle systems	◐	◐	–	–	–	–
Skeletal animation	◐	–	–	✓	–	–
Prefabs & instances	✓	✓	–	–	–	–
In-game UI (HUD)	◐	–	–	–	–	–
Destination	Library	Library	Library	Live scene	Live scene	Library

Notes on the partial cells:

• Unity materials carry albedo and normal maps plus scalar metallic, roughness and opacity; metallic/roughness/occlusion maps are not applied. A Unity Shader Graph shipped in the pack is transpiled when it does something the flat PBR fields cannot reproduce. glTF materials import the base-colour factor only, with no texture maps. OBJ has no .mtl parsing, so meshes arrive a neutral grey.
• Unity scene tree keeps the GameObject hierarchy, and resolves every instance's world transform including mount points inside nested prefabs. Godot and glTF keep the full node tree too. A scene's own MonoBehaviours are converted into scripts and attached to the objects Unity put them on.
• Lights: Unity and Unreal import directional, point and spot. A spot arrives as a cone with its angle; the source's inner angle is not carried, so the edge feathering over the outer quarter of the cone is proportional rather than authored. Godot still collapses SpotLight3D to a point light, so a Godot spot washes its surroundings instead of throwing a beam. Area lights are skipped everywhere.
• Skeletal animation imports from glTF (skins, skeletons and its own clips) and from Unity, whose pack clips are imported and retargeted onto characters; hands and fingers are left at bind pose. Non-humanoid Unity skinned meshes arrive at bind pose. Godot and Unreal skins are not animated.
• In-game UI is Unity-only: a uGUI HUD/menu Interface pack imports its sprite art as textures, its uGUI widget prefabs and assembled screens as draggable Awaken UI prefabs, its .anim clips as UIClips, and its .ttf/.otf fonts as @font-face. Navigation labels set by the pack's runtime scripts stay as their placeholder. See Unity.
• Unreal is the youngest importer. It reads static-mesh geometry, textures, landscape terrain with its splat layers, and material expression graphs, which it translates into node shaders (28 of the 39 engine functions a surveyed pack used). No cameras, colliders, or prefabs yet.
• Particle systems are approximated, not reproduced. A Unity ParticleSystem or a Godot GPUParticles3D/CPUParticles3D becomes a Awaken particle effect asset plus a ParticleEmitter on the node, carrying the concepts both engines share - rate, bursts, lifetime, shape, speed and spread, gravity, colour and size over life. Trails, sub-emitters and emission-by-distance import from both. Anything richer is sampled down: source curves and gradients keep their endpoints, Godot's explosiveness becomes either a burst or a continuous rate, and its damping is converted to exponential drag. The renderer's draw material supplies the sprite texture, tint colour, and blend mode (additive vs bounded alpha) for both Unity and Godot; a system with no readable draw material falls back to the procedural round sprite with additive blending. Expect to open the effect and tune it.

In this section

• The Import Dialog - the options modal for engine packs: file tree, include/exclude, type filters, preview pane, and the texture size cap.
• Unity (.unitypackage) - the fullest importer: meshes, PBR materials, colliders, terrain, sky and post-FX, prefabs, posed characters, and uGUI HUD import from Interface packs.
• Godot (.zip) - node tree, ArrayMesh and primitives, colliders, instanced scenes, materials, lights, and cameras.
• Unreal (.zip) - current partial support and an honest list of the gaps.
• glTF / GLB / OBJ & Images - single models as a Library prefab plus one instance in the scene, and image → texture + material.
• Textures & Terrain - decode options, the size cap, device-neutral storage, and Unity terrain baking.
• Colliders, Skeletons, Lights & Cameras - what physics and animation data survives the trip.

See also

• Scenes & the World - where imported prefabs and scenes live
• Prefabs - dropping imported models into your scene
• Render Pipeline Overview - how imported materials and sky settings are drawn
• Mesh Format - welding and the quantized on-disk geometry