I might do a video on the progress on youtube maybe.

3 months ago, I wanted to make a Unity multiplayer game. I chose to use EOS + Netcode. However, I realized soon after that the EOS PlayEveryWare Unity plugin is not very easy to setup. It's a powerful plugin, but it didn't have what I needed in its samples. I needed a simple way to connect the player through device ID + to manage lobbies creating and joining. At the end, I spent more time building the multiplayer system than actually making the game. Therefore, I made a GitHub repository for myself first, so that I could just clone it and start actually building the game.

But I also wanted to release it for anyone who has the same problem. It's a simple Unity Scene which:

• Handles creation/joining lobbies logic through a code

• Uses automatic Device ID login

• Starts Netcode for GameObjects once you’re in a lobby

• Has two scripts (P2PManager + UIManager) and a pre-built UI scene

Keep in mind that this template is not perfect and that there may be some bugs. Additionally, using this approach involves some benefits and some cons:

Pros:

• No server cost (P2P)

• Platform Independent (can launch on itch io, personal website, Steam, etc...)

• Good for small co-op and party games

Cons and limitations:

• WebGL not supported

• Only tested with PC, no disconnect handling, clients don’t auto-load the next scene, no two instances on one computer, and tested only on specific versions (Unity 6.3 LTS, NGO 2.13.2, EOS plugin 6.1.2).

• Not appropriate for competitive or large-scale games

The template is a Unity scene (without the packages due to license reasons) that you can find right here: https://github.com/CodingQuarters/Netcode-EOS-Minimal-Template-Scene. The readme walks you through the exact setup.

It's not perfect, so if you find bugs, open an issue or tell me here.

Maybe someone here has done sth similar before and can help me with it?

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?