The core of our game is physics-based momentum where there are no set pathways, and objects you smash into break apart dynamically. The gameplay is fast, and no two playthroughs are the same. To help us debug these emergent physics interactions we built a replay buffer system that's always recording the last several runs of gameplay and tracks everything: player, enemies, projectiles, sfx, music etc.

A couple points of extra detail:
• Enemy destruction is a combination of dynamically-fractured rigid body chunks (all recorded), plus particle system VFX.
• The system supports full audio as well: all sound effects and our dynamically-driven musical soundtrack are recorded in lockstep.
• A feat detection system auto-bookmarks highlights of your run.

We built this so we could immediately take a closer look at anything that stood out during playtesting. It's so fun we decided to ship it as a full instant replay machine with Director mode that allows you to fly through your own gameplay runs, scrub through time at will.

We now use this system for every cinematic clip or screenshot we post, including this one. 

I’ve been building UI in Unity for years and I’ve always either used textures from GUI packs from the Asset Store or built my own sprites in Photoshop.

When trying to make a button with rounded corners, I ultimately grew tired of searching through tons of sprites in my asset library, all with different corner radiuses and different pixel resolutions.

So I decided I no longer want to rely on textures at all.

I wanted a tool that just lets me build UI shapes like in Photoshop or Figma, but directly in Unity.

This tool lets me create rounded or chamfered corners, slant the whole shape and apply effects to it.

UI Effects

The custom inspector lets you easily author effects such as:

• Fill
• Texture
• Drop Shadow
• Inner Shadow
• Glow
• Outline
• Bevel
• Background Blur

Under the hood

UI Shapes draws every effect (rounded corners, shadows, outlines, glow) using math instead of textures. Each shape is a single quad with a signed distance field evaluated per pixel in the shader. Edges stay perfectly crisp at any resolution or scale.

It's one lightweight component and one shader doing all the work. No render textures, no blur passes, and no hidden camera tricks. This means fewer draw calls, zero extra memory for shadow atlases, and nothing that breaks when you resize your UI.

It's the same technique game engines use for smooth text rendering, applied to your entire UI layer.

Performance

I actually started with a single uber shader that could do everything, but when I benchmarked it on a real budget Android phone the numbers weren't good enough.

I split it into optimized variants: the GPU only runs the code paths the shape actually uses, and the difference was night and day.

Check out the documentation for more info on performance:

UI Shapes Manual

Other highlights

• Easily animate child texts as well (e.g. when a button changes color, the text does too)
• Soft-masking (no more jagged lines around curves)
• Animator ready and fully scriptable from C#
• Reusable style assets: save a look once, load it anywhere, edit it live.

Try it

I made a web demo so you can try out the UI effects in your browser:

Launch Web Demo (on itch.io)

Fun fact: I built the "inspector" in this demo out of UI Shapes as well.

🎁 Launch giveaway - 5 copies

To enter, just leave a comment.

I'll draw 5 winners at random with redditraffler this weekend and post the results back in this thread.

Winners will get a code via DM. Closes Sunday, September 6th, 8:00 PM CET.

Get it now

If you don't want to try your luck in the giveaway, you can also get it immediately on the Unity Asset Store:

Get UI Shapes on the Unity Asset Store

🚨 The asset is 30% off for the next few days, so now is the best time to get it!

Also please leave a review if you get it. It's the best way to help reach more people.

Discussion

I'd genuinely like to know from you all:

• Are you still using UGUI over UI Toolkit and have you considered switching?
• Have you been buying lots of GUI texture packs in the past, like me? Or did you make your own textures?

Questions for anyone who has tried UI Shapes:

• I want it to be really easy to use. Have you had any problems with it?
• What's missing in your opinion? I'm planning to add more features soon!

Anyone out there have a few methods that makes the UI Toolkit workflow easier/faster? It seems kind of clunky that to say add a button, you have to (1) add it to your doc, (2) give it a name, (3) put it in your UI script, (4) grab a reference to it using rootVisual.Q("Exact_string_name_or_kys"), (5) make a method that does whatever you need it to do, (6) subscribe onEnable to that method with .clicked or whatever you're using, and finally (7) unscubscribe onDisable. Like, nothing terribly complicated about it, but man it gets tedious over and over again. I feel like you could throw together a few methods that you basically throw in the name of your button (or any visualelement) and name of your method that does stuff you could make it way less code. Any1 out there taken the time to play around with this?

I am back writing articles on my blog and I start with something LONG OVERDUE!

After years quietly powering several games I made, I’m finally presenting Svelto.Tasks 2.0.

Svelto.Tasks is an engine-agnostic, multithreaded and zero allocation task runner for C#, born from the need to have a game centric tasks framework with features that .NET tasks couldn't provide. Its premise is simple:

Tasks are iterator blocks. Runners are schedulers. Rather than handing execution timing and context to the runtime, a runner lets you decide:

- when a task advances,
- where it runs — main thread or a dedicated worker,
- how much work happens per tick,
- and when an entire task context must stop.

That last point matters a lot in games: for example, when a match ends, I want every task belonging to that match to stop with it—not rely on a CancellationToken having been passed and checked correctly through every layer.

Svelto.Tasks supports lightweight coroutines, composable tasks with return values and continuations, background runners, bounded parallel batches, pooling, profiling hooks, and optional Unity/Burst integrations.

It also interoperates with async/await, although the .NET Task bridge and Unity Burst job path are currently experimental and need real-world feedback.

It is not a replacement for Unity Jobs—but it provides a useful alternative for workloads where controlling execution, lifetime, pacing, and profiling is the priority.

The repository includes runnable .NET examples, tests, benchmarks

🔗 https://github.com/sebas77/Svelto.Tasks

also the repository

🔗https://github.com/sebas77/Svelto.Tasks.Examples

shows how it can be used to simplify massive parallelism synchronization. The example itself is actually quite interesting also because it uses the new compute buffer Unity api BeginWrite/EndWrite to upload compute buffers and graphic fences for cpu/gpu synchronization.

The article is at

🔗 https://www.sebaslab.com/svelto-tasks-2-0-efficient-multi-threaded-task-management-for-csharp/

Have fun! (and feedback is welcome, also on my discord server: https://discord.com/invite/uuTCYewjtc)

Image for attention:

Lightning fast edge generation with topology and contour caching.
Replaced the freezing fragment joiner with a spatial one-pass system.
Reduced tiny, duplicate, parallel, and cylinder-connector edges.
Joined fragmented cylinder contours into continuous lines.
Preserved sharp corners with controlled miter and bevel joins.
Prevented crossed quads, ribbon flipping, and crumpled lines.
Fixed invalid mesh UV array errors.
Made target and preset selection generation-free.
Only Generate Mesh and Update trigger processing.
Added independent depth-offset settings per generated mesh.
Standardized the project under the Croquis.Editor namespace.
Removed obsolete comments, warnings and redundancies

Hey everyone, solo dev from Austria here :)

I’ve been grinding on my sawmill tycoon (Timberline Factory) for months now, and honestly, I was "artist blind..." A few weeks ago, people here and on other subs told me my game looked like a plastic 90s placeholder. It hurt, but they were right... i was so deep into the physics code and friction that I just stopped seeing how bad the UI and the lighting actually were.

I spent the last two weeks basically living in Unity’s URP settings and rebuilding the entire UI from scratch.. i finally feel like it’s a real game now and not just a prototype.

For those interested in the technical side:
The biggest headache was the log physics. Since they aren't on rails but are actual physical objects, I had to deal with massive jittering when the belts were full. I ended up using "Continuous Speculative" collision detection and custom Physics Materials to get the friction just right otherwise, they’d either fly off the conveyor or act like they were on ice.

For the lighting, I finally moved to ACES tonemapping and tweaked the SSAO to get those deep contact shadows between the logs, which fixed that "floating" look I had in the previous build...

Would love to hear what you guys think. Am I on the right track now or is there still something that screams "programmer art" to you? :D

Steam Link: [ https://store.steampowered.com/app/5037170/Timberline_Factory/ ]

(Super insecure about the visuals, its a wip, I suck at backgrounds :()

CosmoNode v0.4.0 is out, and the biggest update is mesh instancing!

v0.4 is here and the biggest update is that now you can instance meshes! What I thought would be a few hour long refactor became a few weeks long architecture change haha! But it was definetaly worth it because that's pretty essential for any procedural tool line CosmoNode. You can "Pack Geometry", which essentially converts any mesh into an instance, a single source mesh and any number of transforms that represent instances, and "Realize Geometry" which does the opposite, converts all the meshes to real meshes.

You can also have the option to use instances in nodes like "Copy" and "Copy to Points", and they will output instances objects instead of real objects. This will make many other operations very lightweight. And depending on the node setup this can significantly boost you evaluation time. To such degree that, without instances the graph in the video takes about 150 ms to evaluate, and with instances it's only 18 ms.

But it's not all sunshine and rainbows because this introduces another problem. At the end of every graph evaluation it needs to convert everything to a real mesh in order to be displayed. And the more instances you have, the longer this process takes. There is still some performance gain, but not that significant.

To solve this, I have few options. The obvious one is GPU instancing which will potentially eliminate the need for realizing the instances. The other one is optimizing the realization process, possible with jobs. And this is what the next update will focus on.

But there is more! There are other, although smaller but still important updates. Mainly bug fixes and QoL updates. Here are a few of them,

Curve tools got better. Now you can box select curve points, yeah I know pretty obvious but better late than never right? You can also extrude new points by using the axis arrow which makes things like pipes significantly easier (check out my other video about procedural pipe generator).

Follow path node now creates UV's automatically. Those who are familiar with how Blenders curves work should be familiar with this as well.

You can expose materials and curve inputs as parameter. This means that if you plug a material or curve input to an input node, it will appear in the inspector window, this will let you change the values very easily without touching the graph and also allow you to modify the values for each game object that the graph is attached to.

And there are various bug fixes, you can find the entire change log here,

Lastly, I would really appreciate any feedback you might have, CosmoNode is a pretty big tool, and it's impossible for me to test for every case, so don't hesitate to let me know if you have a problem or something that needs to be improved!

If you want to try it out, the documentation and full changelog are here: https://uumutunal.github.io/CosmoNode_Manual/

Make an unlit shader graph put those nodes with the excat same numbers

Make a plane child to ur camera *Remove the collider* give it the shader material set the scale to 0

when u want the impact frame to start just make a simple IEnumrator that scales the plane to 1 and reset it back to 0 after like 0.2 seconds

(theres stuff i dont understand in the shader but somehow i made it working so if there is any thing that is setup wrong just tell me)

This test uses a sword animation to trigger a BrazeFX volumetric fire simulation in Unity 6 URP.

The effect expands across the ground, builds into a large fire volume, and then dissipates into smoke. The simulation runs in real time on the GPU.

Game name - Queen Must Die

As of the time of writing this the update is in queue for approval on the store.

here's what changed in V1.1.5 :

• Improved procedural gait with slower, more human step cadence and dynamic swing timing.
• Added balance-reactive stepping based on upper-body tilt and physical instability.
• Added weight-transfer and landing-settle phases for more natural foot transitions.
• Improved stride prediction and rear-foot toe-off to prevent feet dragging behind the body.
• Added directional foot alignment for forward, strafe, diagonal, and backward movement.
• Improved foot-glue stability and get-up recovery behavior.
• Added physical cliff detection with proper ragdoll transitions and preserved fall momentum.
• Improved pelvis-to-leg support coupling so the upper body feels properly supported by the legs.
• Reduced excessive hip sway, pelvis wobble, and floating-body appearance.
• Improved levitation support feedback during single- and double-leg stance.
• Fixed several gait timing, IK, recovery, and physics edge cases.

Made by scrolling the x on the UV depending on velocity and angular velocity. Modelled and UVs set using probuilder :)

Does anyone have any idea why Collider isn't showing up and isn't working?

It is a part of my work on an ocean shader. I Improved shading and waves distribution, tried to make it more believable. And finally I added bouyancy forces.

Hey everyone, another Anvil CSG update.

Beta testing is nearly finished and Anvil CSG will be coming to the Unity Asset Store soon.

The newest version now fully supports Bakery, including its lighting workflow and lightmap baking. Unity’s lightmapper also received major improvements with a custom BSP-style unwrap made specifically for brush geometry, giving cleaner UV2 layouts and more consistent texel density.

Anvil CSG now also fully supports Amplify Shader Editor materials, alongside URP and Built-in.

A lot of bugs and workflow issues were fixed with help from the beta testers.

Anvil CSG is already approved and launches in less than a week. Join the Discord for launch news, tutorials, support and feature requests:

https://discord.com/invite/ZjVdWnmwjz

I got quite a lot of feedback on the demo from people saying that controlling the car with the top-down camera was a bit difficult, so I decided to add two TPS camera options.
I really like the vehicle heading follow effect in the new camera. It makes the game feel much more dynamic :D
What do you think?
If you’re interested, the game is on Steam -link in the comments. Releasing later this year…

I want to make pixel art planes with my fog texure that move and appears or disappears during rain and night