How to Optimize 3D Models for Android Scene Viewer

Google's Scene Viewer can display a web-hosted glTF or GLB model in 3D and, on supported Android devices, place it in augmented reality. It is deliberately simple for the customer, which means the artifact has to carry a dependable result. Unsupported extensions, excessive joints, a missing fallback URL, or a 4K texture can turn a product model into a slow launch or an outright rejection.

Optimize against the current Scene Viewer documentation and validator. Record the checked date with every release profile because platform capabilities and recommendations can change.

Understand the delivery route#

Scene Viewer can be launched through a supported web component or Android intent. In either case, host the model over HTTPS and provide a browser fallback. The fallback matters when AR services, the Google app, device capability, policy, or network conditions prevent the intended mode.

Document:

the minimum Android and ARCore-supported device tier;
whether 3D, AR, or both are allowed;
the launch integration and tested parameters;
the GLB URL and immutable version;
the ordinary web fallback URL;
product dimensions and placement behavior;
required animation and audio behavior;
the date and version of validator rules.

Do not make the intent URL the only discovery surface. The product page should contain crawlable title, description, dimensions, materials, controls, and preview imagery.

Design to the published model profile#

Google's current asset guidance recommends 10 MB per model and documents 15 MB as the validator's maximum. It recommends about 100,000 triangles, with 30,000–50,000 described as ideal for many assets; 10 materials; and textures no larger than 2048 × 2048. Treat these as platform boundaries and starting points, not evidence that every asset near them will perform equally.

The documented skin limits include 254 joints, 4 weights per vertex, and 1 UV set per mesh. The validator also checks feature support such as morph targets. Review the official table before every pipeline change instead of trusting a generic glTF exporter preset.

Create a preflight that reports:

total and per-primitive triangles;
materials and alpha-blended materials;
meshes grouped by material;
image dimensions and encoded bytes;
UV sets, joints, and maximum influences;
animation clips, duration, and tracks;
glTF extensions used and required;
root scale, bounds, and orientation;
model and external dependency bytes;
validator errors and warnings.

A 9.8 MB file that meets the recommendation can still decode into hundreds of MiB of texture data or draw slowly because it contains many transparent partitions.

Fix coordinates, scale, and framing#

Scene Viewer expects 1 glTF unit to represent 1 meter and uses the glTF coordinate conventions. Google's guidance identifies +Z as the model's front for presentation. Verify the final artifact by placing it beside a known physical object; do not infer success from a DCC grid whose unit settings may be different.

Put the origin where rotation and placement feel natural. Ground products on their lowest intended contact plane. Remove remote debris that expands bounds, because the viewer uses bounds for framing and manipulation.

Suppose a lamp authored in millimeters is exported without conversion. Its 420-unit height becomes 420 meters instead of 0.42 meter. The mesh is technically valid but commercially unusable. Include numeric dimensions in the release report and compare them with catalog data.

Avoid baked shadows on the ground or photographed environment lighting in base color. Scene Viewer supplies its own environment and can render a contact shadow. Painted-in lighting looks doubled and remains fixed when the user rotates the object.

Reduce geometry without erasing identity#

Remove invisible internals, duplicated shells, construction history, scan fragments, and details smaller than their projected contribution. Retain the main outline, holes, handle clearances, seating gaps, and recognizable edge breaks.

If a model begins at 680,000 triangles, a useful sequence might remove 210,000 hidden triangles, replace 90,000 fastener triangles with normal detail, and simplify curved secondary parts to finish at 72,000. That is safer than asking one decimator for an 89% reduction with no protected features.

Inspect the final triangulation, not polygon counts from the modeling viewport. UV seams, hard normals, material boundaries, and skin attributes can duplicate vertices even when the number of geometric triangles is unchanged.

Scene Viewer guidance recommends one mesh per material. Consolidate tiny partitions that use the same appearance, but do not join distant components merely to improve one counter if it ruins culling or animation. For a single isolated product, the priority is usually compact, coherent primitives.

Build a compatible material set#

Use glTF metallic-roughness materials unless an officially supported extension is deliberately required. Current Scene Viewer documentation lists a limited extension profile, including unlit materials and texture transforms. If an export writes an unsupported required extension, the model may fail rather than gracefully approximate it.

Cap the material palette. Ten materials are already enough for most retail objects. Merge duplicates that differ only by a copied name, atlas small opaque parts where it preserves density, and avoid material slots assigned to no faces.

Transparency is especially expensive and visually fragile in AR. Google's guidance recommends no more than 2 alpha materials. Prefer opaque surfaces and cutout-style coverage where supported and visually correct. Test nested glass, labels, foliage, and thin layered films from every side.

Do not rely on a dark studio reflection embedded in base color to sell metal. Validate materials under the viewer's changing environment. Roughness and normal texture frequencies should remain stable when the product moves from indoor shade to a bright window.

Budget decoded textures#

The documented 2048 × 2048 maximum is a ceiling, not a requirement. Allocate texels by visible size and inspection distance. A logo or instrument face may need 2048 pixels; a uniform underside may need 256.

A 2048 × 2048 RGBA image occupies about 16 MiB for the top level when decoded, or roughly 21.3 MiB with a full mip chain. Six separate maps at that size can approach 128 MiB before the model, viewer, camera, and framebuffer allocations. A 6 MB GLB therefore can create far more than 6 MB of runtime memory.

Resize source photography after correcting lens and lighting. Remove alpha channels from opaque images. Use color space correctly: base color and emissive are color signals, while normal, occlusion, roughness, and metallic values are data. An accidental gamma transform changes surface response.

Check compression artifacts on text, sharp logos, normal maps, and alpha edges. Encoded byte savings are useful only when the viewer decodes the chosen image form and the result survives a real phone display.

Keep animation within the viewer contract#

Scene Viewer documentation states that only the first animation is played and that it loops. Put the intended customer-facing motion first, or export a dedicated file containing only that clip. Do not assume a DCC clip picker is available.

Trim animation ranges, remove unused tracks, simplify redundant keys, and test the looping seam. A 4-second turntable at 30 samples per second needs a deliberate 120-sample motion, not thousands of bake samples from a 240 Hz source.

Remove unused bones and keep each vertex at 4 or fewer weights. Stay well below 254 joints unless the use case truly requires a complex character. Product animation often can use rigid node transforms, which are easier to inspect and cheaper than skinning.

Verify current support before exporting morph targets. A warning ignored in a general glTF tool may correspond to a feature Scene Viewer does not render.

Validate the final GLB#

Run both a general glTF validator and Google's Scene Viewer validator. The general validator catches schema, accessor, bounds, and reference defects; the platform validator enforces the profile and recommendations that matter to this viewer.

Treat every error as a release blocker. Classify warnings as visual, performance, compatibility, or accepted exception with an owner. Save machine-readable reports beside the GLB and reference renders.

Open the exact hosted URL, not a local drag-and-drop substitute. Confirm response status, HTTPS, CORS where the launch path requires it, media type, byte-range behavior if relevant, and cache headers. Follow redirects on the same range of devices that will ship.

Test the complete Android experience#

Use at least 3 devices: a lower supported tier, a common midrange phone, and a current high tier. Test on cellular and Wi-Fi. Measure request start, viewer displayed, first model frame, AR readiness, first placement, and interaction stability.

Run this matrix:

cold and warm model launch;
3D mode and AR mode;
slow or interrupted network;
unsupported AR fallback;
portrait and landscape;
minimum and maximum natural distance;
move, rotate, and scale gestures;
animation start and loop seam;
transparent surfaces against light and dark rooms;
10 repeated launches in one browsing session;
background and resume;
bright light, low light, and reflective surroundings.

Check apparent scale against a ruler or known product, front orientation on entry, contact shadow, bounds, material response, texture clarity, and thermal stability. Capture device model, Android version, AR services version, Google app version, asset hash, and test date.

Example asset triage#

Consider a 17.8 MB GLB that fails the platform size check. Its 82,000 triangles already sit in a reasonable range, so aggressive geometry reduction is unlikely to be the best first move. The inventory reveals 5 PNG textures at 2048 × 2048, including 2 identical base-color images and an opaque image with an unused alpha channel. Deduplication, appropriate image encoding, and resizing a low-value underside map to 512 can reach 9.2 MB while keeping the silhouette unchanged.

Now inspect runtime structure. If the file uses 18 materials because each imported part copied the same plastic, merge equivalent assignments and retest. If 4 materials use blending for surfaces that are actually opaque, correct their alpha mode. Those changes address draw and fill costs that a smaller download alone would not solve.

Do not tune exactly to 15 MB, 100,000 triangles, or another published edge. Leave margin for validator changes, later product corrections, and device variation. A 9–10 MB release with documented visual evidence is easier to operate than a 14.99 MB release that fails after one label update.

Integrate those checks into publishing. Reject an artifact when required extensions are outside the approved allowlist, an image exceeds 2048 pixels, dimensions drift beyond tolerance, validation reports an error, or the fallback URL is absent. Let warnings produce a review report rather than silently publishing. This turns platform guidance into a repeatable contract instead of a checklist remembered after a customer reports a failure.

Retain the previous passing GLB at a versioned URL for rollback. If the new release produces a device-specific failure, the product page can restore known-good bytes without changing its indexed content or waiting for another conversion. Record rollback time and the affected device profile in the incident report.

Scene Viewer release checklist#

The hosted GLB and fallback page use HTTPS and versioned URLs.
The page contains indexable content beyond the launch control.
Model bytes meet the current documented profile with margin.
Triangles, materials, transparent materials, and partitions are bounded.
Images do not exceed 2048 × 2048 and decoded memory is estimated.
One unit equals 1 meter, +Z presents the intended front, and bounds are clean.
Ground contact and viewer-supplied shadow look plausible.
Extensions are explicitly supported and validation has no errors.
Skin joints, weights, UV sets, and morph features meet current rules.
The intended animation is first, trimmed, and loops cleanly.
Cold load, fallback, placement, interaction, and repeat-launch paths pass.
Reports, visual baselines, source hash, and device matrix are archived.

Sources and further reading#

Scene Viewer optimization means honoring a precise mobile delivery profile and testing the whole launch path. Keep the GLB comfortably inside current limits, preserve real scale and product identity, budget decoded texture memory, expose a resilient fallback, and validate the hosted artifact on representative Android devices.