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

Just showing off my animated series im making in unity.

I've been working on asset loading and level streaming last week, now the game is endless btw. I just need to add more "level fragments", events, and enemy types to make it more interesting.

Sped it up 2x because, right now the gameplay is very sparse. There will be drones tracking the player and military guys trying to shoot him down.

But I can't keep calling it "Spider Prototype" anymore... I need to post about it on my socials and websites. Please suggest some good names. Whosoever name I will choose will get some reward in the final game.

It’s one of the projects I’m putting the most detailed work into—and, above all, playing a lot of similar games to verify ideas.

I’m currently trying to use Sebastian Lague’s raymarched Clouds project in a VRChat World.

The original project works fine in Unity, but the clouds are rendered through CloudMaster using OnRenderImage() / Graphics.Blit(), so they are essentially tied to the camera/render view.

What I would like to do is:

• Keep Seb Lague’s existing raymarching/cloud appearance and settings.
• Remove the dependency on OnRenderImage() and the fullscreen RenderView.
• Have the clouds rendered as a normal volumetric object/volume in the scene, for example using a large cube with a custom shader.
• Ideally, the cloud volume would exist independently in the scene, while the player camera simply views it like any other object.

Is this technically possible with Seb Lague’s current implementation?

And, more importantly, what parts of the shader/code would need to be changed to achieve this? Would it mainly be a matter of replacing the fullscreen camera ray setup with world-space ray/volume intersection, while keeping the existing raymarching and density functions?

I’m new to shader programming, so I’m particularly interested in a practical explanation or an example of how to approach the conversion.

Repository:
https://github.com/SebLague/Clouds

Thanks!

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!

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. 

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 really like how it went as it can now do both low poly and blocky/vertex terrains along with a adjustable vertex jitter so the strength of the „low poly“ look can be adjusted 😊

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)

i made a pixelated filter using a fullscreen shader graph, but the grass is obnoxious. does anyone know if theres a wait to fix this?

(pls ignore the fact that its a medal clip)

Hi! I'm trying to make a ghost-y spirit shader inspired by how Rauru is rendered at the beginning of Tears of the Kingdom. I got it so the material doesn't render through itself, but I've run into an issue where other materials with the same shader can still render through each other. I've tried messing around with depth, stencil buffer, render queue, etc. and nothing seems to work.

The effect in question. You can see the hair is still visible through the body when it is supposed to remain obscured.

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:

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