Everyday Unity

Hey! One participant had to cancel today, so there’s a free spot at 19:00 CET (in ~80 minutes).
I know it’s super short notice, but I’m sure we can still have a great chat and find ways for you to grow.
Feel free to grab it through the same link.

In Case You Missed It - August 2025

Guys at Unity Technologies were pretty active the last month. A lot of how-to pages were added. I haven't found any new advice there, but it's convenient to have them all compiled in one place.

The how-to on the project setup mentions:

Switch to IL2CPP
Switching the scripting backend from Mono to IL2CPP (Intermediate Language to C++) can provide overall better runtime performance. However, it can also increase build times. Some developers prefer to use Mono locally for faster iteration, then switch to IL2CPP for build machines and/or release candidates. Refer to the Optimizing IL2CPP build times documentation for more on reducing your build times.

I haven't compared mono to il2cpp performance in my games, but I have seen forum posts where devs shared that mono is faster for them. Have you measured your games? Was it true for you?

https://discussions.unity.com/t/in-case-you-missed-it-august-2025/1681933

I'm gonna offer free 1-1 mentoring sessions in game development, software engineering, and tech career growth.

While my primary experience is in game development, these sessions are open to everyone

Lately, I’ve been focusing on:
✔ Technical leadership
✔ Scalable game architecture
✔ Performance and optimization

But we can talk about anything. I’ve created games from scratch to production on mobile and PC. So I have a wide range of experience. I’ve shipped games with millions of DAU, some of the largest titles on the market
Feel free to check my profile and blog to learn about my background: https://gamedev.center/about/

Book a session using the link below and include any details or questions, so we can make the call as effective as possible. Come prepared to discuss and dive deep into your topics

Sessions are available in English and Russian
I’m starting with limited slots, so if the calendar is full, save this post and drop a comment

If you’re interested, book your session here:
Book here

#mentoring

SmartAddresser: Automate Addressing, Labeling, and Version Control for Unity's Addressable Asset System

I wouldn’t say I add a lot of assets to groups all the time, but even if it helps me do this in a few clicks instead of the usual ten, it still saves time. The workflow also becomes somewhat similar to the current sprite packer with a folder setup.

I am wondering would you find it more helpful given your daily routine?

https://github.com/CyberAgentGameEntertainment/SmartAddresser

#addressables #editortools

High Performance C#

The example implementation of finding a “marker” in a string of characters. The author started with a naive approach and then optimized it. I like reading such optimization stories where engineers profile and optimize their code. Of course, real stories from tech trenches are a lot more interesting, but this one is short and might be helpful for someone.

Just remember: profile first, then optimize if needed.

https://www.wolfpackit.nl/en/blog/advent-of-code-at-wolfpack-high-performance-c/

#performance

I have seen multiple game developers posting about their experience with AI tools lately. However I missed a few important steps in these posts, that I find extremely useful.

I started "vibe coding" more than two years ago when stuff like copilot or codium were not able to generate even a whole class if it was bigger than 150 lines of code and was leaving comments like "// here is the rest of implementation unchanged".
And now when modern tools can generate a whole feature in one go and sometimes even without bugs (rarely).

Here is what two years of vibe coding taught me.

I don’t start with code. I start with design.
Every new feature, system, or refactor begins with requirements and PlantUML diagrams, often generated with AI and then refined by me. I visualize how everything fits together.

No AI touches my codebase unless there’s a diagram first.
If I can’t explain it in a diagram, it’s not ready to be implemented by AI. When I code manually, I have full control and can easily start without design and iterate on the fly. AI can’t do that. Without clear technical constraints in the form of diagrams, it quickly creates unmaintainable chaos.

Why PlantUML?
Because it’s code.
Text-based, versioned, reusable, tweakable. I can store diagrams next to the codebase, review them in PRs, and evolve them as systems change.

Visual consistency matters.
PlantUML diagrams look the same whether you’re a UML expert or a beginner. That removes noise and keeps everyone focused on the system, not the drawing style.

Hand-drawn diagrams?
Beautiful, but useless after a week. Hard to maintain, impossible to diff, and AI can’t update them.

With PlantUML, I can iterate fast. Combined with LLMs, it’s even faster:
“Generate a sequence diagram for this flow.” Done. Then I validate responsibilities, avoid circular dependencies, and refine the design before coding. What is more these diagrams are used in the future as prompts to add new functionality to existing features.

Implementation comes last. By then, I know exactly what to build and can verify the implementation against the design.

Does this guarantee bug-free code? No.

In almost every case there are bugs in a low level. And AI struggles with bug fixing and can get stuck in loops. It's especially true for multiplayer games where AI has a hard time figuring out which calls must be networked and which not.

I still debug a lot of low-level details manually. But the number of bugs drops significantly with proper preparation, and overall, it’s a faster, more controlled workflow.

And when sometimes a feature is generated in one go and comes out bug-free, it feels incredibly satisfying.

How do you keep AI-generated code maintainable?

Below is the real generated class diagram from my pet project. While it can be improved for clarity by reorganizing entities and arrows, that was never the goal, it serves well for verification and as a prompt.

Use all of Unity 6's profiling tools in the smartest and most efficient way (Part 2)

Project Auditor
Project Auditor scans your entire project and provides detailed reports about inefficiencies, such as heavy scripting calls, unused assets, excessive entity counts, and more.

The Project Auditor covers several different areas:
- Performance optimization: It identifies problems that could impact your project’s runtime performance, such as excessive garbage generation, unnecessary object allocations, or expensive function calls.

- Code and asset review: It highlights unused assets, inefficient code patterns, or outdated APIs that can be refactored. This helps reduce build size, improve overall project maintainability, and optimize memory use.

- Diagnostics and best practices: It provides recommendations based on Unity best practices and highlights errors or warnings related to your project setup, such as missing references or suboptimal Player and Quality settings.

- Customizable reports: It organizes the results into categories, making it easy to prioritize optimizations. You can also create custom rules to tailor the analysis to your specific project or needs.

Deep Profiling
I still see a lot of misunderstanding about how deep profiling works. Luckily, the book highlights it once again:

"Enabling Deep Profiling will result in the insertion of Profiler markers at the beginning and end of each function call."

And a very important point following from this:

"However, deep profiling adds a marker to the start and end of every function call, and each marker adds some overhead. This means that a part of your code which has a deep call stack (say MyDeepFunction) will show up as more expensive than places which do all their work inside a single function (MySingleFunction). That means you cannot rely on the relative timing of these two pieces of code – MyDeepFunction might look more expensive than MySingleFunction with deep profiling enabled, but this cost could all be in the extra markers added."

https://unity.com/blog/use-unity-6-profiling-tools-smart-efficient

#profiling #performance #optimization

Use all of Unity 6's profiling tools in the smartest and most efficient way (Part 1)

I have read the new book about profiling so you can dive immediately into what interests you the most.

I had a lot of experience with Unity Profiler before, so I am excited about the new Unity 6 profiling book.
I skimmed it for you to highlight all the new stuff I found interesting and worth special attention.
Feel free to dive deeper into any point by searching for the text in the book:
- With the new Highlights module in Unity 6, it’s easy to determine whether your application is CPU- or GPU-bound on all platforms.
- Locating recurring memory allocations over application lifetime.
- Establish a profiling methodology: The flow chart below illustrates the initial profiling process with the sections following it providing detailed information on each step.
- Common pitfalls for main thread bottleneck
- Common pitfalls for render thread bottlenecks
- Common pitfalls for worker thread bottlenecks
- You can use the Flow Events feature in the Timeline view of the CPU Usage Profiler module to investigate when jobs are scheduled and when their results are expected by the main thread.

- Expensive fragment shaders caused by:
- Branching logic inside shader code
Note: I saw multiple posts that demystify it for modern desktop GPUs, so validate every claim for your particular case

- A general tip to combat device thermal issues over extended play times is to leave a frame idle time of around 35%.

Profile Analyzer tips:
- Drill into user scripts (ignoring Unity Engine API levels) by selecting a Depth level of 4.
After filtering to this level and looking at the Unity Profiler in Timeline mode, you can correlate the call stack depth to make a selection here – Monobehaviour scripts will appear in blue on the fourth level down. This is a quick way to see if your specific logic
and gameplay scripts are taxing by themselves without any other “noise.”
- Filter data in the same way for other areas of the Unity engine, such as animators or engine physics.
- On the right side in the Frame Summary section, you’ll find the highlighted method’s
performance range histogram. Hover over the Max Frame number (the exact frame in which max timing was found) to get a clickable link to view the frame selection in the Unity Profiler. Use this view to analyze other factors that potentially contribute to the
high maximum frame time.

- If you have a widescreen or two monitors available it can be useful to open the Profile Analyzer and the Unity Profiler side by side. This setup enables you to double-click a frame in the Profile Analyzer to automatically select the same frame in the Unity Profiler, from where you can further investigate it using the Timeline or Hierarchy views.

- Common sense, but I’ve never seen it before in any docs and with a concrete
percentage.

DRAM access is typically a power-hungry operation on mobile devices.
Arm’s optimization advice for graphics content on mobile devices says that LPDDR4 memory access costs approximately 100 picojoules per byte.
Reduce the number of memory access operations per frame by:
- Reducing frame rate
- Reducing display resolution where possible
- Using simpler meshes with reduced vertex count and attribute precision
- Using texture compression and mipmapping

Allocation call stacks provide a quick way to discover managed memory allocations in your code.
These will provide the call stack detail you need at less overhead compared to what deep profiling would normally add, and they can be enabled on the fly using the standard Profiler.

Investigating Memory Issues in Unity

I came across a new post about using the Memory Profiler in Unity. It has some helpful tips and a few things I hadn’t heard before, like the command line arguments -debugallocator, -systemallocator, and -log-memory-performance-stats, which might be useful in certain cases.

The author also shares links to native profilers they recommend. Ngl there have only been a few times when I really needed to use a native profiler in a real prod game instead of Unity's built-in one.
For example, when profiling the cold and hot start of our game on Android. Still, it’s something I want to explore further. More real production use cases would help with that.

Have you ever used native profilers because the Unity ones didn’t provide enough info or for any other reason?

https://dev.to/attiliohimeki/investigating-memory-issues-in-unity-55am

#memory #profiler

Unity 3rd Person - Animation Rigging Package for head look

Needed a way to blend skeletal animation with head movement that follows the cursor (just like in Liar's Bar). Found a quick and clean solution in this video using the Animation Rigging package

Don't pay attention to the issues with the rig 💀

Should I leave this cat in my prototype?

https://www.youtube.com/watch?v=q7aF8l_xndE

#animation #rig

A follow-up after one year on that post about improving Unity performance using IL2CPP_USE_SPARSEHASH.

Has anyone here tried using that approach in their own projects? I’d really love to hear if it brought any improvements on your side or if you ran into anything unexpected while experimenting with it.

I already know a couple of teams that gave it a try and saw noticeable performance gains, especially during app startup and dependency resolution. So I’m curious if there are more of you who found it useful or maybe applied it in a different way. Let me know.

You can write a comment or hit the DM.

I made a post with a detailed line-by-line breakdown of the VHS shader I shared earlier. It was pretty helpful to me in the first place to understand and describe in layman's terms what each function does in the shader, in the same manner as I did before with the interactive grass shader in my blog.

I know that four texture samples for such a basic effect are less than optimal, but for the prototype it's okay for now. If you have any other ideas to optimize it, I'd be happy to hear them.

Also, thanks for sharing other great solutions in comments and DMs. Inspired by that, I have already started creating an improved version of my VHS effect and will post an update here once it is ready.

https://gamedev.center/how-to-make-a-retro-vhs-effect-shader-in-unity/

#vhs #vfx #shader #builtin

Debug LMKs

I recommend reading this page because it offers clear, practical guidance on how Android manages low memory and how Unity games are impacted. Understanding these concepts is key for creating stable and efficient apps that perform well across a range of devices. The page provides actionable steps to help developers detect and handle low memory situations, leading to fewer crashes and a better user experience.

I also like advice regarding stuff like IL2CPP metadata, because I rarely see it being mentioned online and how it affects the memory.

https://developer.android.com/games/engines/unity/unity-lmks

#memory #optimization

Android Developers Blog: Transition to using 16 KB page sizes for Android apps and games using Android Studio

Check your Android build and make sure it supports a 16KB page size before November 1, 2025, if you plan to release updates.

https://android-developers.googleblog.com/2025/07/transition-to-16-kb-page-sizes-android-apps-games-android-studio.html

#native

VHS effect breakdown in less than a minute

Following the post about sharing my progress here. While working on my prototype, I wanted to add a VHS-style post-processing effect for a retro, analog vibe.

I explored the asset store and found a good one, but at a pretty high price point, it felt too much for this stage of development.

I also checked several free and open-source implementations on GitHub, but many lacked documentation or even basic instructions on how to integrate them.

And since I prioritize development speed, it turned out building my own was faster than reverse-engineering someone else's code, especially with the help of AI to speed up shader prototyping and testing.

So, I created a custom VHS effect from scratch.

I broke the look down into key components:
🔹 Scanlines – flickering lines to mimic CRT displays
🔹 Color grading – slight desaturation with a soft blue tint
🔹 Color bleed – RGB channel separation (chromatic aberration)
🔹 Noise/static – analog-style grain
🔹 Wobble/distortion – horizontal offset to simulate tape playback

Each of these can be toggled on/off and fine-tuned in real time, and when combined, they recreate the familiar imperfections of VHS playback.

Have you seen any open source VHS effect that you can recommend? Or do you have any suggestions to improve my version?

#postprocess #shader #builtin #vhs

A VHS effect breakdown in less than 1 minute

I built a custom VHS effect from scratch to get that gritty, analog vibe for my prototype about a post‑apocalypse. Cheaper, faster, and fully tailored to my needs.

Want the full shader code and a deeper dive into how it works? Drop a 🔥

#postprocess #shader #builtin #vhs

Batching tamed: reducing batches via UI mask optimization

The post explains how UI masks kill batching and provides an example of how to implement a custom rectangular mask for the Image component that doesn't break a batch.

https://medium.com/my-games-company/batching-tamed-reducing-batches-via-ui-mask-optimization-4d346175140d

#ui #mask

A 1 minute Unity LUT tutorial

https://www.reddit.com/r/Unity3D/s/aGNBIyXuQB

#lut #vfx