Revel3D

Building the next gaming platform. Sharing the work as we go.

We're building tools to bring existing game content to the browser. Start with Terminal: a Unity scene converted to Three.js, with recreated lighting, materials, and interactive navigation.

Read the development journal

Revel3D / In development

Extras / Progress

The development journal.

A closer look at what we're building, how it evolves, and what each iteration teaches us.

Entry 001Rendering / TerminalDevelopment study

Terminal: converting a Unity scene to Three.js.

We converted Unity's Terminal sample scene to run in the browser with Three.js. This demo shows the conversion in action: imported scene assets, recreated lighting and materials, and interactive navigation.

We brought the Unity scene's geometry, textures, layout, and baked lighting data into our browser pipeline. That initial import was relatively straightforward with the tools we already had. The harder part was translating Unity's material and lighting behavior into Three.js so the scene retained its original appearance.

We made progress by leaning on Three.js's built-in lighting and material capabilities, reducing our reliance on complex custom reflection workarounds. That gave us a clearer foundation for resolving visual differences and refining the result.

v1 Ingestion
Bring the scene across.

Import the Unity scene's assets and layout into Three.js. Get the scene running in the browser, then identify the lighting and material differences that still need work.

What we learnedA successful import is the beginning of visual validation.
v2 Faithful recreation
Get the source right.

Recreate the Unity scene faithfully in Three.js, matching its lighting and material response using the renderer's built-in capabilities.

What we learnedCorrectness needs a faithful reference before enhancement.
v3 Enhanced presentation
Build on that foundation.

Build on the conversion with Three.js post-processing, including ambient occlusion and RGB shift, to refine the presentation beyond the original Unity scene.

What we learnedEvaluate visual enhancements against the established baseline.

Try the Unity-to-Three.js conversion

Open full demo ↗

This is the converted Unity Terminal scene, rendered locally in your browser by Three.js. Move through it and switch device views to explore the desktop, phone, and tablet layouts. Water and hologram materials are simplified in this conversion.

01 / What we're building

Bring existing game content to the browser.

Terminal demonstrates the first part: converting a Unity scene to Three.js. Around that work, we're building the tools to import assets, edit scenes, and run interactive games on the web.

Import

Bring the assets.

Convert geometry, textures, materials, and animation from existing pipelines into validated browser-ready bundles.

Author

Build in the browser.

Edit scene layouts, lights, and material assignments. Shatter, our material graph editor, compiles connected nodes into runtime shaders.

Run

Render on the device.

The browser draws the scene and handles interaction locally. The Terminal demo above is a working example of that approach.

02 / The engine

The systems behind the scene.

Our runtime, editor, and asset tools share a common foundation. These systems are in development, with working demonstrations across animation, rendering, world building, and more.

Animation & characters

Clip playback, locomotion blending, rig mappings, and reusable character loading. Combat and movement demos exercise these systems.

VFX & particles

Particle simulation and effect rendering, with imported material graphs using the same compiler as Shatter-authored materials.

Physics & destruction

Destructible geometry, clearance systems, and rebar experiments. These remain subsystem prototypes.

Worlds & vehicles

Biome layouts, interactive grass, modular placement, and vehicle construction. City Drive shares its saved project with the scene editor.

Networking

A shared protocol, client timing, server identity, and presence, supported by a local multiplayer development server.

Rendering & tooling

Lighting, reflections, and shader tools, with structured engine APIs for automated workflows. Terminal brings 207 instances and 42 materials into the browser.

03 / Conversion workflow

From source assets to a running scene.

Studios already have art, materials, and scene layouts. Our conversion work starts with that investment and documents what carries over, what needs translation, and what still needs work.

01
Import the source
Bring across meshes, textures, transforms, material assignments, and supported animation data.
02
Translate & validate
Recreate material and lighting behavior. Check asset bundles and compare the rendered result with the source.
03
Run & refine
Load the scene in the browser, reduce geometry transfer size, and refine the experience across viewport sizes.

Compatibility varies by source format and feature. Terminal shows one conversion in detail; support expands through continued research and validation.

04 / Cloud research

Exploring what can run beyond the device.

Alongside the local engine, we're testing cloud graphics and simulation. These are separate research demonstrations with saved validation reports; integrating them into the platform is ongoing work.

Lighting

Send lighting data to the browser.

Cloud GPUs calculate surface lighting, shadows, and reflections. The browser receives samples and reconstructs the image locally. Visual differences from the reference remain.

Simulation

Simulate remotely, draw locally.

A cloud GPU runs particle gravity and sends state updates to the browser. Local interpolation connects those updates for display.

Multiple GPUs

Divide the computation.

Two physical GPUs share gravity and visibility calculations. Saved tests establish correctness; a throughput advantage has not been proven.

Image streaming

Test server-rendered output.

A separate experiment delivers rendered frames to a browser receiver for offline rendering and benchmarks.

05 / Development progress

Working demonstrations.
Specific things learned.

Each study tests part of the platform. Terminal is available to explore above; the other studies support development of the engine and tools.

Terminal: Unity-to-Three.js scene conversion, baked lighting, material translation, and local reflections.
Shatter shield study: 35 imported material expressions, edited in-browser with previews using the runtime compiler.
Combat & locomotion: Character animation kits, combat training, and weapon attack blending.
VFX library: Particle effects and imported material graphs rendered through the engine pipeline.
City Drive: A vehicle driving demo connected to the same saved project as the scene editor.
Cloud experiments: Deployed lighting, gravity, and multi-GPU demonstrations with saved validation reports.

06 / The opportunity

A platform developers can build on.

The commercial path starts with original games that put the technology in players' hands, then expands into licensing the tools and runtime to other studios.

Reach players through a link.

Browser distribution reduces installation friction and makes games easier to share. It also gives studios a direct channel to their audience.

Our goal is to carry that experience across desktops, phones, tablets, and browser-based handheld environments.

Build once, keep improving the tools.

Original games give us real production needs to solve. Those improvements feed back into asset conversion, the engine, the scene editor, and Shatter.

Licensing gives other studios a way to use that same foundation for their own projects.

What's next

Help bring the platform to market.

We're raising to broaden asset compatibility, develop the toolchain, and connect the research into a cohesive platform.

The engine API, scene editor, Shatter prototype, and cloud demonstrations are running. Integration, broader format support, and production readiness are the next steps.

investors@revel3d.com