The Unity Engine Roadmap

It was impossible for me to share live at Unite all the great features they have planned as it was so packed. Check the recording and you'll definitely find something interesting for you.

I posted the most exciting stuff for me live on the 19th of November, what do you expect the most from the roadmap?

https://youtu.be/rEKmARCIkSI

#roadmap

Optimizing Burst matrix multiplications

A deep dive into optimizing matrix multiplications. A story of multiple optimization attempts, moving from basic implementation to hand-tuned intrinsics.
Key takeaways from the optimization journey:
* Switching to Unity’s Mathematics package (SIMD-friendly) immediately gave a massive boost over standard C#.
* The Low-Hanging Fruit: Using FloatMode.Fast allows the compiler to merge instructions into Fused Multiply-Add (FMLA).
* Reinterpreting NativeArray<Matrix4x4> as float4x4 helps the compiler see the data layout more clearly, reducing instruction count.
* Utilizing Affine Matrices (since most game objects don't use perspective projection) allows you to skip calculating the 0,0,0,1 row, saving significant cycles.
* Using Intrinsics and float4x3 to pack data tightly into vector registers.
This is a must-read if you are working on high-performance physics, skinning, or animation systems in Unity.

https://medium.com/toca-boca-tech-blog/optimizing-burst-matrix-multiplications-bfb301de80ce

#burst #optimiziation

Using DOTS to optimize GameObject gameplay: A case study from Survival Kids | Unite 2025

The recording is available now.

https://www.youtube.com/watch?v=ZkvK0mX-id4

#optimization

Unity 6.3 LTS is available

Hopefully, they are addressing old issues as well.

Key changes for me in 6.3:
* Platform Toolkit: A unified API for handling accounts, save data, and achievements across platforms (Steam, Consoles, Mobile).
* HTTP/2 Support: Now the default for UnityWebRequest where supported, reducing server load and device CPU usage.
* AssetBundles & Addressables: Improved with TypeTree deduplication, which can significantly reduce runtime memory usage and speed up build times.
* Sprite Atlas Analyzer: A new tool to identify inefficiencies, wasted space, and compression issues in atlases.
* SRP Batcher Improvements: A new API for dynamic custom values (Shader User Values) allows the SRP Batcher to handle per-instance data, a performant alternative to Material Property Blocks.

Has anyone tried this in production yet?

Also, for those who already upgraded from 2022 LTS: is it safer to step to 6.0 LTS first, or jump straight to 6.3 LTS?

https://unity.com/blog/unity-6-3-lts-is-now-available

#lts

Understanding Unity memory | Unite 2025

One of my favorite talks this year, which I recommended in my live report from Unite, is now available on YouTube.

https://www.youtube.com/watch?v=0y3erF2tzbI

#memory #unsafe

Why await Resumes on the Main Thread in Unity - SynchronizationContext

I have been working on projects that extensively use async, both Task and UniTask, for many many years already. And we always had a lot of strong engineers who understood the ins and outs of how it works in Unity. So I had a great opportunity to learn from them not only how it works, but, more importantly, how to use it correctly to avoid critical issues.

I have also conducted many dozens of interviews, and I noticed that a lot of people just use async and do not know the internals or about the existence of a custom synchronization context in Unity. And that is usually okay for 99% of cases, you are here to make games in the end. However, when this remaining 1% happens in a critical module, it may cause unpredictable harm, like players losing progress or an ANR rate three times higher than usual.

I also see a lot of confusion around asyncs in general. For example, some people assume that using await in Unity means creating new threads and doing multithreading, without realizing that it would be very inefficient to use multithreading for something like UniTask.Delay. It’s also easy to overlook the difference between creating threads and using the thread pool, or that an async method can execute synchronously. Sometimes people don’t fully grasp the purpose of ValueTask or what happens if the same UniTask is awaited twice. And I am not even talking about the magic that compiler does for us when we write "await" and the difference in how the async state machine is compiled in debug and release builds.

I also noticed that people who are willing to dive into how things work under the hood, and who show engineering curiosity, can troubleshoot issues much better. They don’t stop after the first unsuccessful step when we have tricky bugs to uncover.

So you don’t need to know what this post talks about to make games, but it will help you in the future not only pass heavy theory interviews (which is a widespread thing), but also prevent critical issues, which is extremely important when you work on a live game with millions of users.

https://discussions.unity.com/t/why-await-resumes-on-the-main-thread-in-unity-synchronizationcontext/1700147

#async #synchronizationcontext

Unity's Mono problem: Why your C# code runs slower than it should

* Unity uses Mono, a legacy JIT runtime → 2–3× slower than modern .NET
* Benchmarks: map generation and game startup take 100s in Unity/Mono, 38s in .NET (Debug mode)
* Even in Release mode: Mono 30s vs .NET 12s
* Mono JIT produces unoptimized machine code, lacks modern runtime features
* CoreCLR promises major speedups + modern APIs, SIMD, hardware intrinsics
* Burst compiler helps, but limited; CoreCLR would unlock broader improvements

To add to the author’s ideas, Editor performance is also a huge benefit, not just runtime. Slow iteration can cost hours per week, making iteration speed crucial for big teams and projects.

Working with LLMs adds another challenge: AI can sometimes break working code while fixing old bugs. Using unit tests to verify existing logic helps, but running them in Unity Test Runner is slow and requires a lot of manual work.

With a great idea from a friend, I created an infrastructure to run unit tests on the latest .NET without using the Unity Editor. This lets AI run the tests by itself to verify its changes, so no manual action is needed, and it takes mere seconds compared to Unity Test Runner.

I haven’t seen any info about this setup online yet, so either me or my friend might prepare a sample and a post describing how to set it up, but that’s still undecided. Drop a 💯 if you are interested

https://marekfiser.com/blog/mono-vs-dot-net-in-unity

#coreclr #performance

UI Toolkit Tutorial: Custom Shaders for UI Toolkit (6.3)

I won't be using UI toolkit for my next project yet. However I am happy to see it's improving, so bookmarking the video for the future.

https://youtu.be/xAOBBW9hsjA

#uitoolkit

Running Unity Tests at Warp Speed with .NET

A while back, I posted about running Unity tests faster using .NET. So I sat down and documented the entire setup.

https://gamedev.center/run-unity-tests-faster-dotnet/

#testing

Played around with Claude Code and remote controls while working on a prototype. Good alternative to doomscrolling.

As you might know, the dopamine hit usually comes from the anticipation of finding a good video while scrolling, not the video itself. Now you can just "scroll" prompts to an agent instead. It’s useful for commuting when you don't have a laptop but still want to be kinda productive.

The setup:

- a web game (Three.js for the prototyping phase)

- claude code

- remote control (CC feature)

- github action (publishes to itch.io draft on tagged master commit)


The loop: I write a prompt, Claude implements it and tests via the Chrome Dev Tools MCP. If it reports success, I ask it to be pushed to master with a tag.

In about a minute, the build is playable in a mobile browser on itch.io. I can play and iterate on it further from there.

Can the anticipation of an agent’s output actually compete with a TikTok algorithm for you, or is this just a honeymoon phase?

Around 4–5 weeks ago I used my Google account with an AI Pro subscription to set up OpenClaw. Turned out it was against ToS and I was banned overnight from using Antigravity and Gemini CLI.

I believe the correct option was to use the API key created in the Google Cloud panel. However, despite having monthly credits on my cloud account included in the Pro subscription, I couldn't use it unless I paid $30 directly on top, which is weird to me.

I wrote an email to them, got no reply obviously, and forgot about Gemini completely until recently.

I decided to check it again and I was unbanned. If you were banned too, is it working for you now? I don’t know if my email helped or they unbanned everyone.

Anyway, the reason I got back to Antigravity was that I found an interesting repo I wanted to test: Agency Agents

I checked the Antigravity docs and didn't find anything about agent setup. I just dropped them into a project like with Claude Code and asked the LLM to check it and fix the setup. It reassured me that everything was correct and that it supports agent teams.

However, with all models, Antigravity fails to follow through the whole workflow. I have to pinpoint missed steps for every single task.

Heavily inspired by the original repo, I prepared a team specialized in game development with Unity: https://github.com/AlexMerzlikin/unity-agent-team

I also added custom tools to the Coplay Unity MCP to take screenshots and interact with the in-game logic. This way, the LLM can write manual test cases, run the game, take screenshots, and query the scene hierarchy to verify these "manual" tests.

First impressions of these agents:
• As said above Antigravity doesn't support it at all.
• Codex and Claude Code integration is great. You can check what each agent does, and they run in parallel, making the whole flow a lot faster.
• This team produces a lot of documentation. Compared to the default old Sonnet, which created multiple docs per prompt, this team does it better though. Everything is structured according to Nexus Sprint rules, and I feel like it helps to understand how your requirements transform throughout the dev pipeline. Also, each agent is super focused. Subjectively, there is less fluff in each document, and I get the exact info I need from a particular output. It's great for when I work on a big project, but it's too much overhead for prototypes. I prefer to skip it completely when just testing ideas.
• Token drain. Each agent has its own context, so token spend multiplies. Keep that in mind when testing these agents, or tailor it to reduce the number of agents.

If anyone tries out the Unity agent team repo, drop a comment. I am curious to see how it handles your specific setups and workflows.

#ai #agent

I am using Superpowers and I was surprised by its visual companion skill. Claude used it automatically when I asked it to introduce better character models into my prototype.

Instead of only describing the plan in text, it suggested starting a local server and preparing a page with visual examples.

Of course, it uses more tokens, but I feel like it made iteration on the new design much faster than before.

A while ago I shared my Unity agent team repo here, and I've been using it in my daily work ever since. Last weekend I added two new agents focused purely on performance: a Unity Performance Reviewer and a Unity Profiler Analyst.

And already yesterday, I got the first big win. On the very first try, the Profiler Analyst identified a real memory regression in our live game just by reading a Memory Profiler snapshot. The kind of issue that can easily slip past a normal code review but stands out immediately once something actually inspects what is resident in memory. I'll keep the specifics internal, but the takeaway was: a meaningful production-shape issue affecting scalability, found on input capture #1, on a codebase the agent had zero prior context on.

What each of the two agents does:
• Performance Reviewer reviews diffs through a pure runtime-cost lens: allocations in hot paths, GC pressure, draw-call growth, Canvas rebuilds, shader variant explosion, mobile frame budgets. It complements the generic code reviewer: that one cares about correctness, this one only asks "what will this cost at 60 FPS on a cheap device?"
• Profiler Analyst doesn't touch code at all. It ingests Profiler / Profile Analyzer / Memory Profiler / Frame Debugger captures and returns a ranked, quantified optimization plan.

That said, a grain of salt: one good catch isn't a pattern yet. Profile first, then optimize (if needed), even when the agent sounds very confident 🙃

Drop a 🔥 if you want more examples of how I use these at work.

https://github.com/AlexMerzlikin/unity-agent-team

#ai #agent #performance #unity

A follow-up on my Unity agent team repo. In the comments on the last post Artem asked about the custom MCP tools the tester agent uses.

Here is the implementation from my prototype, sitting on top of the Coplay Unity MCP: custom actions to interact with the game, screenshots and scene hierarchy queries, so the agent can actually verify its own "manual" tests. Nothing fancy, but it closes the loop end-to-end. Feel free to adjust it for your own game logic.

Fair warning: this drains tokens fast. Automated tests are of course way faster and cheaper to run, and if you can cover a case with a unit or integration test you probably should. The difference with this setup is that the agent plays your actual game against "manual" test cases, not a test harness with mocks and stubs. And on my prototype I saw real results: the agent walked through real gameplay logic, caught actual issues, and reported back in plain English. Not a replacement for the automated suite, more of an extra pass on top. Your mileage may vary.

https://gist.github.com/AlexMerzlikin/a810877fb26c2325536213295ddb84c3

What is your setup for letting an agent verify its own changes in a running Unity build?

#ai #agent #unity #mcp

"Software Fundamentals Matter More Than Ever" — Matt Pocock

I recently watched a short conference talk about how software fundamentals are even more important now in the age of AI. It focused heavily on one of my favorite books, "A Philosophy of Software Design."
Of course, not all the advice there applies directly to game development, but I still highly recommend checking it out and using the other concepts proposed by the author.
I am already trying a /grill-me skill, and it feels like /brainstorming from superpowers. But it asks a lot more questions and helps you shape much better requirements. Anyway too early to say which one is better.

What do you think about it?

https://www.youtube.com/watch?v=v4F1gFy-hqg

#ai