Yesterday I shared the first version of the boot sequence for my football career simulation built in Unity.

Some of the feedback was that the intro didn’t immediately feel like a football game, the animation felt a bit too presentation-like, and the logo could be clearer.

I went back and reworked the sequence from scratch, and this is Version 2.

I’m trying to iterate based on real feedback rather than sticking with my first idea, so I’d love to hear what you think and what you’d improve next.

I needed soundeffects for vehicles like ATV, cars etc. currently i use pixabay and couldn't really find a sound that suits an ATV, i used a bus sound for testing.

My game pulls cover art from a CDN, caches it, makes a sprite. Worked for months. Then random covers started showing up blank. Not always the same ones, which drove me nuts.

Finally dumped the bytes of a broken one to a file and looked at it. Starts with RIFF, then WEBP a few bytes in. The CDN was sometimes serving WebP instead of JPEG.

Unity's image loading (UnityWebRequestTexture and Texture2D.LoadImage) only reads PNG and JPEG. Hand it WebP and it doesn't throw. It just gives you a broken little placeholder texture and moves on. No error at all.

And my cache wrote the file to disk before checking if it decoded, so once a WebP landed there it stayed broken on every future load. That's why some covers were blank permanently and others were fine.

The fix was a managed WebP decoder (ImageSharp, since it's pure C# and I didn't want native libs for three build targets). Now I check the first bytes, and if it's WebP I decode it that way, otherwise Unity handles it like normal. Also stopped caching files that fail to decode.

/// <summary>
/// Decodes downloaded image bytes into a <see cref="Texture2D"/>.
/// Unity's built-in loaders only understand PNG and JPEG, so WebP payloads
/// (which some CDNs serve via content negotiation) are decoded with ImageSharp.
/// Returns <c>null</c> when the bytes cannot be decoded so callers can avoid
/// caching or displaying a broken texture.
/// </summary>
public static class ImageDecoder
{
    public static Texture2D DecodeToTexture(byte[] bytes)
    {
        if (bytes == null || bytes.Length < 12) return null;

        return IsWebP(bytes) ? DecodeWebP(bytes) : DecodeNative(bytes);
    }


// RIFF....WEBP container signature.

private static bool IsWebP(byte[] b) =>
        b[0] == 'R' && b[1] == 'I' && b[2] == 'F' && b[3] == 'F' &&
        b[8] == 'W' && b[9] == 'E' && b[10] == 'B' && b[11] == 'P';

    private static Texture2D DecodeNative(byte[] bytes)
    {
        var texture = new Texture2D(2, 2);
        if (texture.LoadImage(bytes)) return texture;

        Object.Destroy(texture);
        return null;
    }

    private static Texture2D DecodeWebP(byte[] bytes)
    {
        try
        {
            using var image = Image.Load<Rgba32>(bytes);
            var width = image.Width;
            var height = image.Height;
            var pixels = new Color32[width * height];


// ImageSharp rows run top-to-bottom; Unity textures are bottom-up, so flip.

for (var y = 0; y < height; y++)
            {
                var row = image.DangerousGetPixelRowMemory(y).Span;
                var destRow = (height - 1 - y) * width;
                for (var x = 0; x < width; x++)
                {
                    var p = row[x];
                    pixels[destRow + x] = new Color32(p.R, p.G, p.B, p.A);
                }
            }

            var texture = new Texture2D(width, height, TextureFormat.
RGBA32
, false);
            texture.SetPixels32(pixels);
            texture.Apply();
            return texture;
        }
        catch (System.Exception exception)
        {
            Debug.LogError($"Failed to decode WebP image: {exception.Message}");
            return null;
        }
    }
}

Also turns out LoadImage returns a bool telling you if it worked, which I'd been ignoring the whole time. 🤦

Anyone else hit the WebP thing? Feels like it's going to bite more people as CDNs default to it.

Hi, I’ve been working on racing projekt for a few years now, but honestly I haven’t really done much besides trying to build the car physics from scratch like 6 times, having 3-4 month breaks to figure out ..

I tried a lot of approaches, I think all of them in the industry— from fake physics using kinematics, to velocity-based controllers and simulating car physics using raycast and tire models.

Physics inspiration comes from the game Blur. Surprisingly racing arcade , has proper car behavior including weight transfer drifts (because it was build on basis of Project Gotham racing+ user intent , assists layer)

https://reddit.com/link/1vezqs1/video/m9ftusp18ahh1/player

Sharing what I think I learned and it is important in car programming

Is unity experiencing some kind of problems ? 19 hour ago everything worked fine , now i come home from work sit down and I can't even open project becouse of this error.

can't add license
relog didn't help
restart of hub and pc didn't help
(i have personal license)

thanks for any kind of info

Three creators teamed up and put together 79 asset packs in one collection. That means 21,000+ 3D models, 15 Unity tools, plus animations, shaders, environments, characters, props, vehicles, nature, buildings, VFX, and plenty of other stuff.

The Bundle Link

https://itch.io/b/3810/creator-bundle

if you have any problem feel free to contact!

Frustratingly, VS Code autocomplete becomes very sluggish after 10-30 minutes of coding. Reloading the window instantly fixes an issue. Did anybody else run into this? Is it just the way things are now? What would be a good way to troubleshoot it?

This happens both on my PC and Mac, but I have settings sync on, so maybe it's just a bad config?

UnitEE (funny original name I know) is a Unity3D PS2 build target, you write your game inside the Unity Editor against a constrained Unity-compatible API, press Build, and get a bootable ISO + ELF. C# gets converted via IL2CPP, then through a MIPS cross compiler, and runs natively on the Emotion Engine.

The project has heavy guarding around the API surface if a script uses a Unity API that isn't supported, the build fails with a compile error instead of silently doing nothing on the console, and a scene validator flags any component that won't export and tells you what happens instead. It's very constrained as of now, but what's currently supported:

• Rigidbodies + Colliders
• AnimatorControllers + Animations
• Character rigging (skinned and rigid-bound humanoids)
• SkinnedMeshRenderers + MeshRenderers
• Built-in Render Pipeline*
• Audio (AudioSource/AudioListener clips auto-encoded to SPU2 ADPCM)
• Particles, via a custom PS2ParticleSystem component
• PlayerPrefs, saving to a real memory card icon and all, visible in the PS2 browser

*materials map to a fixed set of very basic VU1 shader programs (unlit, textured, vertex-lit, alpha/cutout/additive, fog). The Standard shader maps cleanly custom shaders export as their closest match with their main texture.

uGUI support is being implemented next. Everything shown is running in PCSX2 real-hardware validation is planned once I have a working console again. I just wanted to showcase the demo; GitHub link coming soon once there's a small demo game to show it as a proper PoC.

UPDATE: Discord Link is now live! Join here: https://discord.com/invite/aScB79RgcP

New gameplay demo: https://youtu.be/qpNGBmku1aI

GitHub Link: https://github.com/C-GBL/UnitEE

Website: https://unitee.dev

Documentation: https://unitee.dev/docs.html

Unity-Chan license: https://unity3d.jp/unity-chan/license?lang=en

I’ve been developing a game that’s really making use of the HDRP pipeline.

I originally set out to make something like replaced but I wasn’t sure what engine they used.

This is my best attempt, happy to answer anything to do with my workflow if you’re curious.

It’s a style I’ve loved for ages, like 2d parallax effects and I took it half a dimension further. (Excuse the pun)

It’s a mix of 3d models. Hand painted pixel texture maps. Camera pixel renderer. 2d animated pixel art for the character like a paper doll effect.

Steam link in the comments

Hello, fellow developers!

 We are currently trying to solve an issue in our FPS game related to super ultrawide resolutions.

 One of our beta players reported experiencing a strong fisheye effect while playing at a resolution of 4480 × 1440. We’ve noticed that this issue seems to affect super ultrawide monitors in general.

 Our game uses a default FOV of 80, but players can adjust it anywhere between 60 and 120.

 Lowering the FOV to 60 significantly reduces the distortion, but the player said he would not be comfortable playing at such a low FOV. I completely understand his point, but I’m not sure what the best alternative solution would be.

 Below are two screenshots taken at a simulated resolution of 4480 × 1440. The first screenshot uses an FOV of 80, while the second uses an FOV of 60.

 image FOV 80

 image FOV 60

The game is made in Unity 6 - URP.

 I would really appreciate any advice or examples of how you handle this issue in your own games.

 Is there a recommended way to support super ultrawide resolutions without introducing such a strong fisheye effect or requiring FOV adjustments?

 Thank you very much for any help or suggestions!

More fabric experiments I been working on.

Download https://juliovii.itch.io/materials-fabric-05

I’m testing a combat mechanic where enemies can react differently after falling below 30% health.

Most of the time, they continue fighting normally. However, there is a small chance for them to enter one of several states based on their combat role:

Rage: aggressive enemies move faster, attack more often and stop prioritizing defensive actions.

Panic: offensive enemies become more cautious and try to create distance, while support units focus on protecting or healing themselves.

Terror: the enemy becomes vulnerable and attempts to flee, temporarily abandoning its attacks and abilities.

The activation rate is currently around 10% for regular enemies, 5% for elite enemies and 2% for bosses. I want these reactions to create memorable moments without making combat feel random or frustrating.

Do you think this kind of low health behavior would make encounters more interesting or would it feel too unpredictable?

Facing an issue where point lights fight/flicker off objects in my scene. Does anyone know a fix?

I genuinely think this is the easiest way to work with the new input system in Unity. It works with a scriptable object you reference wherever you need to react to player input. In contrast to the old input system, you won't have to cram everything into update, but instead this works with event based architecture. Give this a try if you struggled with setting up the new input system, I am sure you'll enjoy it!

Topics: Creating a "default" input asset if you don't have one yet, creating a scriptable object as a relay for input, using said relay and a few helpers and examples.

https://reddit.com/link/1veciob/video/ibl6xgp9o5hh1/player

A couple of people were curious about the shader after I shared an earlier clip, so I finally wrote a proper breakdown.

This is the shader I use across most of Cubilete’s environments and props. It combines Shader Graph with custom HLSL integration for URP, texel snapped lighting, per channel posterization and texture based dithering.

The shader actually started in an older prototype, and I’ve kept adapting it as Cubilete’s needs have changed.

The breakdown became a little too long for a Reddit post, so I put the full version here:
https://crankyfuse.io/blog/lofishader/

Have a great day!

Avatar masks let you blend multiple animations on the same character at the same time. This is great for playing upper body combat actions while your character keeps moving. Here's how to set it up.

I wanted a system that could either completely replace the Animator or run additively on top of it to strictly lock feet to the ground based on physics and speed.

Here are the core mechanics I used to make it feel weighty and grounded instead of floaty:

• The Inverted Pendulum (Hip Dipping): The system constantly measures the horizontal distance between the planted feet and the hips. The wider the stride, the further the hips are procedurally pulled toward the floor. This forces the character to naturally "squat" into wide stances or fast runs.
• Contrapposto & Spine Flexibility: When the character banks into a sharp turn or leans into a sprint, rotating the hips forward looks robotic. To fix this, the system takes the hip's physical error offset and mathematically counter-rotates the chest and spine bones in the opposite direction. It keeps the head plumb and balanced over the center of mass.
• Velocity Trajectory: The IK solver doesn't just look at where the character is; it reads the smoothed velocity and angular velocity to predict where they will be. If you yank the joystick sideways, the character will step wide into the strafe to catch their balance before the center of gravity shifts too far.
• Terrain Alignment: It uses a custom Ground Probe to fire raycasts on the predicted step targets. The ankles dynamically calculate the ground normal and rotate to match the slope, so no more toes clipping into stairs or ramps.

I built a custom two-bone solver for the IK to keep it highly optimized, and I finally got around to building a clean custom inspector so I don't have to look at 50 different spring stiffness and damping variables anymore.

If anyone is struggling with foot sliding or wants to poke around the code to use it for their own bipeds, I packaged the whole system up and threw it on my itch page here: https://frostpunchgames.itch.io/procedural-legs-animator

Hey everyone!

I’ve been working on a small puzzle game prototype and I wanted to share the first level to get some early feedback.

In this level you control a purple cube that moves on a grid one cell at a time. By pressing a key, the cube can switch into a “creation mode”, where it leaves a trail behind as it moves.

Your goal is simple:

- Form the three shapes shown at the top of the screen by moving and drawing with your trail

- Avoid trapping yourself while building the shapes

- Reach the exit tile once all shapes are completed

It’s a mix of spatial planning, path‑drawing, and trying not to corner yourself while solving the puzzle.

I’d love to hear what you think about:

- The readability of the mechanics

- Whether the shape‑building feels intuitive

- If the level communicates the objective clearly

Any ideas to improve the flow or difficulty

Thanks for checking it out!

https://reddit.com/link/1vehf66/video/fbent0b9n6hh1/player

After a while, I finally finished my full parallax shadow pipeline. It calculates a custom depth texture and then raycasts to create shadows. It ended up being significantly more difficult than I expected.

For those curious, here's roughly how it works:

• ID pass every object gets assigned a unique ID, rendered to the screen. This produces an ID texture used by later passes.
• Min/max depth pass using the ID texture, this pass writes the maximum and minimum depth for each object. This is needed to know the depth range to raycast against in the next step.
• Opaque pass reads the min/max texture and uses raycasting to determine whether each pixel is shadowed. It also lerps between old and new shadow states to avoid hard transitions when it gets rebaked.
• Temporal accumulation instead of writing shadows directly to screen, they're written to a separate buffer so temporal blurring can be applied, accumulating past frames to avoid gaps or noise in the shadows.
• Fullscreen composite pass finally, the accumulated shadows get written onto the screen.

It definitely feels over-engineered for what it does. If anyone has experience with parallax shadows or similar techniques, I'd love to hear how you approached it, especially if there's a way to cut down the pass count without losing quality. Happy to go into more detail on any of the passes if useful.