What Is PlayCanvas? Exploring the Web-Based Engine

Older articles keep describing the PlayCanvas Editor as closed source. Its frontend has been MIT-licensed on GitHub since 2025 (PlayCanvas blog, 2025). Only the hosted backend behind it is still a PlayCanvas service.

The rest of the platform sits on an open-source engine that renders with WebGL2 and WebGPU, plus a browser editor that several people can work in at once. Finished apps open from a URL and need no plugin. Browser games, playable ads, product configurators and AR and VR scenes are the usual projects.

What Is PlayCanvas and What Does It Include?

The engine is open source and written in JavaScript. A visual editor in the browser sits over it, and both exist so that 3D apps and games load from a URL.

The PlayCanvas docs list a few products, and every one of them runs on that same engine.

• The Engine is the JavaScript runtime behind every PlayCanvas app. You’d pick it when you want full control, or when performance is the main concern.
• The Editor runs in the browser and lets a team work together in real time. Beginners and anyone prototyping quickly tend to start here.
• PlayCanvas React wraps the engine in a declarative React interface, which suits apps that already use React.
• Web Components do much the same through custom HTML elements, so a page with no framework can use them.

Developers coming from Unity or Unreal get pointed to the Editor, which the docs say offers a similar end-user experience.

PlayCanvas didn’t start as a desktop engine that picked up a web export later. Browser delivery is the main target, and the Editor’s publishing docs list the Web path first, then Mobile, Desktop and Playable Ads.

It isn’t a bare rendering library either. Physics, animation, audio, input and an entity component system all ship with the engine, so a single codebase can cover HTML game development, visualizations and playable ads.

Who Makes PlayCanvas and Is It Open Source?

Mostly. The engine and the Editor frontend are both MIT-licensed on GitHub, and the hosted backend behind the Editor stays a PlayCanvas service.

Wikipedia’s entry still frames the creation platform as proprietary. That holds for the backend but not for the Editor frontend, whose source has been public since 2025.

The dates and figures people usually ask about:

• PlayCanvas formed in April 2011 (Mozilla Hacks, 2014)
• The engine was open-sourced on June 4, 2014 (Mozilla Hacks)
• The Editor frontend went open source in 2025 under the MIT license (PlayCanvas blog)
• The engine repository sits at 16.6k GitHub stars, MIT license (GitHub)

License and source code

MIT terms cover both repositories. That means commercial use, modification and redistribution are all fine, as long as the license notice stays attached.

• The engine lives at github.com/playcanvas/engine, with a contributing guide and a code of conduct
• The Editor frontend is at github.com/playcanvas/editor
• Bug reports and questions go through GitHub issues and the PlayCanvas forum

A modified frontend still talks to PlayCanvas’s own backend, per the 2025 announcement.

Founders and Snap ownership

Will Eastcott (CEO) and Dave Evans co-founded PlayCanvas, a UK company. Eastcott worked in the games industry before that and has Call of Duty and Max Payne credits. He’s also the one who announced the engine’s open-source release on Mozilla Hacks.

Snap Inc. owns PlayCanvas. Which year it bought the company depends on the source.

UK financial filings show the share transfer to Snap in May 2017, and Snap filed to trademark the name in January 2018 (Global Corporate Venturing, 2018). The deal didn’t become public until March 2018, when Tech Monitor and Game Developer reported it with an undisclosed price.

That’s why “acquired in 2017” and “acquired in 2018” both circulate. The filings point to 2017 for the share transfer, and neither company has disclosed a closing date.

How the PlayCanvas Engine Renders 3D Graphics

The engine draws through WebGL 2.0 or WebGPU. The PlayCanvas docs still label WebGPU as Beta, and when a browser doesn’t support it, the engine drops back to WebGL.

Graphics backends

Web3D Survey figures quoted on the PlayCanvas blog put WebGPU support at 62.19% of end users in April 2024. It’s a dated snapshot, so don’t treat it as today’s number.

• WebGL 2.0 is the mature backend and works across browsers and devices. PlayCanvas launched support for it in 2017 with Mozilla.
• WebGPU (Beta) cuts driver overhead and adds compute shaders, which arrived in Engine v1.70.0.

A Null backend exists too. It’s headless and meant for running the engine in Node.

PlayCanvas worked hard to make existing WebGL projects look identical under WebGPU. At the April 2024 launch, the run-time lightmapper still didn’t work on WebGPU.

The first-party sources describe WebGPU in slightly different ways. The GitHub README says the engine is built on WebGL2 and WebGPU. The docs call WebGPU Beta. The Engine v2.19.7 changelog (June 2026) records a temporary WebGPU shutoff on Imagination PowerVR GPUs, with the Pixel 10 named.

Put together, WebGPU is a first-class target that still carries a beta label and some device-level exceptions. Leave the WebGL 2.0 fallback switched on and test on actual phones. That fallback is the first thing I’d check before shipping anything.

Materials, lighting and effects

PlayCanvas announced physically based rendering for WebGL in December 2014, and the current material system grew out of it.

• PBR with metallic/roughness and specular/glossiness workflows, plus clearcoat, anisotropy, sheen and transmission materials
• Clustered lighting for hundreds of dynamic lights, along with area lights and run-time lightmap baking
• Post effects through the CameraFrame system, including HDR bloom, SSAO, depth of field and TAA
• Custom shaders in GLSL for WebGL and WGSL for WebGPU

Model formats, compression and physics

Asset streaming and physics both rely on third-party technology.

Draco-compressed GLB files need the Draco decoder at load time. Engine v2.20.0 (June 2026) added a warning and a failed load for the case where the decoder is missing.

Engine v2.21.0 (July 2026) put physics behind a backend abstraction with Ammo and Null implementations. Ammo.js is still the working physics backend.

Gaussian splatting

D Gaussian splats, a photorealistic scene reconstruction technique, load and render in the engine as a first-class asset type.

The tooling lives in separate products. SuperSplat handles editing and publishing, and the SplatTransform command-line tool converts files. PlayCanvas also open-sourced the SOG compression format for splats in 2025.

• Engine v2.20.0 (June 2026) selects GPU sorting automatically on WebGPU and marks it stable.
• Engine v2.21.0 (July 2026) added support for the KHR_gaussian_splatting glTF extension, and SPZ files through an external parser.

How the PlayCanvas Editor Works

The Editor builds scenes in the browser, and its viewport runs the same engine as published apps. What you see there is what users get at runtime (PlayCanvas docs).

Projects save to the cloud on their own, so any machine with your login has the project.

Interface and scene building

Most scene work happens in a handful of panels.

• The Hierarchy shows the entity tree and is where you organize and parent entities
• The Inspector holds the properties and components of whatever is selected
• Models, textures, audio and scripts live in the Assets panel, which comes with folders, search and filters
• The Viewport adds transform gizmos for moving, rotating and scaling

A public Editor API exists for automation, per the 2025 frontend announcement.

Real-time collaboration

Collaboration is part of the Editor itself, not a plugin. Teammates edit the same scene at the same time, and stakeholders can drop in to check the latest state.

You can tell who is doing what from a presence bar with avatars, a chat panel, colored camera frustums in the viewport and selection markers in the Hierarchy.

The docs promise no merge conflicts when people work simultaneously in one scene. Merging between branches is a separate path. It goes through a conflict manager that compares each branch against the base version and lets you pick a version for every conflicted property.

Version control

Checkpoints are snapshots you can roll back to. Branches let you work on a feature without touching the main project, and merging brings them back together, with the conflict manager sorting out any clashes.

Item History keeps checkpoint timelines for entities, assets, scenes and project settings.

Branches suit risky experiments, like moving a project over to the WebGPU backend.

How to Build and Publish a Project in PlayCanvas

Going from an empty scene to a published app happens entirely inside the Editor.

1. Create a project from the PlayCanvas dashboard and open its first scene in the Editor.
2. Add entities in the Hierarchy and give them components such as camera, light, render, physics, audio or script.
3. Upload models, textures and audio to the Assets panel. The asset pipeline converts source files into web-ready formats on PlayCanvas servers.
4. Create a script, attach it to an entity through a script component and set its attributes in the Inspector.
5. Press Launch to open the project in a new tab. Hot reloading lets you change scripts and materials while it runs.
6. Publish through one of the documented paths: Web, Mobile, Desktop or Playable Ads.

Entities, components and scripts

Every PlayCanvas scene runs on an entity component system. Entities are plain containers with no behavior of their own. Components give them functionality or data, and systems process every instance of one component type in batches (PlayCanvas docs).

Scripts attach to entities as reusable code for input handling and game logic. They’re written in JavaScript, and code-first projects scaffolded with create-playcanvas use TypeScript.

Each script gets an update method that receives the frame’s delta time, which hooks it straight into the game loop.

ESM scripts versus classic scripts

Both scripting systems can live side by side in one project.

ESM scripts use the .mjs extension with import and export syntax and class-based modules. The Editor gives them better autocomplete and inline docs. There’s no shared global scope either, so load order stops being a problem.

Classic scripts (.js) belong to the Scripts 2.0 system, which launched in July 2016 and is built on prototype syntax. Existing projects can keep using them.

PlayCanvas named ESM the recommended way to write scripts in June 2025. Use it for anything new, and migrate the classic ones whenever you next touch them.

Engine upgrades and breaking changes

Releases in the 2.x line flag their breaking changes, so an engine upgrade should be a deliberate step.

• Engine v2.20.0 (June 2026) moved gsplat lodRangeMin and lodRangeMax onto the GSplatComponent
• Engine v2.21.0 (July 2026) renamed gsplat script classes to match core GSplat casing and removed MeshInstance parameter pass flags

The engine docs have an Engine Migrations page, which warns that code written for Engine 1 often no longer works. Read it before you change a project’s engine version.

What Can You Build with PlayCanvas?

Browser games, product configurators, playable ads, AR and VR scenes and 3D viewers all fit. The showcase on playcanvas.com is sorted into 7 industries: games, AR, VR, configurators, advertising, gambling and education.

Games and product visualization

Games came first. King, Disney and Nickelodeon used PlayCanvas for casual and multiplayer browser games, according to a 2018 Game Developer report.

Polaris and Trelleborg took it somewhere else and used it for 3D product renders (Global Corporate Venturing, 2018).

The site also lists a Model Viewer product for inspecting glTF scenes in the browser.

Playable ads

Facebook and Snapchat playable ads are supported. Other ad networks might work, but the PlayCanvas docs say the team hasn’t verified them.

WebXR on phones, headsets and desktop

AR and VR apps in PlayCanvas run on a standard browser API, so what works depends on the device. Support for WebXR is still rolling out across major platforms, according to the PlayCanvas docs.

iPhones don’t appear in that table. The glTF Viewer gets around it with WebXR on Android and USDZ export for iOS, as PlayCanvas’s 2022 year-in-review describes.

There’s a trap if you test without hardware. The WebXR API Emulator Chrome extension is incompatible, and PlayCanvas apps throw an exception while it’s active. The docs point to the Immersive Web Emulator instead.

Native packaging for app stores

A PlayCanvas app is just a web page, an index.html file plus its resources, so a Google Play or Apple App Store release means wrapping it. Apache Cordova and GoNative both do the job. So does a custom Android or iOS app with one fullscreen WebView that loads the build from local resources.

PlayCanvas Pricing and Plans

The engine costs nothing. On the Editor side, Free is $0 and Personal is $15 per month, while Organization runs $50 per seat per month (PlayCanvas plans page, October 2026).

What each upgrade buys

Moving from Free to Personal gets you private projects and ten times the storage, 10GB instead of 1GB. Organization adds team management and 50GB, and it’s billed per seat.

The feature grid on the plans page also lists self-hosting downloads, REST API access, a custom loading screen and project archive and restore. Check the grid to see which tier carries each one.

Billing terms

• The minimum term is 1 month, and you can cancel at any time
• Subscriptions renew automatically each month, on the day you first subscribed
• There’s no self-serve trial, so you request an upgrade code from sales
• Annual prepayment goes through invoices for Organization subscriptions of 1 year or more

These terms come from the FAQ on the same plans page.

PlayCanvas vs Three.js, Babylon.js and Unity

PlayCanvas is an engine with a hosted editor attached. Three.js sits lower down as a rendering library, and Babylon.js is a full engine with browser playgrounds. Which one fits comes down to how much of the toolchain you want handed to you.

The download counts come from the npm registry API and only reflect code-first installs. Apps built in the Editor don’t pull the engine from npm, so the gap overstates the difference in total use.

PlayCanvas vs Three.js

Three.js calls itself a lightweight, general-purpose 3D library, and its current builds ship WebGL and WebGPU renderers, per its README.

Three.js makes the better base for custom pipelines, since you put together physics, input and scene tools yourself. Engineers who want a minimal starting point will like that. If artists and designers need to edit scenes without touching code, PlayCanvas fits better.

PlayCanvas vs Babylon.js

Both are full engines under permissive licenses. Babylon.js is Apache-2.0 and comes with a browser Playground and Sandbox for quick tests. PlayCanvas is MIT and keeps a persistent Editor project that a whole team can open at once.

Babylon.js suits code-first prototyping. PlayCanvas starts to pay off once a team is sharing scenes.

PlayCanvas vs Unity

Unity publishes to the web through its Web build option, which defaults to WebGL2 (Unity manual).

Unity 6.6, released in September 2026, dropped the experimental label from WebGPU, but the API stays opt-in and the manual lists its browser and device support as limited. PlayCanvas labels the same API Beta and falls back to WebGL automatically.

If the project also ships to native platforms, Unity makes more sense. If the browser is the only target, PlayCanvas is the simpler call.

When PlayCanvas Is the Wrong Choice

Skip it if private work has to survive a lapsed subscription, or if authoring has to stay offline. A hard time budget on the first load can rule it out too.

Private projects after a lapse

Cancelling a paid plan locks your private projects, while published apps keep running (PlayCanvas plans page FAQ). Resubscribing unlocks the projects again, and making them public is the other documented route.

The Free plan lists public projects only, so closed-source client work needs a paid plan from day one.

Load size and the 5-second target

The PlayCanvas docs tell developers to aim for a load under 5 seconds so users don’t leave.

The built-in physics engine adds a 379KB download, so the docs suggest a hand-rolled alternative when a project only needs very simple collisions.

• AVIF files come out smaller than WebP, JPG or PNG at the same quality, but not every browser supports AVIF
• A 2048×2048 texture on a small object may look the same at 1024×1024 or 512×512
• Uncheck Preload on assets the first scene doesn’t need, such as music
• Sort loaded assets by size in the Chrome DevTools Networking panel and delete duplicates

Offline and local-only authoring

The Editor runs in the browser and saves to the cloud, so teams that have to work offline can’t use it as their main tool.

The engine doesn’t have that limit. It installs from npm, and create-playcanvas scaffolds a Vite and TypeScript project that runs locally.

That route also skips the paid plans, which only cover Editor features according to the plans page.

PlayCanvas FAQ

Does PlayCanvas support multiplayer?

Yes, through an external networking layer. The official tutorial builds a client-server model with Node.js and Socket.io, and the docs also point to Colyseus and Photon tutorials for hosted multiplayer services.

How active is PlayCanvas development?

The engine shipped 9 releases between June 23 and July 24, 2026, from v2.20.0 to v2.21.1, according to its GitHub releases page.

Most were small patches. Two were minor releases with new features.

Where do I find ready-made assets for a PlayCanvas project?

In the Asset Store, which opens from a button in the Editor’s Assets panel. Its April 2023 relaunch offered models, fonts, textures, skyboxes and scripts, built from Creative Commons sources such as kenney.nl and Sketchfab.

Can I host a PlayCanvas app on my own server?

Yes. The web publishing docs list PlayCanvas hosting, self-hosting and heyVR.io as options, and the plans page lists downloads for self-hosting as a plan feature.

Serve JSON and JS files with GZIP compression on your own server, per the load-time docs.

How to Test PlayCanvas Before Paying for Seats

Start on the Free plan with your hardest scene and non-confidential assets. Load and device failures show up there, before any seat is bought. Launch that scene on a real mid-range phone, and pay for a month only if you need privacy or team editing.

That order puts technical risk ahead of spending. Private projects and team management don’t change whether the engine fits your scene, so they come last.

The 1-month minimum term and the plan prices cap a trial at one month, which costs $15 on Personal or $50 per seat on Organization, with no annual commitment.

If the docs ever drop the Beta label on WebGPU, the phone test can run on a single backend. The docs checked in October 2026 still carry it.

• Author
• Recent Posts

Bogdan Sandu

Bogdan Sandu specializes in web and graphic design, focusing on creating user-friendly websites, innovative UI kits, and unique fonts.

Many of his resources are available on various design marketplaces. Over the years, he's worked with a range of clients and contributed to design publications like Designmodo, WebDesignerDepot, and Speckyboy, Slider Revolution among others.

Latest posts by Bogdan Sandu (see all)

• What is Backend in Web Development? - September 13, 2026
• What is Frontend Development? - September 11, 2026
• How to Make a Button in Figma: Design Best Practices - September 10, 2026