And by the way, you can also set up the layout in the virtual player window, which allows you to debug more easily by having access to the console, scene view, and hierarchy.

Sampling vs. Instrumentation Profilers in Unity: When to Use Each for Better Performance

New Blog Post Alert!
It’s been a while since the last post on my website gamedev.center — lately, I’ve been deep into working on my pet project instead of writing. But finally, a new post is up!

I keep seeing Superluminal mentioned more and more—so is it time to take another look? 🤔

In this post, I break down sampling vs. instrumentation profilers, when to use each, and why a hybrid approach gives the best results. Plus, I share real-world profiling strategies that helped optimize Unity projects.

https://gamedev.center/sampling-vs-instrumentation-profilers-in-unity-when-to-use-each-for-better-performance/

#profiling #sampling

Easy Text Effects for Unity

An open-source Unity package for animating TextMeshPro text with customizable effects. Includes ready-to-use samples, real-time previews, and per-vertex animation capabilities.

https://github.com/LeiQiaoZhi/Easy-Text-Effects-for-Unity

#text #vfx

GitHub - ruccho/WaterRW: WaterRW is 2D interactive water system for Unity.

https://github.com/ruccho/WaterRW

#water

Performance checklist provided by Unity in their ECS samples repo covers both regular projects and DOTS.

It gives you a clear plan of what to check after identifying slow parts of your game through profiling. While the list may seem trivial to developers experienced in optimization, it's beneficial to have it formalized and written down somewhere to optimize your optimization workflow. And of course it’s very helpful for less experienced devs.

https://docs.google.com/document/d/1QQZz6xzmWpe6NMdL3t2o7RXmya6UFyl_Xgo3KPfGxzQ/

#performance #profiling

Stencil Debugger for Unity's Universal URP
Stencil Debugger is a utility for visualizing the stencil buffer in Unity URP. This is especially useful for debugging rendering effects that rely on the stencil buffer.

It's been a while since I last debugged a shader, and it was far from trivial—I had to write shader code just to render the debug info into a texture. So this tool is incredibly helpful, as it eliminates the need for custom debug code at least for the stencil buffer.

https://github.com/alexanderameye/stencil-debugger

#stencil #debug

Reveal-By-Progress-Shader-For-Unity: A custom shader for Unity that reveals an object based on a progress value.

This effect is based on an old tutorial by Alan Zucconi. It's great to see a complete implementation that can be easily used for prototyping. Currently, it supports only the Built-in Render Pipeline.

I have seen this revealing effect in a lot of hyper casual games. Moreover, it can be modified for other purposes—for example, cutting off dark vertices entirely to imitate a 3D printing mechanic.

https://github.com/AnhPham/Reveal-By-Progress-Shader-For-Unity

#shader #reveal #builtin

How to Use Dependency Injection with ECS

A new post on my blog.
I’ve seen this question come up quite often in ECS discussions, so I decided to share how I typically integrate Dependency Injection containers with ECS — complete with the simplest working example on GitHub. To me, such a setup always feels more convenient and more efficient. But it doesn't mean it is the only or the right way to work with it. If you prefer the Entities approach, or a manual setup of dependencies via the inspector in Morpeh, then that is also okay.

https://gamedev.center/how-to-use-dependency-injection-with-ecs-for-scalable-game-development/

Repo: https://github.com/AlexMerzlikin/ECS-DI-Sample

#ecs #di

Post for those who struggle with motivation to finish their projects.

I came across a study that shows writing down your goals and sharing them with a friend can really help you achieve more (kinda obvious, but proves this point once again). Here are the details:

Participants: 267 people from different backgrounds.
Groups:
Group 1: Just thought about their goals.
Group 2: Wrote their goals down.
Group 3: Wrote goals + made action plans.
Group 4: Wrote goals + action plans + told a friend.
Group 5: Wrote goals + action plans + sent weekly updates to a friend.
Success Rates:
Group 1 (Unwritten Goals): 43% success rate.
Group 2 (Written Goals): 64% success rate.
Group 3 (Written Goals + Action Plans): 68% success rate.
Group 4 (Written Goals + Action Plans + Shared with a Friend): 70% success rate.
Group 5 (Written Goals + Action Plans + Weekly Progress Reports to a Friend): 76% success rate.

The study shows that each step—writing down goals, making action plans, and sharing progress with a friend—increases the likelihood of achieving those goals.

Download the report: https://scholar.dominican.edu/cgi/viewcontent.cgi?article=1002&context=psychology-faculty-conference-presentations

Conclusions:
1. The positive effect of accountability was supported: those who sent weekly
progress reports to their friend accomplished significantly more than those who
had unwritten goals, wrote their goals, formulated action commitments or sent
those action commitments to a friend.
2. There was support for the role of public commitment: those who sent their
commitments to a friend accomplished significantly more than those who wrote
action commitments or did not write their goals.
3. The positive effect of written goals was supported: Those who wrote their goals
accomplished significantly more than those who did not write their goals

I’ve been creating TODO lists and full-blown project boards with a backlog, milestones, and sprints using various tools for quite a while. Right now, I’ve settled on Notion and use various templates there for each new prototype. It hasn't helped me finish many recent games, though.

So with my latest prototype, I’m now trying the “Written Goals + Action Plans + Weekly Progress Reports to a Friend” method to see if it helps me reach a first playable prototype more successfully. I'm curious to see how it goes.

If you're interested in hearing more about my progress and how I'm applying this to my game, let me know by reacting to this post.

🔥 – Post progress updates here in this channel
💯 – Post progress updates, but in another channel; leave this one only for references to interesting posts
👎 – Don’t post updates anywhere 💀

Quick and Dirty PlayerPrefs Persistence with VContainer

Lately, I’ve been deep into prototyping, and I’m always on the lookout for quick patterns that speed up the boilerplate. This blog post by Vigrid shares a neat way to persist data using PlayerPrefs and VContainer with minimal setup.

While the original example uses VContainer, the pattern is container-agnostic—you can adapt it easily to any DI framework you're using.

https://vigrid.gg/blog/2025/05/quick-and-dirty-playerprefs-persistence-with-vcontainer/

#save

Is your AI safe? Threat analysis of MCP (Model Context Protocol)

Cyber Ark finished digging into the Model Context Protocol (MCP) security model and found some nasty vulnerabilities that could seriously mess with devs using AI coding tools.

Quick Context: MCP is what lets tools like Claude Desktop and Cursor connect to external services and your local files. Basically, it's an API layer for AI apps.

The Problems:
- Malicious Tool Registration: Attackers can publish “helpful” tools that actually steal your code or secrets
- Server Chaining: Legit servers can quietly route requests to malicious ones
- Hidden Prompt Injection: Servers can embed invisible instructions that hijack the AI
- Weak Auth: Most MCP servers don’t really check who’s calling them

Why It Matters:
If you’re using AI coding assistants with MCP:
- Your codebase could be exfiltrated
- API keys in env vars are exposed
- Custom integrations might be backdoored

Quick Fixes:
- Stick to verified MCP servers
- Check the official registry
- Read server code before installing
- Don’t keep secrets in env vars if using MCP
- Use clients that require approval before calling tools

This is what happens when we rush to plug AI into everything without thinking about security. MCP’s flexibility is a double-edged sword.

I have personally been trying various MCPs for quite a while since they started to become popular. While I was concerned about security, not gonna lie, I didn't put enough effort into reviewing every MCP server myself (it is open source and totally safe, right? 💀), as I was focused on adding new features to multiple prototypes I've been working on lately and was more concerned about the tool's efficiency and how it improves the workflow rather than its security. What's more, I see some companies also pushing for MCP adoption, and I hope they pay more attention to security than I did with my prototypes.

Do you use any MCP for game dev and find it helpful?

Worth a look if you’re building or integrating with MCP

https://www.cyberark.com/resources/threat-research-blog/is-your-ai-safe-threat-analysis-of-mcp-model-context-protocol

#ai #mcp

Memory optimization guide in Unity 6

While this guide has some decent profiling and memory optimization tips, I was puzzled by the claim that Unity GC can compact managed memory blocks.

I even went to recheck the official documentation to verify that Unity still uses Boehm GC for both Mono and IL2CPP noscripting backends, and it is a non-compacting GC.

So I discussed this topic with ChatGPT, and it gave me the same claim about the compacting algorithm until I referenced official documentation in the chat. It's sad that a guide from such a well-known website with various valid tips is still affected by AI hallucinations and false claims (btw, if what the post claims regarding the compaction step is valid, then share links to the GC implementation or any docs, I would love to update my knowledge).

Apart from that AI slop, the tips are valid and can be used to optimize your runtime memory.

If you like reviews calling out misleading info, drop a 🔥

If you think I should skip posting stuff like this, hit 🗿

https://theknightsofu.com/memory-optimization-guide-in-unity-6/

#gc

So your code is slow: General C# and DOTS-specific performance tips – Technical Articles – Unity Discussions

A list of questions to ask yourself when your code is slow.
Don't forget the obligatory "profile first" to avoid optimizing what doesn't matter. I once saw a stellar 100x optimization, the author didn’t mention the function took 0.001 ms to begin with and was invoked once an hour though.
So this post also mentions how domain knowledge is important in optimization.

https://discussions.unity.com/t/so-your-code-is-slow-general-c-and-dots-specific-performance-tips/1654372

#optimization #dots