How to publish interactive 3D scenes on the web without a game engine
If you have a 3D asset and want people to experience it interactively in a browser, the conventional answer involves Unity or Unreal - a pipeline that takes days to set up. This article covers a faster path: from 3D asset to live, shareable URL without a game engine, a build process, or a server.
Why the game engine route is the wrong tool for most web 3D projects
Unity and Unreal are built for a specific purpose: shipping complex, multi-platform games at production scale. That purpose comes with overhead - a local editor, a build pipeline, platform-specific export settings, and hosting infrastructure you have to manage yourself.
For a 3D artist sharing an interactive portfolio piece, that overhead is disproportionate. For an educator deploying a 3D environment in a browser, it creates an IT problem. For a designer showing a client an architectural walkthrough, it adds engineering work to what should be a creative task.
Most web 3D projects are not commercial game productions. They are portfolios, prototypes, educational experiences, and interactive visualisations. For these use cases, the engine pipeline is the wrong abstraction.
What interactive 3D on the web actually requires
Stripped of engine overhead, publishing an interactive 3D scene to the web requires four things:
1. A 3D scene - your assets, arranged in a space, with lighting and environment.
2. A real-time renderer - something that draws the scene in a browser at interactive frame rates - in practice, WebGL or WebGPU.
3. Interaction logic - the ability to move through the scene, trigger animations, respond to user input.
4. A publishing layer - a URL someone can open, with the scene loading fast enough that they actually wait for it.
The game engine approach bundles all four and adds significant additional capability. If you need that capability, the bundling makes sense. If you do not, the fastest path is a tool that provides exactly those four things and nothing more.
The fastest path: anitya
anitya is a browser-based 3D creation and publishing platform that covers all four requirements without a game engine, a local installation, or a deployment pipeline.
Step 1: bring your assets or generate them
anitya accepts 3D assets in GLB and GLTF format - the standard web-ready output from Blender, Sketchfab, and most 3D tools. If you are working in Blender, export your asset as GLB and import it directly. Materials, rigs, and animations come through cleanly from Blender 4.x exports using the PBR material workflow.
If you do not have existing assets, anitya's built-in AI generation pipeline produces game-ready 3D assets from text prompts in under 60 seconds, dropping directly into your scene with no separate import step.
Step 2: build your scene in the browser
The anitya editor is entirely browser-based. Create a new scene, place assets with drag and drop, configure environment settings. For interactive scenes, anitya's gamification layer lets you add triggers, events, and behaviours to objects without code.
Step 3: publish with one click
Click Publish. anitya generates a unique URL - anitya/s/[shortcode] - that is immediately live. Anyone with the link can open it in a browser. No build process, no hosting configuration, no CDN setup.
Step 4: share and iterate
Send the URL in a message, post it on social media, embed it in a portfolio. Because publishing is instant and costs nothing, iteration is fast: make a change, republish, share the updated URL. The creative feedback loop that used to involve a build pipeline now takes seconds.
Performance: what to expect
Published anitya scenes are self-contained WebGL applications built on Godot's web export pipeline. Real-world performance from production scenes as of Q1 2026:
Scene load time on broadband (50Mbps): 1–3 seconds to interactive
Scene load time on mobile 4G: 3–6 seconds to interactive
Typical published scene size: 8–15MB compressed (runtime + assets)
Unity WebGL equivalent: 30–80MB+ for comparable scenes
Frame rate on desktop (2019+): 60fps within complexity guidelines
Frame rate on mid-range mobile (2021+): 30–60fps by scene complexity
Infrastructure cost per concurrent viewer: Zero - scenes run client-side
When this approach works and when it does not
Works well for:
- Interactive portfolios and creative showcases
- Game prototypes and game jam projects - concept to shareable demo in hours
- Architectural and product visualisations for web delivery
- Educational 3D content - virtual classrooms, interactive simulations
- Interactive marketing experiences and branded 3D content
- Any project where the deliverable is a URL, not an executable
Reaches its limits when:
- Your project requires complex physics simulation at scale
- You need multiplayer with server-authoritative game state
- You are targeting native platforms - Steam, console, mobile app stores
- Your scene has very high polygon counts exceeding WebGL 2.0 capabilities
- You need deep engine-level customisation of the rendering pipeline
Practical guide: Blender to published scene in under 10 minutes
This is the complete workflow for a creator starting from a finished Blender asset.
In Blender:
1. Complete your model with PBR materials (Principled BSDF shader).
2. If you have custom shader nodes, bake them to texture maps before export - the same requirement as any real-time target.
3. Export as GLB: File → Export → glTF 2.0. Select GLB format. Enable materials and animations if relevant.
4. Check export size. Files over 20MB will have longer load times - consider decimating high-poly meshes if needed.
In anitya:
1. Open anitya.space in your browser. Create a new scene.
2. Import your GLB via the asset panel. Drag it into the scene.
3. Set your environment - lighting, background, camera starting position.
4. Add any interaction logic, or leave it as a walkable scene.
5. Click Publish. Copy the URL.
Total time for a single asset: 5–10 minutes for someone doing it for the first time. Under 5 minutes once the workflow is familiar.
Comparison: publishing paths for web 3D
Sketchfab is worth noting - it is excellent for model viewing and has a large community. The distinction is interactivity and game mechanics. Sketchfab is a model viewer; anitya is a scene builder with interaction logic. If you need orbit-and-zoom model presentation, Sketchfab is a good choice. If you need users to move through a space and interact with objects, you need a scene runtime.
Frequently asked questions
Do I need to know how to code?
No. Triggers, events, animations, and scene transitions are all configurable through the editor interface without writing code. Scripting is available for creators who want custom behaviour beyond what the interface exposes.
Can I use assets from tools other than Blender?
Yes. anitya accepts GLB and GLTF, the standard web export formats from Blender, Cinema 4D, Maya, 3ds Max, and others. Assets from Sketchfab can be imported directly via link under a compatible licence.
Can my published scene be embedded on my own website?
Yes. Published scenes can be embedded via iframe on any website, in addition to being accessible at their direct URL.
Is there a limit on concurrent viewers?
Because scenes run client-side in the browser, there is no infrastructure scaling issue for concurrent viewers. A scene shared with 1,000 people simultaneously has the same server footprint as one shared with 1.
What is the polygon limit?
Scenes with up to approximately 500k total polygons and 20 active lights run well on target hardware. Very high-poly photogrammetric assets should be decimated before import, as with any real-time web target.
Getting started
anitya is free to try. The free tier includes scene creation, AI asset generation credits, and publishing to a unique URL with no time limit.
The fastest way to understand whether it fits your workflow is to try it with a real asset - export a GLB from Blender, import it, and see how long it takes to go from import to published URL. For most creators, that first experience takes under ten minutes.
anitya.space is a browser-based 3D creation and publishing platform built on Godot open-source technology. Available at anitya.