mrkeyoor.com_
Mon 14 Sept 15:49 UTC
Webevaluationupdated 14 Sept 2026

engine review

PlayCanvas Engine is an open-source JavaScript engine for 3D games, product viewers, visualizations, and XR experiences that run in a browser. It supplies rendering, physics integration, animation, input, audio, and asset loading without forcing a project into the hosted PlayCanvas Editor.

Verdict

Our PlayCanvas Engine install took 24 seconds and its build took 43 seconds, but tests stopped after 6 seconds on an ERR_REQUIRE_ESM dependency error. It is still a serious candidate for browser-first 3D teams because the engine covers WebGL2, WebGPU, WebXR, glTF 2.0, physics, and input under an MIT license. Trial it against your slowest target device, and avoid treating the green build as proof that this checkout's test environment is reproducible.

We ran it

Lab card: what happened when we ran engineScreenshot of engine (playcanvas.com)
Install✓ · 24s598 packages · 294 MB
Build✓ · 43s
Tests✗ · 6sran, no count parsed
Known vulns00 critical · 0 high · 0 moderate · 0 low (npm audit)
Repo3044 files~422,452 lines of source · 525.2 MB · 7 CI workflows · tests dir

Answers from our run

Does engine build from source?

Dependencies installed in 24 seconds (598 packages), and the build succeeded in 43 seconds. We cloned commit 1180f57 into a clean Debian container with 3 CPUs and no project-specific setup.

Do engine's tests pass?

The test command failed in our container, and its output did not report a pass or fail count.

Does engine have known vulnerabilities in its dependencies?

npm audit found none in the dependency tree at the time of our run.

Who should not use engine?

Teams that need a clean test run on the measured Node 22 environment: our suite stopped on an ERR_REQUIRE_ESM dependency error before project tests could run.

What are the alternatives to engine?

Three.js, Babylon.js, Godot. Our PlayCanvas Engine install took 24 seconds and its build took 43 seconds, but tests stopped after 6 seconds on an ERR_REQUIRE_ESM dependency error.

Setup3/5Install and build passed; Node 22 tests stopped on ESM loading
Docs5/5Manual, API reference, examples, and standalone setup are linked
Community5/516,777 stars, a September 2026 release, and active issue work
Maturity4/5Long-lived engine with active releases; measured tests did not start

Who it’s for

Web developers building interactive 3D experiences with JavaScript or TypeScript.
Game teams that want WebGL2 and WebGPU in one browser-focused engine.
Product and visualization teams using glTF 2.0, compressed assets, or Gaussian splats.
XR developers who can test WebXR behavior across their actual device list.

Who it’s NOT for

Teams that need a clean test run on the measured Node 22 environment: our suite stopped on an ERR_REQUIRE_ESM dependency error before project tests could run.
Apps that repeatedly create and destroy Ammo-backed engine instances: open issue 9279 reports the full application remaining reachable after app.destroy().
Studios whose required targets are native consoles or app-store binaries: the README defines PlayCanvas as a browser engine and does not promise those deployment paths.
Legacy projects unwilling to track API removals: issue 9086 lists remaining deprecated aliases and compatibility helpers being reviewed for relocation or deletion.

Setup reality

Our sandbox installed 598 npm packages in 24 seconds and used 294 MB. The build succeeded in 43 seconds. Tests failed after 6 seconds with exit code 1 because html-encoding-sniffer tried to load an ES module through require(); the log did not reach project test results.

The README asks for Node.js 18 or newer and supports either npm install playcanvas for an application or npm install inside the engine checkout. The basic runtime needs no account or API key. Physics, compressed assets, XR, and hosted Editor workflows bring their own files, browser permissions, or services.

This is a browser graphics engine, so a successful package build says nothing about frame rate on the phones, GPUs, and headsets you support. WebGL2 and WebGPU paths, asset budgets, Ammo lifecycle behavior, and browser fallbacks need product-specific testing.

WebGL2 and WebGPU live in one 3,044-file engine

PlayCanvas Engine is an MIT-licensed browser runtime for games, interactive product pages, visualizations, and XR. The project README puts WebGL2 and WebGPU behind the same engine and includes WebXR, animation, input, positional audio, and an Ammo.js physics integration. Its asset layer understands glTF 2.0 plus Draco and Basis compression. Gaussian splat rendering is part of the stated feature set rather than an external demo.

The engine can stand alone. An application imports the playcanvas npm package, creates a canvas and an Application, then builds a scene from entities and components. PlayCanvas also maintains a React renderer, web components, a scaffolding command, and a separate browser Editor. That separation matters: a JavaScript team can use the runtime without moving its whole production process into a hosted visual tool, while an art-heavy team can evaluate the Editor as another part of the stack.

Node.js 18+ gets a cube running before production work starts

The documented floor is Node.js 18, and the shortest start is one npm install plus the spinning-cube example. Engine contributors have separate build and documentation commands. The standalone engine manual is the more useful route once the cube is no longer enough, because a real project needs a bundler choice, asset organization, resize handling, loading states, and deployment rules. No PlayCanvas credential is required for the standalone npm path.

Browser delivery moves performance work into your project. glTF 2.0 and compressed textures can reduce transfers, but artists still need budgets for geometry, materials, texture resolution, and shader cost. WebXR requires compatible browsers and devices. Ammo adds another runtime and its own teardown concerns. The engine gives teams the relevant systems; it cannot decide how a scene should degrade on a weak phone or what happens when WebGPU is unavailable.

What happened when we ran it

Our sandbox installed 598 npm packages in 24 seconds, leaving 294 MB on disk. The full build succeeded in 43 seconds. Those are reasonable contributor setup results for a repository containing 3,044 files and about 422,452 lines of source, though the 525.2 MB checkout itself is a substantial download before npm adds its dependency tree. The scan found 7 CI workflow files and a tests directory, but no Dockerfile.

Tests failed with exit code 1 after 6 seconds. Mocha raised ERR_REQUIRE_ESM while html-encoding-sniffer used require() on @exodus/bytes/encoding-lite.js, which Node treated as an ES module. The stack continued through jsdom and Mocha's ESM loader. No project assertion summary appeared, so it would be wrong to describe any engine tests as passing or failing. The result only establishes that the supplied test command did not start cleanly in our Node 22 container.

Npm audit reported 0 known vulnerabilities across all 598 installed packages: 0 critical, high, moderate, or low findings. That is useful evidence for commit 1180f57, not a promise about future dependency resolution. A team evaluating the checkout should reproduce the same install with its lockfile and Node version, then require the complete suite to reach assertions before accepting a dependency update.

Ammo teardown has a specific open memory report

Open issue 9279 describes an app lifecycle that deserves attention in single-page sites. The reporter created and destroyed an Ammo-backed application 200 times and measured roughly 1.1 MB of retained memory per cycle. Their investigation says an Emscripten function-table callback keeps the JavaScript application graph reachable after app.destroy(). The issue also says the older Ammo path without that callback was not affected.

That report does not prove every PlayCanvas application leaks, and it is separate from our sandbox measurements. It does identify a poor fit today: pages that swap many 3D experiences by repeatedly destroying the engine while using Ammo. Test that lifecycle with the exact Ammo build and browser you ship. A single long-lived application or a project without Ammo has a different risk profile, but teardown still deserves a regression test before release.

v2.22.2 arrived three days before this review

GitHub recorded 16,777 stars and 496 open issues and pull requests on September 14, 2026. A separate issue-only query returned 463 open issues, with new reports and proposals updated during September. The repository was pushed the same day. Release v2.22.2 shipped on September 11 with 2 listed material and shadow fixes. These dates show active maintenance, while the queue shows that adopters should search known problems around their chosen subsystems.

Compatibility work is also visible. Issue 9086 tracks deprecated aliases, helpers, and side-effect imports that still need decisions before the old module can be removed. Existing applications should read release notes and budget migration checks instead of pinning indefinitely. For a new browser-first 3D product, PlayCanvas earns a prototype beside Three.js and Babylon.js. The deciding evidence should be scene performance, tool fit, and a passing test setup on the Node version your team supports.

Alternatives

ProjectWhat it isPick it when
Three.js gh↗A widely used JavaScript 3D library with a lower-level scene and rendering focus.pick this instead when you want to assemble your own game or application systems around a rendering library.
Babylon.js gh↗A browser 3D engine with rendering, tooling, physics options, and a large feature surface.pick this instead when its APIs, inspector, or surrounding tools fit your team better after a side-by-side prototype.
Godot gh↗A full editor-led game engine that exports to the web and other platforms.pick this instead when a desktop editor and targets beyond the browser matter more than a JavaScript-native runtime.

What people are saying

  1. [github-trending] Pasta-Devs/Marinara-Engine
  2. [github-trending] playcanvas/engine
  3. [hackernews] Getting 50 GB/S Back from the Apple Neural Engine
  4. [hackernews] Usenet rewind archive search engine
  5. [hackernews] Retrospectively Reverse-Engineering Apple's Neural Engine
  6. [hackernews] Show HN: Engrim – A universal, local-first SQLite memory engine for AI CLIs

Sources

  1. PlayCanvas Engine README
  2. PlayCanvas Engine repository
  3. PlayCanvas Engine v2.22.2
  4. Ammo teardown memory issue
  5. Deprecated API cleanup issue
  6. Standalone engine manual

More web reviews

openui · fabric.js · uBlock · OI-wiki · dioxus · Folo · the whole board →