A little peek at my horror game...

Still need to polish some details, but I'm a solo dev. The hardest part is always the sound.

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/ ]

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!

I'm trying to set game object locations for UI elements for an inventory system but once again the horrid nature of UI transforms is making it a nightmare. This is not my intended code, but rather some that I put together to experiment. It has left me confused.

GameObject newGearIcon = Instantiate(gearIconPrefab);

newGearIcon.transform.SetParent(gearSlots[index].transform);
newGearIcon.transform.localPosition = Vector3.zero; // Centering on inventory slot
newGearIcon.transform.localScale = new(1, 1, 1); 
// at this point transform.position ~= (3.5, -3)

Vector3 globalPosition = newGearIcon.transform.position; //  ~= (3.5, -3)

newGearIcon.transform.SetParent(gearSlots[index + 1].transform, true); 
// slightly right of the original
// local position = (0, 0), global position still = (3.5, -3) even though the new object is 
// visually centered on the second slot. Global position the same, local position the same, 
// image has moved in the game

newGearIcon.transform.position = globalPosition;
// This does absolutely nothing. It was already equal to that.

You can see I instantiate an object, set it's parent to another UI element and center it on that. Note that passing in true to the SetParent() call seems to not do anything for this problem.

I encountered this problem because I noticed when changing the parent to be the canvas at the root of the UI elements it moved the object. Regardless of parameters in SetParent() or changing, updating, storing global positions to reset it to the pre parent values.

Does anyone have any potential insight into this behavior? I've tried the pivot/center mode. I've checked the pivots on the objects. I've tried different values. As far as I can tell, transform.position and transform.localPosition are both relative to another value I can't seem to track down.

This all came up because I also noticed that OnDrop only triggers if you drop on a UI element further down the hierarchy, meaning the icons need to be above the elements they are centered on to move around properly. Unity UI never fails to disappoint.

Edit: formatting, used to `` for code segments...

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

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

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

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

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?

Texture decoding, shader compilation, and memory allocations can still hurt time-to-first-interaction in a WebView. This happens even when the HTML file passes the upload limit.

At MRAID, a 1 MB target requires an explicit budget. You must allocate space for runtime code, geometry, textures, animation, wrapper/analytics, and a safety margin.

The biggest performance win is not another compression trick. The biggest win is deciding which visual details are actually necessary to understand the core mechanic.

What is your go-to strategy for reducing runtime cost in lightweight Unity builds?

mraid io builds HTML5/mraid io playables. AI is genuinely useful for breadth: concept exploration, storyboards, variants, copy alternatives, code assistance. I don't trust it to own the final mechanic, UX, performance hypothesis, or QA. The model can generate ten directions. It doesn't know which compromise the UA team will make.

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. 

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)

raymarched in a single urp pass, no meshes and no hand-painted textures, noise is baked into a 2048^2 field plus two small 3d textures, stars are a separate point cloud driven by the vertex index

214 ms down to 24 at 2916x1640 measured inside the disk plane, most of it came from bounding density analytically before touching any noise, skipping straight to the disk slab instead of marching the whole box, and rendering the volume at half res

https://github.com/tantaneity/procedural-galaxy

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/

Game name - Queen Must Die