Blend4Web: The Open-Source WebGL Framework for Blender, and Its Status in 2026

Blend4Web is an open-source framework for putting interactive 3D scenes on the web. You build a scene in Blender, export it with the Blend4Web add-on, and the framework’s JavaScript engine renders it in any browser with WebGL, with physics, sound and logic included and no plugin to install. It was made by Triumph LLC, a Moscow-based company, and released in 2014 under the GPLv3 licence, with a paid commercial licence as an alternative.

This profile covers where Blend4Web came from, how it works, a scene we built and ran with it, the projects made with it, and where it stands in 2026. The short version: Blend4Web still works in today’s browsers, but it hasn’t had a release since 2018 and only supports Blender 2.79. Facts were checked against the Blend4Web source repository, the project’s website and blog, and news coverage in November 2026.

What Is Blend4Web?

Blend4Web is a JavaScript and WebGL framework for interactive 3D on the web, made by Triumph LLC and first released in March 2014. Scenes are created in Blender and exported for the browser, with physics, spatial audio, animation and a node-based logic editor. It’s dual-licensed under GPLv3 and a commercial licence. Its last release was 18.05 in 2018, and it supports Blender 2.79 only.

A Short History of Blend4Web

Triumph LLC was founded in 2010, and Blend4Web’s first public release, 14.03.28, came out on March 28, 2014. From the start it was free software: the first source release on GitHub already carried the GPLv3 licence, with a commercial licence for companies that didn’t want to publish their code.

For four years the team shipped a new version almost every month, 47 releases in the GitHub mirror alone. Highlights included:

• 2015: WebGL 2.0 support arrived in version 15.11, alongside new logic nodes, Blend4Web’s way to program interactivity in Blender without code.
• 2016: VR support in the 16.06 LTS (long-term support) release.
• 2017: augmented reality in the 17.06 LTS release.

Blend4Web also powered award-winning projects. NASA’s Experience Curiosity, a web app that lets you drive the Curiosity rover, won a Webby Award in 2016 (BlenderNation on the Webby Award), and the Everest Panorama project won a Red Dot Award for communication design in 2017.

Then development slowed. In late 2017 Blend4Web’s founders, Yuri and Alex Kovelenov, left Triumph to start Soft8Soft and its new WebGL toolkit, Verge3D. Blend4Web’s final release, 18.05, came out in June 2018. In October 2019 the Blend4Web blog announced a rework called Blend4Web Studio, explaining that tying the engine to Blender’s development had become a burden (the “New Blend4Web” announcement). It was the last post on the blog, and no new version has been released.

How Blend4Web Works

Blend4Web has two halves:

• The Blender add-on. You model, texture, light and animate in Blender as usual, using its node-based materials. The add-on adds Blend4Web settings and exports the scene as a JSON file plus a binary data file, or as a single self-contained HTML page.
• The JavaScript engine. The engine loads the exported scene and renders it with WebGL 1 or 2. It’s split into modules, such as app, data, scenes, objects, transform and physics, that your own code can call.

On top of that, the engine includes:

• Physics from Uranium, Blend4Web’s build of the Bullet physics engine compiled to JavaScript and WebAssembly.
• Spatial audio through the Web Audio API.
• Animation of objects, bones, shape keys and materials, with blending.
• Rendering features such as cascaded shadow maps, physically based materials, post-processing effects, water and particles.
• Logic nodes for building interactions visually in Blender.
• VR and AR through WebVR and the device camera.

The SDK also includes a project manager for creating, building and deploying apps, tutorials, and many example scenes.

Hello, Blend4Web: A Spiral of Monkeys

This script loads a scene exported from Blender, takes one object from it (Blender’s famous Suzanne monkey head) and builds a spiral of 60 copies with the engine’s JavaScript API:

// spiral.js: builds a spiral of 60 monkeys from one object in a Blend4Web scene
"use strict";

var m_app   = b4w.require("app");
var m_data  = b4w.require("data");
var m_scs   = b4w.require("scenes");
var m_obj   = b4w.require("objects");
var m_trans = b4w.require("transform");

var COUNT = 60;

function init() {
    m_app.init({
        canvas_container_id: "canvas",
        callback: function(canvas, success) {
            if (!success) { console.log("WebGL init failed"); return; }
            m_data.load("scene/instancing.json", build_spiral);
        },
        physics_enabled: false,
        autoresize: true
    });
}

function build_spiral(data_id) {
    m_app.enable_camera_controls();
    var source = m_scs.get_object_by_name("Suzanne");

    for (var i = 0; i < COUNT; i++) {
        var angle = i * 0.35;                 // radians between copies
        var radius = 2 + i * 0.15;            // the spiral widens as it climbs
        var copy = m_obj.copy(source, "Spiral_" + i, false);
        m_scs.append_object(copy);
        m_trans.set_translation(copy, radius * Math.cos(angle), i * 0.3 - 9,
                                radius * Math.sin(angle));
        m_trans.set_rotation_euler(copy, 0, -angle, 0);
        m_trans.set_scale(copy, 0.8);
    }
    console.log("Spiral built: " + m_scs.get_all_objects("MESH").length + " mesh objects");
}

window.addEventListener("load", init);

A few things to notice:

• b4w.require("app") and the other require calls fetch engine modules from the global b4w object.
• m_app.init() creates the WebGL canvas, then m_data.load() loads the exported scene and calls build_spiral when it’s ready.
• m_obj.copy() duplicates an object, and m_scs.append_object() adds the copy to the scene, so every monkey is a real scene object that the engine can move or animate.

How we tested it: we took the Blend4Web 18.05 engine and an example scene from the SDK repository, and ran this script in an up-to-date headless Chromium with WebGL 2.0. The engine reported version 18.5.0, logged “Spiral built: 61 mesh objects” (the 60 copies plus the source object), and rendered the spiral of monkeys. We used the SDK’s ready-made exported scene, because creating a new one needs Blender 2.79.

Projects Made with Blend4Web

Blend4Web was used more for interactive presentations and configurators than for games:

Blend4Web in 2026

• No releases since 2018. The last version is 18.05, and the GitHub repository’s last commit is from July 31, 2018.
• Blender 2.79 only. Blend4Web supports Blender 2.79. Blender 2.80, released in 2019, replaced the internal real-time renderer that Blend4Web was built on, so current Blender versions can’t export Blend4Web scenes.
• The engine still runs. Exported scenes still play in a current browser: our test above ran with WebGL 2 in an up-to-date Chromium.
• The website is online. blend4web.com still offers the SDK, documentation and demos, but its blog and news stopped in 2019.
• The successor is Verge3D. Soft8Soft, the company started by Blend4Web’s founders, develops Verge3D for Blender, 3ds Max and Maya. It’s commercial software, and it’s still updated in 2026.

Common Misconceptions About Blend4Web

• “Blend4Web became open source in 2015.” It was open source from its first public release in 2014, under GPLv3.
• “Blend4Web won the Best Web Technology award.” We found no record of that award. The awards we could verify went to projects built with Blend4Web: a Webby for NASA’s Experience Curiosity and a Red Dot for Everest Panorama.
• “Blend4Web works with current Blender.” It doesn’t. It needs Blender 2.79.
• “Blend4Web runs on Linux, Windows, OS X, Android and iOS.” It runs in the web browser on those systems; it doesn’t build native apps.

Blend4Web Alternatives

• Verge3D: the commercial successor from Blend4Web’s founding team, with Blender, 3ds Max and Maya workflows (Soft8Soft, makers of Verge3D).
• Three.js: the most widely used open-source JavaScript 3D library, which loads glTF scenes exported from any current Blender version (three.js).
• Godot: a free, open-source engine that exports full games to the web, if you want a game engine rather than a web framework. See our Godot engine profile.
• Blender Game Engine: Blender’s own built-in game engine, removed in Blender 2.80 like Blend4Web’s renderer. See our Blender Game Engine profile.

For more open-source engines, browse our directory of open-source C++ game engines.

Key Takeaways

• Blend4Web is an open-source WebGL framework for turning Blender scenes into interactive 3D web apps, made by Triumph LLC.
• It was GPLv3 from its first release in March 2014, with a commercial licence as an option.
• It shipped 47 releases in four years, adding physics, logic nodes, WebGL 2, VR and AR.
• Its last release was 18.05 in 2018, and it only supports Blender 2.79.
• Exported scenes still run in today’s browsers, as our test showed.
• For new projects, look at Verge3D or three.js; Blend4Web is best for maintaining existing apps.

Conclusion

Blend4Web was one of the first tools to make real-time 3D on the web practical for Blender artists, and projects built with it won major awards. Its tight link to Blender was also its weakness: when Blender 2.80 changed its renderer, Blend4Web was left behind, and its team moved on to Verge3D. Its code is still on GitHub and its scenes still run, but it’s a framework for maintaining old projects, not starting new ones.

For more engines across every genre, browse our game development hub.