"Democratization" is the watch-word for any non-noob-level developer/designer working in tech. More often than not this implies that industry standards and best practices are ignore in order to allow for even more easy to grasp entry-level workflows for absolute beginners.
Case in point: Unity WebGL.
The whole idea is simply: Unity allows you to build a WebGL version of your game/app which runs in the browser. As this involves some heavy lifting when it comes to file sizes you need to leverage browser caching and PWA methodologies to get the time it takes a new user to get to the – what I call – "first meaning full 3D frame".
Unavoidably this requires some server-side configuration of response headers, most crucially the content-encoding header for the GZip and Brotli compressed *.data and *.wasm files contained in the Unity WebGL player. For a 3D designer just looking to publish interactive content to the web this is not trivial at all. You need hosting platform of your choice like Vercel, Github Pages or Cloudflare Pages and you need to know how to configure custom headers, as most of these platforms will not handle WASM with Brotli and Gzip out of the box.
None of these platforms will handle Unity's custom *.data package out of the box.
The False Promise of "Just Export and Upload"
Unity's marketing around WebGL presents it as a simple "export and upload" solution, but the reality is far more complex. The default export settings produce massive files that perform poorly and are often incompatible with basic web hosting solutions. This gap between expectation and reality is a perfect example of how "democratization" can go wrong.
When designers without web experience export their first WebGL build, they're often shocked to discover:
- File sizes in the hundreds of megabytes for even simple scenes
- Loading times that make users abandon before seeing anything
- Compatibility issues with various browsers and devices
- Hosting complications that require technical knowledge beyond their skillset
The Skilled Developer Tax
For experienced developers who understand web optimization, Unity's WebGL implementation is particularly frustrating. Instead of leveraging standard web technologies and best practices, Unity has created a proprietary system that actively fights against them.
Want to implement proper asset streaming? Sorry, Unity's asset bundle system doesn't integrate well with WebGL.
Need to optimize memory usage? Good luck navigating the cryptic compression settings that often result in broken builds.
Trying to integrate with existing web frameworks? Unity's generated JavaScript is a nightmare to customize or extend.
And, most annoying of all, the console log bloat that comes with every build out of the box. It's just not okay to print a couple of hundred lines to the browser console every time your 3D player launches.
The result is that skilled developers spend more time fighting against Unity's implementation than they would creating their own WebGL solution from scratch. This is the "skilled developer tax" – the extra effort required to work around limitations designed to make things simpler for beginners.
Breaking Web Standards For No Good Reason
Perhaps most frustrating is how Unity actively breaks web standards. The custom *.data format is completely unnecessary when standard formats like glTF exist specifically for 3D web content. The loading sequence ignores modern browser capabilities for streaming content. Even basic PWA features require extensive hacking of Unity's generated code.
Unity could have embraced the web platform, teaching developers proper web practices while making them more employable in the broader tech industry. Instead, they've created a walled garden with its own rules that don't transfer to other contexts.
A Better Path Forward
Unity should provide more templates and categorize them by skill level. Beginners could have simplified exports that work on standard hosting with minimal configuration, while advanced users could access templates that follow web best practices.
Additionally, Unity should:
- Embrace standard web formats rather than proprietary solutions
- Provide clear documentation on server configuration requirements
- Allow deeper integration with modern web frameworks
- Optimize the default export settings for performance rather than simplicity
- Create official deployment guides for common hosting platforms
Until then, developers above the absolute beginner level will continue to pay the price for Unity's misguided approach to democratization – an approach that ultimately serves neither beginners nor experts well.
The irony is that by trying to make things simpler for everyone, Unity has made WebGL development more complicated for everyone. True democratization would mean creating clear pathways for growth, not hiding complexity behind broken abstractions.