Steam Next Fest wrapped its February 2026 edition with over 2,200 participating games and more than 3,500 playable demos. The data from this round tells a clear story about what works for indie discovery on Steam and what doesn't.

A look at standout indie games from Steam Next Fest February 2026

The tier system

Analysis by presskit.gg established clear performance benchmarks based on wishlists earned during the festival:

The median game earned around 460 wishlists during the festival. That's the realistic baseline.

What performed well

Co-op games overperformed. Content creators gravitated toward games they could play with friends on stream, which drove organic visibility. Social play translates into social media reach.

Survival and crafting titles stayed strong. No signs of audience fatigue in this genre despite how crowded it feels from the developer side.

What struggled

Narrative games and visual novels had a hard time. The festival format rewards quick, visually distinct experiences that photograph well in thumbnails. Story-driven games need more context to communicate their appeal.

Roguelikes faced saturation but could still break through with strong differentiation.

The momentum effect

The most striking finding: games that entered Next Fest with fewer than 1,000 existing wishlists rarely broke into higher tiers. The games that hit Diamond almost always started with 10,000+ wishlists already in place.

Next Fest amplifies existing momentum. It doesn't create it from nothing. The event rewards games that already have an audience. If you're launching cold, the festival alone probably won't change your trajectory.

What this means for developers

The data reinforces that discovery on Steam increasingly favors games with pre-existing visibility. Capsule art that reads at small sizes matters. Content creator relationships before the festival matter. Having a community before you show up matters.

For games that don't have that built-in momentum, alternative discovery paths become more important. We wrote about this dynamic in our Steam Next Fest strategy guide.

References

• presskit.gg analysis
• The Indie Informer top demos

Rémi Verschelde, Godot co-founder and one of the engine's core maintainers, has publicly described the surge of AI-generated pull requests hitting the project as "draining and demoralizing."

The problem

Maintainers now have to second-guess nearly every pull request from new contributors. The AI-generated submissions often look plausible at first glance but contain fundamental errors, broken logic, or code that doesn't make sense in context. The time spent identifying and rejecting these PRs takes away from reviewing legitimate contributions.

Godot currently has 4,681 open pull requests on GitHub. Distinguishing honest human mistakes from AI-generated nonsense has become, in Verschelde's words, extremely difficult.

Why it's happening

Godot's popularity surged after Unity's 2023 Runtime Fee controversy drove developers to explore alternatives. More users means more potential contributors, and a growing number of those contributors are using AI tools to generate code submissions without understanding what the code does.

Godot has contribution guidelines that require disclosure of AI assistance, but these are frequently ignored. The submissions aren't typically malicious. They come from people who genuinely want to contribute but are leaning on AI tools that produce confidently wrong code.

What Verschelde proposed

His primary recommendation was more funding to hire additional maintainers who can handle the review volume. He acknowledged that using AI to detect AI-generated PRs would be "horribly ironic" and expressed reluctance to automate the process.

Other possibilities floated include moving off GitHub or implementing community trust-rating systems, though both options risk raising barriers for genuine new contributors, which runs counter to the open-source ethos.

The broader pattern

This isn't only happening to Godot. Open-source projects across the software ecosystem are reporting similar patterns. AI tools make it trivially easy to generate a pull request. They don't make it easy to generate a useful one. The cost of submitting has dropped to near zero while the cost of reviewing remains high.

References

• Game Developer
• The Register
• PC Gamer

Date: 2026-02-27 Author: Research and proposal for Mariana's review Last news post: January 18, 2026 (Cinevva launches reels-first game discovery) Gap: 40 days without a news update

Part 1: Catch-up news articles

These are factual news posts following the existing format. Short, direct, developer-focused.

1. Godot 4.6 released with Jolt Physics and new editor theme

Why it matters: We already published a preview article on January 10 predicting this release. Now it's shipped and the actual features are bigger than expected. Jolt Physics is now the default for all new 3D projects, replacing the old GodotPhysics. Direct3D 12 is the default renderer on Windows. There's a new IK framework, SSR overhaul, and a fresh "Modern" editor theme. LibGodot lets you embed the engine in other applications. Delta encoding makes patch updates smaller. This is one of the most feature-dense Godot releases in years and it directly affects web game developers.

Angle: Follow up on our preview. What shipped vs. what we expected. Emphasis on Jolt Physics (matters for web export performance) and LibGodot (embedding potential).

Date to publish: 2026-02-27

2. Unity previews AI game creation ahead of GDC

Why it matters: Unity CEO Matthew Bromberg announced that Unity will demo a new AI beta at GDC (March 9-13) that lets people "prompt full casual games into existence with natural language only." This is a direct competitor to what Cinevva already does. It's also a signal that the biggest engine in the industry now considers AI-first game creation a primary product direction, not a side experiment.

Angle: Factual reporting on the announcement. What Unity said. What we know and don't know. The significance of a mainstream engine going all-in on prompt-to-game. No editorializing in the news post itself.

Date to publish: 2026-02-28

3. Roblox launches AI-powered 4D model creation

Why it matters: Roblox released a beta tool that generates fully functioning in-game 3D models from natural language prompts, complete with physics and interactive mechanics. Cars with working doors. Objects with real collision. This is relevant to our audience because it shows AI-generated game content moving from static assets to interactive objects.

Angle: What the 4D creation tool does. How it compares to existing 3D generation tools. What "4D" means in this context (3D + behavior/interactivity).

Date to publish: 2026-03-01

4. Godot maintainers struggle with AI-generated pull requests

Why it matters: Rémi Verschelde, one of Godot's core maintainers, called the flood of AI-generated PRs "draining and demoralizing." Contributors are submitting low-quality, nonsensical code generated by AI tools without review. This is affecting one of the most important open-source game engines and it connects to a broader issue that matters to our community.

Angle: The facts. What's happening to Godot's PR queue. Verschelde's direct quotes. The tension between welcoming new contributors and managing noise. Keep it factual for news, but this topic could also warrant a deeper piece in the new section (see below).

Date to publish: 2026-03-03

5. Steam Next Fest February 2026 data: what worked for indie discovery

Why it matters: Over 2,200 games participated. The data from presskit.gg shows clear patterns: games with 10,000+ existing wishlists broke into the Diamond tier. Most games earned 460-999 wishlists. Co-op and survival-craft overperformed. Narrative games and visual novels struggled. This is directly relevant to our audience of indie developers trying to get discovered.

Angle: The numbers. What tiers existed. What genres performed well. What the data tells you about when to enter Next Fest and how to prepare. Reference our existing Steam Next Fest strategy guide.

Date to publish: 2026-03-05

Part 2: New section proposal — "Signals"

The concept

A new content section called Signals that sits between News and Blog.

News is factual. What happened. Short. No opinion. Blog is personal. Deep essays. Mariana and Oleg writing from lived experience. Signals is analytical. What does this trend mean? Where is this going? Written in Mariana's conversational voice but focused on industry shifts rather than personal stories.

Why it fills a gap

The news section reports events. The blog section tells stories. Neither one does the thing readers increasingly want: someone they trust telling them what to pay attention to and why. That's what Signals does.

Each piece is 500-900 words. More frequent than blog posts (which take weeks). More opinionated than news (which stays neutral). Published when something worth analyzing happens, not on a schedule.

Voice and format

Written in Mariana's voice following the existing guidelines:

• Conversational, direct, warm
• First person ("We've been watching..." / "I think...")
• Contractions, active voice
• No corporate speak, no banned words
• Specific and concrete, not abstract
• Opens with a hook, not a summary
• No bullet points unless the structure demands it
• No summary paragraph at the end

Each Signals piece follows a loose structure:

1. The thing that happened (1-2 sentences)
2. Why it caught our attention (the analysis)
3. What it means for people building games (the "so what")

No formal sections or headers required. These should read like smart notes from someone paying close attention.

Proposed Signals articles

Signal 1: "Everyone wants to be the AI game engine now"

Unity is demoing prompt-to-game at GDC. Roblox shipped 4D model creation. Moonlake AI opened its World Model Agent beta. Phaser Editor v5 integrated AI through MCP. Arcane Forge is building a full AI pipeline. And we've been doing this for years.

This isn't a complaint about competition. It's an observation about timing. Two years ago, VCs said the market wasn't there. Now the biggest names in gaming are racing to build what they said couldn't work.

The piece would cover what each company announced, how the approaches differ (text-to-game vs. AI copilot vs. AI asset pipeline), and why the "AI game creation" umbrella hides fundamentally different products. Some of these tools generate a demo that looks cool in a tweet. Others generate something you can actually ship. The difference matters.

Target length: 800 words

Signal 2: "Vibe coding is the new game jam"

Collins Dictionary named "vibe coding" Word of the Year 2025. Andrej Karpathy coined it to describe building software by describing intent in plain English. In game development specifically, this means the barrier between "weird idea" and "playable prototype" collapsed.

This piece would connect vibe coding to something we already demonstrated with A Breaker Belt (built in three days). The point isn't that AI writes better code than humans. The point is that game ideas that would have died in a brainstorm doc now get built in an afternoon. The economics of experimentation changed.

The risk of vibe coding: context window limits, loss of understanding, AI-generated complexity that nobody can debug. The promise: more games that shouldn't exist but somehow do.

Target length: 700 words

Signal 3: "Open source has an AI pollution problem"

Godot maintainers are drowning in AI-generated PRs. The code doesn't work, doesn't make sense, and wastes volunteer time. Rémi Verschelde called it "draining and demoralizing." This is happening to one of the most important open-source game engines in the world.

The piece would explore the irony: AI tools that are supposed to make developers more productive are actively making open-source projects less productive. The people submitting these PRs aren't malicious. They're using the tools they've been told to use. The incentive structure is broken. AI makes it trivially easy to generate a PR. It doesn't make it easy to generate a good one.

This connects to the broader question of AI in creative work. Making something is now cheap. Making something good still requires taste, judgment, and effort. The tools changed. The standard didn't.

Target length: 700 words

Signal 4: "What 2,200 games at Steam Next Fest tell you about discovery"

Steam Next Fest February 2026 is a dataset, not just an event. 2,200+ games. Clear tier breakdowns. Genre performance data. Patterns you can actually act on.

This piece would go deeper than the news article (which covers facts). It would analyze what the data means for indie developers choosing where and how to launch. Co-op games overperformed. Narrative games underperformed. Games with existing momentum compounded it. Games starting cold mostly stayed cold.

Then connect it to what Cinevva is building. Steam Next Fest rewards games that already have an audience. Cinevva's reels-first discovery is designed for games that don't. The approaches are complementary, not competing. But the Next Fest data shows why alternative discovery paths matter.

Target length: 800 words

Section logistics

URL structure: /signals/ with individual posts at /signals/YYYY-MM-DD-slug Frontmatter: Same as news (title, description, date) plus author field like blog Index page: Similar to news index, chronological, with RSS Navigation: Add under the "Learn" dropdown alongside News, Blog, Tutorials, Guides Frequency: 2-4 per month, whenever something worth analyzing happens Authors: Primarily Mariana. Oleg for technical signals. Guest contributors eventually.

Part 3: About "Alina"

I searched the entire codebase, blog posts, about page, team pages, and external sources for references to "Alina." I found no one by that name associated with Cinevva or the immediate game development tool space.

Possibilities:

• Alina.social is a social media content management platform with an AI editor, but it's not related to game development
• There's an "Alina" user on GDevelop (gd.games/Alina) who creates games on the platform
• Could be a team member, collaborator, or friend whose work isn't yet reflected in the codebase

If "Alina" refers to someone specific on the team or in the community, I'd need more context to research what she's building and incorporate it into the content plan.

Part 4: Recommended publishing order

Week of Feb 27 - Mar 2:

1. News: Godot 4.6 released (Feb 27)
2. News: Unity previews AI game creation (Feb 28)
3. News: Roblox launches 4D AI models (Mar 1)

Week of Mar 3 - 9: 4. News: Godot maintainers and AI PRs (Mar 3) 5. Signals: "Everyone wants to be the AI game engine now" (Mar 4) 6. Signals: "Open source has an AI pollution problem" (Mar 6)

Week of Mar 10 - 16 (GDC week): 7. News: Steam Next Fest February results (Mar 10) 8. Signals: "What 2,200 games tell you about discovery" (Mar 11) 9. Signals: "Vibe coding is the new game jam" (Mar 13)

This schedule gets us back to regular publishing, establishes the Signals section, and creates a rhythm around GDC week.

Roblox opened the beta for its 4D creation tool on February 4. The tool generates interactive 3D objects from natural language prompts, and unlike standard text-to-3D tools, these objects have real physics and player-driven behavior built in.

Roblox VP of AI explains the Cube foundation model and 4D creation

What "4D" means here

The "4D" in Roblox's naming refers to interactivity over time. A 3D model is a static mesh. A 4D object is a mesh with behavior. You prompt "a red sports car" and get a drivable vehicle with four independently spinning wheels, a body that responds to collisions, and controls that react to player input.

The system uses "schemas" that define object structure and behavior. At launch, two schemas are available:

• Car-5: Five-part vehicles with working wheels, steering, and collision physics
• Body-1: Single-piece objects like boxes, sculptures, or furniture with basic interactive properties

The numbers

During early access (starting November 2025), players generated over 160,000 objects using the 4D tools. Users who engaged with 4D generation showed a 64% average increase in play time compared to baseline.

A showcase experience called "Wish Master" by developer Laksh lets players generate and drive cars, fly planes, and control dragons, all created through prompts in real time.

A creator testing the 4D AI creation tools inside Roblox

What's coming next

Roblox plans to let creators build custom schemas for more object types beyond cars and simple bodies. They're also working on reference-image-to-3D generation and what they call "real-time dreaming," an AI world model approach that generates dynamic environments and objects on the fly.

This builds on their earlier Cube 3D model (released March 2025), which was open-sourced and generated over 1.8 million 3D objects on the platform.

References

• TechCrunch
• Reuters
• Roblox Cube announcement

Unity CEO Matthew Bromberg announced that Unity will demo a new AI beta at the GDC Festival of Gaming (March 9-13) that lets creators "prompt full casual games into existence with natural language only."

Unity CEO Matthew Bromberg discussing AI strategy and the platform's direction

What Unity said

Bromberg described AI-driven authoring as Unity's "second major area of focus for 2026." The tool will be native to the Unity platform, which means generated prototypes can be iterated into production-quality games without switching environments.

Under the hood, Unity says it combines the company's understanding of project context and runtime with frontier models from OpenAI (GPT) and Meta (Llama). The AI assistant will be web-accessible to reduce friction.

Bromberg estimated this could bring "tens of millions of more people creating interactive entertainment" through AI-enabled development tools.

What we know and don't know

Known: The beta exists and will be shown at GDC. It targets casual games. It uses natural language input. It's integrated with Unity's runtime and context system. Enhanced in-app purchase commerce tools are coming alongside it, with general availability in Q2 2026.

Unknown: What "full casual games" means in practice. Whether generated games are editable at the code level or only through continued prompting. How it handles asset generation versus code generation. What the quality ceiling looks like. How it compares to existing text-to-game tools.

Why it matters

Unity is the most widely used game engine in the world. When Unity puts AI-first game creation at the center of its product strategy, it signals that the market has moved past the experimental phase. This is the same company that faced developer backlash over the 2023 Runtime Fee. They're betting AI authoring is what wins developers back.

GDC runs March 9-13 in San Francisco. The 2026 event is being restructured as a "Festival of Gaming" with simplified passes starting at $649 for five days.

References

• The Verge
• Game Developer
• GDC Festival of Gaming 2026

Godot 4.6 landed on January 27, following through on the Q1 2026 preview we covered earlier. The release is one of the most feature-dense in the engine's history, and the changes matter for web developers specifically.

What shipped

Jolt Physics is now the default. Every new 3D project in Godot 4.6 uses Jolt, the same physics engine behind Death Stranding 2. Jolt has been available as an experimental option since 4.4, but this release makes it the standard. For web exports, Jolt's performance profile is noticeably better than the old GodotPhysics backend.

Modern editor theme. The new default theme, based on the community-favorite Godot Minimal Theme by passivestar, replaces the classic blue-tinted interface. Clean lines, improved spacing, grayscale palette for color-sensitive work. It's a visual refresh that keeps focus on the viewport.

Unified docking system. Panels can now be moved between sides and bottom freely, and most docks support floating windows. You can rearrange the editor layout to match how you actually work.

Screen Space Reflections overhaul. The SSR system got a full rewrite with improved roughness handling, better visual stability, and a half-resolution rendering mode for performance on constrained hardware.

LibGodot. You can now embed Godot as a library inside other applications. Initial support covers Linux, Windows, and macOS. This opens the door for using Godot as a rendering or game logic layer inside custom tools, launchers, or entirely different applications.

Other changes worth noting: unique node IDs that survive scene reorganization, delta encoding for smaller patch updates, rotatable TileMap tiles, in-game speed controls for testing, and C++ tracing profiler support.

What it means for web developers

Godot's web story has improved every release since 4.3 introduced single-threaded export. The 4.6 release continues that trajectory. Jolt's better performance matters when you're running physics in a browser. The SSR half-resolution mode helps on mobile web. And LibGodot's embedding capability could eventually let you run Godot scenes inside existing web applications, though web support for LibGodot hasn't been confirmed yet.

References

• Godot 4.6 release page
• Game Developer coverage

Cinevva is now live—a new way to discover indie games through short gameplay reels and instant browser play.

The problem we're solving

• Store pages don't show the fun. Screenshots and trailers are marketing, not gameplay.
• Too many clicks to play. Download, install, load, tutorial... friction kills interest.
• Great games stay buried. Indies can't compete with AAA marketing budgets.

How Cinevva works

Scroll. See. Play.

Watch 15-second gameplay clips. When something looks fun, launch it instantly in your browser. No downloads. No installs. No waiting.

Why now

The timing is right:

• WebGPU is now in all major browsers, enabling better graphics
• WebAssembly performance keeps improving
• AI-generated content has created a trust crisis—players want to see real gameplay
• Instant play removes the friction that kills discovery

For players

Discover your next favorite game in seconds, not hours.

For creators

Get your game in front of players who actually want to play it.

Try it

Head to app.cinevva.com to start discovering games.

Godot 4.6 is projected for release in Q1 2026, following the engine's regular release cadence.

What to expect

Based on Godot's release policy and community discussions:

• Continued improvements to web export stability
• Potential WebGPU backend progress (currently experimental)
• Further WASM optimizations building on 4.5's SIMD support
• Bug fixes for web-specific issues reported in 4.5

Godot's web momentum

Since Godot 4.3's single-threaded web export (August 2024), each release has improved the web story:

• 4.3: Single-threaded export for easier hosting
• 4.4: Stability improvements
• 4.5: WASM SIMD by default

References

• https://docs.godotengine.org/en/latest/about/release_policy.html

As of early 2026, WebGPU is supported by default in Chrome, Firefox, Safari, and Edge across desktop and mobile platforms. This marks a fundamental shift in what's possible for browser-based games.

What changed

• All major browsers now ship WebGPU by default
• Compute shaders enable GPU-accelerated physics, AI, and effects
• Modern rendering patterns that were impossible with WebGL are now viable
• Engine support from Three.js, Babylon.js, Unity, PlayCanvas, and others

What this means for developers

The conversation has shifted from "will WebGPU be supported?" to "how do I best use WebGPU?"

Key considerations:

• Keep WebGL fallbacks for older browsers and devices
• Test across browsers—implementations vary slightly
• Profile your specific scenes, not just demos
• Consider compute shaders for physics and particle systems

The ecosystem in 2026

• Babylon.js 8.0: Native WGSL shaders, no GLSL conversion needed
• Three.js r170+: Zero-config WebGPU imports
• Unity 6.1: WebGPU as a supported backend
• Godot: WebGPU backend in development

Looking ahead

Web games can now achieve visual quality that was previously reserved for native applications. The gap between "web game" and "real game" continues to narrow.

WebGPU has moved from "future tech" to something you can realistically target for most players.

Why this matters for web games

• Better GPU access than WebGL for modern rendering patterns
• Compute shaders for effects, simulation, and GPU-side workloads
• A clearer path to desktop-quality visuals in the browser

Browser support timeline

• Chrome 113+ (May 2023)
• Firefox 141+ on Windows (2025)
• Safari 26 (September 2025)
• Edge follows Chrome

What to do as a developer

• Add capability detection and keep a WebGL fallback for older browsers
• Expect different performance profiles vs WebGL: measure on your real scenes
• Treat WebGPU as an opportunity to simplify pipelines

References

• https://web.dev/blog/webgpu-supported-major-browsers
• https://developer.chrome.com/blog/new-in-webgpu-113

Cinevva has been selected as one of the stars of this generation's World's Top Performing Startups in the digital science category by Shanghai's local investors ecosystem.

What this means

The recognition highlights Cinevva's mission to make game creation, discovery, and self-publishing accessible to everyone—across all channels and devices.

Our approach to AI

While the AI race intensifies, we're taking a different path: orchestrating state-of-the-art AI tools to serve our users' end goals—not replacing creators, but empowering them.

• Bring ideas to life in minutes
• Publish more, faster
• Express yourself through games
• Prompt from your phone or PC

Build a voice. Build an audience. Thrive.

Looking ahead

We're excited to explore partnerships with organizations like Tencent, Tencent Games universities, and other supporters in the space as we continue growing globally.

Source: Mariana's LinkedIn announcement

Godot 4.5 was released on September 18, 2025, with WebAssembly SIMD enabled by default for web exports.

Key web export improvements

• WASM SIMD by default: Single Instruction Multiple Data operations improve performance without manual configuration
• Single-threaded export remains default: Avoids Cross-Origin Isolation header requirements
• PWA support improved: Service worker fallback for COOP/COEP headers

PWA features

• High-resolution icons
• Display orientation settings
• Offline support via service worker caching
• Custom offline page option

Continued limitations

• C# not supported for web export (use GDScript or Godot 3.x for C#)
• Audio restrictions in browsers (user interaction required)
• Full-screen must be triggered by user input

References

• https://godotengine.org/releases/4.5/
• https://docs.godotengine.org/en/4.5/tutorials/export/exporting_for_web.html

Safari 26 marks Apple's full commitment to WebGPU, enabling it by default across all Apple platforms.

What's included

• macOS Tahoe (macOS 26)
• iOS 26 and iPadOS 26
• visionOS 26

Why it matters

Safari was the last major browser to ship WebGPU support. With this release, web games can target WebGPU across essentially all modern browsers without feature detection fallbacks for most users.

For web game developers

• Test your WebGPU games on Safari/WebKit
• Apple's Metal backend may have different performance characteristics than D3D12/Vulkan
• Mobile Safari now supports compute shaders

References

• https://webkit.org/blog/14879/webgpu-now-available-for-testing-in-safari-technology-preview/

Three.js r170 continues the WebGPU maturation with improved organization and broader format support.

Key changes

• WebGPU modules moved to addons for cleaner imports
• GLTFLoader improvements under WebGPU renderer
• Better compatibility with existing Three.js codebases

Import changes

import { WebGPURenderer } from 'three/webgpu';

For web game developers

The WebGPU path in Three.js is becoming more stable and production-ready with each release.

References

• https://github.com/mrdoob/three.js/releases

Firefox 145 extends WebGPU support to Apple Silicon Macs, an important milestone for cross-browser compatibility.

Support timeline

• Firefox 141: Windows support
• Firefox 145: macOS ARM64 support
• Linux and Android: still rolling out

Why it matters

With this release, Firefox joins Chrome and Safari in supporting WebGPU on the most common desktop configurations. Web game developers can now target WebGPU with higher confidence.

References

• https://www.mozilla.org/en-US/firefox/releases/

Unity 6.1, released in April 2025, adds WebGPU as a supported graphics backend for web builds.

What's included

• WebGPU backend for browser builds and Instant Games
• Improved web performance and stability
• Enhanced debugging tools for web exports
• Instant Games platform support expansion

Why it matters

Unity catching up on WebGPU means the most-used game engine now offers a modern path to browser deployment. Developers can target WebGPU for better performance while falling back to WebGL for compatibility.

Considerations

• Test early for build size and load times
• WebGPU support varies by browser
• Keep shaders and assets optimized
• Some browser APIs may not be implemented

References

• https://unity.com/releases/unity-6

GeoGuessr, the geography guessing game that built its audience as a browser game, launched on Steam in Early Access.

Why it matters

This demonstrates that successful browser games can expand to traditional gaming platforms. The path from web to Steam is viable for games that build an audience online first.

The browser-to-Steam model

• Build and iterate quickly on the web
• Grow an audience without install friction
• Expand to Steam for discoverability and features

References

• https://store.steampowered.com/app/2959080/GeoGuessr/

Babylon.js 8.0 was released on March 27, 2025, with a major architectural improvement: all core engine shaders are now available in WGSL.

Key features

• WGSL-first shaders: No GLSL-to-WGSL conversion needed for WebGPU builds
• Smaller bundle sizes: Eliminating the translation layer reduces download size
• IBL Shadows: Image-based lighting shadow support
• Area Lights: More realistic lighting options
• Node Render Graph (alpha): Visual render pipeline editing

Why WGSL matters

Previously, Babylon.js would convert GLSL shaders to WGSL at build time for WebGPU. With native WGSL support:

• Faster builds
• Smaller bundles
• More predictable behavior
• Better debugging

For web game developers

If you're using Babylon.js for WebGPU games, 8.0 is a significant upgrade. The reduced overhead makes WebGPU an even more attractive target.

References

• https://blogs.windows.com/windowsdeveloper/2025/03/27/announcing-babylon-js-8-0/
• https://forum.babylonjs.com

Cinevva won second place ($10,000) in the Dell for Startups pitch competition at SXSW 2025 in Austin.

The competition

Founder Institute Texas alumni pitched live on the Dell Experience stage at SXSW, competing for $25,000 in total prize money provided by Dell for Startups.

The pitch

Cinevva founder Mariana Muntean presented the platform's vision: making game creation and discovery accessible to non-technical creatives through browser-based tools and AI assistance.

Results

• 1st place ($15,000): Intuily (Austin)
• 2nd place ($10,000): Cinevva (Houston)

What this means

The recognition validates Cinevva's approach to democratizing game creation and discovery. The prize money supports continued development of the platform.

References

• Founder Institute announcement

Godot 4.4 was officially released on March 3, 2025, continuing the engine's investment in web as a first-class platform.

Web export improvements

• Continued refinements to single-threaded export (introduced in 4.3)
• Better WebGL 2.0 compatibility
• Improved audio handling in browsers

Known limitations

• C#/.NET projects still not supported for web export
• Some audio features (AudioStreamInteractive) have issues in web builds

References

• https://godotengine.org/releases/4.4/
• https://docs.godotengine.org/en/4.4/tutorials/export/exporting_for_web.html

As of December 11, 2024, WebAssembly garbage collection (WasmGC) is available by default in all major browsers.

Browser support

• Chrome 119+: enabled by default
• Firefox 120+: enabled by default
• Safari 18.2: added support

Why it matters for web games

WasmGC makes it easier for languages with garbage collection (Kotlin, Dart, Java, etc.) to compile to WebAssembly without bundling their own GC. This means:

• Smaller WASM bundles
• Better performance for GC-heavy languages
• More options for game development toolchains

The practical impact

Games and engines written in languages that need GC can now target the browser more efficiently. Expect to see more diverse toolchains targeting WASM.

References

• https://web.dev/blog/wasmgc-wasm-tail-call-optimizations-baseline
• https://v8.dev/blog/wasm-gc-porting

Three.js r171 makes it easier than ever to use WebGPU with zero-config imports.

What changed

You can now import WebGPURenderer without special bundler configuration:

import { WebGPURenderer } from 'three/webgpu';

No polyfills, no extra setup, no bundler tweaks required.

Why it matters

Lower friction means more developers will try WebGPU. The Three.js team has been steadily reducing barriers to WebGPU adoption.

References

• https://github.com/mrdoob/three.js/releases/tag/r171

Epic Games launched Fab on October 22, 2024, consolidating multiple asset marketplaces into one unified platform.

What's included

• Unreal Engine Marketplace content
• Sketchfab Store assets
• Quixel Megascans (free through end of 2024)
• ArtStation Marketplace (migration planned for 2025)

Key details

• Revenue share: 88% to creators, 12% to Epic
• Format support: Unreal, Unity, Blender, Maya, Cinema 4D
• Planned support: Roblox and Minecraft formats coming

For web game developers

Fab assets work across multiple engines, including those that export to web. The unified search and licensing makes it easier to find and use assets legally.

References

• https://www.fab.com
• https://www.unrealengine.com/en-US/blog/fab-epics-new-unified-content-marketplace-launches-today

On September 12, 2024, Unity officially cancelled the Runtime Fee for all game-making customers, effective immediately.

What changed

• No per-install fees for any game, on any version of Unity
• Return to seat-based subscription model
• Free (Personal) tier revenue cap increased to $200,000/year
• Unity 6 users can optionally remove the "Made with Unity" splash

Pricing changes (effective January 1, 2025)

• Unity Pro: increased ~8% to $2,200/year
• Unity Enterprise: increased ~25%
• Companies with $25M+ revenue/funding require Enterprise tier

Why it matters

The Runtime Fee had caused significant uncertainty for developers planning budgets and business models. Its cancellation restores predictability to Unity's pricing.

References

• https://unity.com/blog/news/pricing-and-packaging-updates

Godot 4.3, released on August 15, 2024, brings back single-threaded web exports as a major quality-of-life improvement.

Why it matters

Multi-threaded web exports require special HTTP headers (COOP/COEP) that many hosting platforms don't support or make difficult to configure. Single-threaded exports work everywhere:

• itch.io and other game portals
• GitHub Pages and static hosts
• macOS and iOS Safari (which had issues with multi-threaded builds)

What changed

• Single-threaded export is now available and enabled by default
• Multi-threaded export still available when needed
• Reduced hosting friction for indie developers

References

• https://godotengine.org/releases/4.3/
• https://godotengine.org/article/progress-report-web-export-in-4-3/

Three.js r167, released in July 2024, enables WebGPU by default when the browser supports it.

What this means

When WebGPU is available, Three.js will automatically use WebGPURenderer instead of requiring manual setup. WebGL remains the fallback for browsers without WebGPU support.

Benefits

• Automatic detection: no code changes needed for WebGPU benefits
• Graceful fallback: WebGL still works everywhere
• Future-proof: apps automatically improve as browser support expands

For developers

Test your Three.js apps in WebGPU-capable browsers to ensure they work correctly with both renderers.

References

• https://github.com/mrdoob/three.js/releases/tag/r167

PlayCanvas announced integration with Sketchfab, allowing developers to browse, preview, and import 3D models directly within the PlayCanvas Editor.

How it works

• Browse Sketchfab's library from the Asset Store panel
• Preview models before importing
• License and author information preserved

Why it matters

For web game developers using PlayCanvas, this reduces friction when finding and adding 3D assets. No need to download, convert, and re-upload models manually.

Note

This is an integration, not an acquisition. Sketchfab remains owned by Epic Games and is now part of the Fab marketplace.

References

• https://blog.playcanvas.com/playcanvas-adds-sketchfab-integration

Unreal Engine 5.4 was officially released on April 23, 2024, with continued improvements to Pixel Streaming for web deployment.

Pixel Streaming 2 (experimental)

• New Pixel Streaming Player component
• Support for H.264, VPX, and AV1 encoders
• Display active pixel streams as media sources within UE projects

Why Pixel Streaming matters

Since Unreal dropped native HTML5 export, Pixel Streaming is the primary way to run high-fidelity UE content in browsers. The game runs on a server and streams video to the browser.

Trade-offs

• Pro: Full Unreal fidelity in browser
• Con: Requires server infrastructure and bandwidth
• Con: Latency-sensitive games may struggle

References

• https://www.unrealengine.com/en-US/blog/unreal-engine-5-4-is-now-available
• https://dev.epicgames.com/documentation/en-us/unreal-engine/pixel-streaming-in-unreal-engine

Babylon.js 7.0 was officially released on March 28, 2024, with significant performance improvements and new features.

Key highlights

• Performance gains across rendering pipeline
• WebGPU improvements including Snapshot Rendering (render bundles)
• Gaussian Splatting support for novel view synthesis
• Procedural geometry enhancements

Snapshot Rendering

Babylon.js's Snapshot Rendering uses WebGPU render bundles to cache and reuse GPU command lists, potentially achieving 10x CPU-side speedups for static geometry.

Why it matters

Babylon.js continues to push what's possible in browser-based 3D. For web game developers, 7.0 offers meaningful performance improvements without code changes.

References

• https://forum.babylonjs.com/t/introducing-babylon-js-7-0/49132
• https://blogs.windows.com/windowsdeveloper/2024/03/28/part-1-announcing-babylon-js-7-0/