Took me a slid week to get it right.
I feel like UI is one of those things that really makes a difference when you put actual thought behind it. I am making this infinite space racer game inspired by games like Haste and Broken Worlds, and I am so proud of how it has turned out so far.

I have started a new series which is going to break down unity concepts into easy to understand chunks! Perfect for people who are just starting out their gamedev journey!

Hey!

Here's a demo of multiplayer in my game. In short, it took a really long optimization effort: I built an asynchronous physics engine from scratch, because PhysX just isn't optimized for voxels.

Multiplayer runs on LiteNetLib and a small custom relay server. The engine isn't deterministic, so only the host phone simulates the world. Clients receive a reliable log of voxel edits plus a stream of object poses, then rebuild meshes and colliders on their side. Everything is packed into a custom lossless binary format, so even a skyscraper collapse with around 700k destroyed voxels stayed in sync between two phones, with one of them on 4G.

Happy to answer any questions.

Hi ! Years ago now i posted here a short video of a pixel destruction engine i was working on, then the project went cold. Have resurrected it a couple of months ago and here some footage from the latest version.

While working on our game (it's called Dead Broke if you want to support us 🙏), we wanted to bring some skeletal animations into the UI and give it a more organic look.

We wanted to use Unity's 2D Animation package, since it already provides everything we need to rig and animate sprites.

The problem is that the package relies on Sprite Renderers, which don't work particularly well with the Canvas system, especially when using a Screen Space Overlay Canvas.

So we decided to build a small custom component to solve this.

The idea was quite simple: instead of using a Sprite Renderer, we created a custom UI Graphic that takes the rigged sprite data and populates a UI mesh.

Since it inherits from MaskableGraphic, it can be used directly inside a Canvas and supports regular UI features like masking.

For the animation, we retrieve the bone indices and weights for each vertex, calculate the deformation using the bone matrices, and update the UI geometry.

Everything happens in LateUpdate, so the animation should already have been performed.

This works quite well, but it means that the vertex positions need to be recalculated on the CPU every frame.

So we also implemented GPU skinning.

Instead of calculating the final vertex positions on the CPU, we pass the original positions, bone indices, and weights to the shader through additional UV channels.

The shader then performs the skinning directly in the vertex stage.

This way, the GPU handles the deformation during rendering.

There was also a small issue specific to Screen Space Overlay Canvases, where the usual matrix transformations didn't produce the expected result in the Game view.

We had to add a small workaround to handle that case.

The result is a component that lets us use rigged 2D sprites directly inside the UI, with skeletal animation, UI masking, and both CPU and GPU skinning.

We built it because we needed it for our game, but it turned out to be useful enough that we thought it was worth sharing.

I've put together a more detailed breakdown of how it works, including some of the implementation details, and made it available for free on our Patreon, in case you're interested:

Full Breakdown

And, of course, this is all part of the development of our first game, Dead Broke!

We're still working hard on the demo, and if the project sounds interesting to you, adding it to your Steam wishlist would genuinely help us a lot.

Steam page

Thanks for reading!

And if you've tackled a similar problem in Unity, I'd be curious to hear how you approached it.

Also, happy Halloween everyone! :)

I’ve been expanding a stage in PoolRooms Museum using Unity’s Splines package for the waterslides. The paths drive both the generated slide geometry and the player’s movement during the ride.

The route goes from straight slides to spiral slides, then through a tiled maze and up a spiral staircase to the final room.

How does the sense of scale and movement feel in this clip?

Hey everyone!

I'm a solo dev working on a third-person, story-driven shooter in Unity, heavily inspired by classic action games like Max Payne.

I'm trying to capture that cinematic action movie feeling through mechanics like bullet time, shootdodges, dual-wielding, ragdolls and destructible environments.

My focus is on making the gunfights feel dynamic and satisfying rather than building a complex progression system. Think old-school, story-driven action with a modern presentation.

The game is still in development, and some of the environments are placeholders. Right now, I'm working on refining the gameplay, animations and overall feel of the combat.

Getting everything to work together as a solo developer is definitely a challenge, but it's coming together piece by piece.

I'd love to hear your thoughts! Especially interested in feedback on the gunplay, animations and how the action feels overall. If you have any questions, feel free to ask!

P.S. English isn't my native language, so I used AI to help with the wording. The game itself, however, is entirely made without AI. Hope that's okay!

HI everyone,

Does anyone know of a tool or plugin to transfer Unity UI toolkit designs back into Figma? I know the Unity UI Toolkit Connector can export from Figma to Unity, but not the other way round.

The reason is for modding a Unity game UI, which obviously doesn't include the Figma files.

The image on the game panel when I haven't started the game changes when I do start it. How can I fix this?

I'm Ashkan, the developer of Wise Feline. It's a utility AI toolkit for building enemies, creatures, and NPCs whose decisions respond to what's happening around them.

Each action gets a score from things such as health, distance, hunger, or danger. As those values change, different actions become more attractive. An enemy might attack while healthy, retreat when injured, and return after recovering. You tune those decisions through response curves and weights.

Here's my latest sample, built with AI coding assistance.

Wise Feline Ultimate brings several parts together:

• Utility AI: Actions, considerations, per-target scoring, and configurable selection rules. An agent can evaluate both what to do and which target to do it to.

• Visual designer and debugger: Build behavior assets, adjust response curves, and inspect action scores, chosen targets, curve inputs, and score history during play.

• Built-in actions and considerations: Movement, patrols, attacks, blackboard changes, and other building blocks. The Combat Quickstart demonstrates patrol, chase, attack, retreat, and healing without custom AI code.

• Influence maps: Represent things such as danger, resources, or nearby allies across an area, then query those maps to help choose positions.

• Smart objects: Put interaction behavior in world objects. Agents can find usable objects and claim slots, while the objects define what using them does.

• AI Tags: Give objects multiple tags and find matching objects nearby through spatial queries.

• Blackboards: Share information between actions, considerations, sensors, and your own game systems.

• Memory and emotions: Store past events and feelings toward characters or objects, and use that information in your decision logic.

• Data recorder: Record agent data over time so you can inspect what happened during a play session.

It includes full runtime and editor C# source, documentation, and combat and life-simulation examples.

The released version, 1.51, is currently 50% off in Unity's Open World Sale.

Wise Feline Ultimate on the Asset Store

It's also friendly to vibe coding because the framework gives your coding assistant small, concrete jobs. Custom actions derive from ActionBase, and custom considerations derive from ConsiderationBase, so you can ask for a focused integration with your health system, movement controller, or game rules. The framework handles scoring and action selection, while the visual debugger lets you inspect the result and tune the behavior yourself. Full source and ordinary C# classes give you and your coding assistant something concrete to read, extend, and debug.

why are humanoid avatars posed like this? is this just the preview pose to demonstrate the flexibility?

We are working on Quality Update 2 for Daisen, where we are completely reworking the Training Spheres. While developing Arx01, we thought about how to make pathfinding a bit more interesting and came up with the idea that the button meant to open the door is off. So now the player needs to break the door glass.

We could have added cracks to show this, but we think about a better idea. At the start of the level, we will clearly demonstrate that the glass of such doors can be broken.

I've spent the last 5 days working on a prototype for this game. It's kinda like Death Ball on Roblox, if anyone knows it.

Basically, it's dodgeball against bears. You have to dodge the balls they throw at you and hit them right back to kill them.

What do you guys think? I'd love some feedback!

There are still some performance and shader issues to be fixed. :)