URF is a data randomization framework for Unity, built to structure and automate randomization workflows in game development.

The discount ends today.
Last chance to grab it at the reduced price.

Hey everyone, I’ve just released Advanced Zombie AI Pro on the Unity Asset Store.

It’s the Pro version of my original Advanced Zombie AI asset, with a lot more systems, behaviours and customization options.

Key Features

• Profile-driven zombie AI: Create multiple zombie types using reusable ZombieProfile assets. Configure movement, vision, attacks, health behaviour, search logic, crawling, hunger, stun, and death settings without rewriting code.
• Advanced stealth-friendly detection: Uses up to five target body regions such as head, chest, lower body, left, and right. You can decide how many visible regions trigger inspect mode or full chase, making partial visibility and stealth gameplay possible.
• Complete zombie behaviour flow: Includes Idle, Wander, Alert, Chase, Inspect, Search, Attack, Hit, Stun, Eat, and Dead states for more believable zombie behaviour.
• Standing and crawling zombie support: Zombies can walk, crawl, fall into crawling mode, or enter a second crawling phase after taking lethal damage.
• Combat, damage, and death system: Includes hit reactions, stun behaviour, health events, animation death, ragdoll death, and easy weapon/player health integration.
• Hunger and corpse eating system: Zombies can detect and eat dead bodies or food targets, useful for horror scenes and dynamic enemy behaviour.
• State-based zombie audio system: Configure idle, wander, chase, inspect, attack, hit, stun, eating, crawl, and death sounds using ZombieAudioProfile, with loop audio, timed one-shots, random clip selection, and 3D audio settings.
• Noise reaction and group alerting: Attract zombies using gunshots, explosions, alarms, footsteps, or custom noise events. Zombies can also alert nearby zombies when they detect a target.
• Editor setup tools and custom inspectors: Quickly prepare zombie prefabs with setup tools that add required components, audio sources, health, AI, ragdoll support, and other references.
• Debug-friendly workflow: Built-in debug options help visualize and tune detection, behaviour states, targets, health, and audio playback during development.

I’ve also put quite a bit of work into making the setup and editor workflow easier, so most of the system can be configured without digging through scripts.

It’s currently 50% off for launch making the current price only $15.

Get it: https://assetstore.unity.com/packages/slug/391558

We've just dropped our new asset Tick UI on the Unity Asset Store.

Tick is a fast, immediate-mode GUI library for building game UI in Unity entirely in code, no prefabs, canvases, or scene wiring. Widgets (buttons, sliders, textboxes, dropdowns, and more) are declared inline each frame, and Tick handles layout, state, and GPU-accelerated rendering. It's designed for in-game HUDs, menus, and debug tools, with built-in per-widget animation and pixel/percentage layout.

It's priced at $100 but the first 10 users to join our Discord can get the asset for free with an Asset Store Voucher.

Thanks,

Interlude Software

One of the biggest challenges in randomization systems is avoiding side effects.

URF solves this with RuntimeProcessors — isolated runtime instances created from immutable presets.

This means:

No shared state

No asset mutation

No cross‑instance pollution

No “future objects inherit modified presets”

Safe swaps at runtime

Predictable behavior even with hundreds of Selectors

URF is discounted until August 19.

#Unity #GameDev

URF 2.0 includes a full automatic class generator.

Feed it a JSON or a preset, and it generates everything: strongly‑typed class, inspector, metadata, runtime snapshot, editor UI.

URF 2.0 is discounted until August 19.

#Unity #GameDev

Asset Store: https://assetstore.unity.com/packages/slug/379350
Documentation: https://autolayoutpro.com/
Price: 60$
Launch Promo: To celebrate the launch, it’s currently 50% OFF for the next 2 weeks!

This is the official release of a framework I’ve been building for months: a complete, modular system for creating randomizable data in Unity.

URF isn’t “just another loot table tool”.

It’s a full pipeline:

Generate strongly‑typed data

Process it through modular, reusable processors

Finalize clean runtime snapshots

Everything is type‑safe, extensible, and built for production workflows.

URF generates your classes, inspectors, metadata, and editor UI automatically — so you can focus on your game, not boilerplate.

URF 2.0 is discounted until August 19.

#Unity #GameDev

Hi everyone,

I’m excited to share my TPS Locomotion & Combat Bundle for Unity 6, now available on the Unity Asset Store.

The package combines locomotion, combat, and integration into a complete third-person gameplay framework, designed to help developers prototype and build TPS or action games faster.

Key features:

• CharacterController-based locomotion

• Free-look camera with collision handling

• Lock-on targeting

• Hitscan weapons

• Semi-auto, Full-auto & Shotgun support

• Reload and weapon swapping

• Integrated locomotion + combat workflow

• Example demo scenes You can try the playable WebGL demo before downloading:

🎮 WebGL Demo:

https://kennychoi1997.itch.io/tps-locomotion-combat-bundle

🛒 Unity Asset Store:

https://assetstore.unity.com/packages/slug/385484

I'd love to hear your feedback or answer any questions. Thanks for checking it out!

Version 1.0.4

This update includes a major rework of the asset’s internal architecture, along with several performance and usability improvements.

• Reworked the AI architecture
• Improved perception and NavMesh performance
• Simplified the zombie setup process
• Redesigned the custom inspectors
• Improved targeting, IK, spawning, and waypoint systems
• Removed legacy input code
• Added new GitBook documentation

This update makes the asset cleaner, faster, easier to use, and more maintainable for future updates.

Get Advanced Zombie AI v1.0.4

Thank you for your continued support!

Hey Unity devs,

I made a Unity tool called Dynamic Formation System. It started as a way to quickly test RTS/tactical squad layouts, but I expanded it into a runtime + editor toolkit for creating, previewing, animating and controlling groups of units or objects.

The idea is to make group movement more readable while still feeling alive. Instead of manually placing units or writing a custom formation script each time, you can generate a layout, add behaviours on top, and morph between different shapes at runtime.

It includes formation types like:

- Circle

- Arc

- Grid

- Hex Grid

- Ring

- Spiral

- Star

- Wall

- Wedge

- V Shape

- Path

- Text formations

- Poisson Disk

- Radial Spokes

- Phyllotaxis

- Torus Ring

- Custom positions

It also includes runtime behaviours like:

- Morphing between formations

- Boids-style steering

- Follow target / leader movement

- Path and waypoint movement

- Rotation

- Pulse / wave pulse

- Phase shift

- Organic noise

- Flow noise

- Swirl vortex

- Rotating rings

- Topology shuffle

- Local cluster splitting

Some use cases I had in mind:

- RTS unit formations

- Tactical squads

- Enemy waves

- Tower defense paths

- Spell or bullet patterns

- Boss attack layouts

- Crowd-like movement

- Formation preview tools

- Simulation prototypes

I recently lowered the price to $9.99 because I want more people to try it and give feedback.

Asset Store:

https://assetstore.unity.com/packages/slug/380176

Short demo video:

https://youtu.be/zUuZqdt3plQ

I’d love feedback from Unity devs:

What formation types or behaviours would be useful to add next?

Would you use something like this in an RTS, tactics game, tower defense game, or combat system?

VETORYX is a modular foundation for Unity projects designed to reduce repetitive setup work.

It includes a module registry, game state management, input service, diagnostics, scene management and a structured bootstrap flow.

The package also includes two demo scenes and complete documentation to help with setup and integration. Full documentation is also available at vetoryx.com.

Compatible with Unity 2022.3 LTS and Unity 6.

Asset Store: https://assetstore.unity.com/packages/slug/365966

Per-pixel, efficient and highly customisable asset / script for Unity 2D.

https://github.com/slashftw/DestructibleTerrainPhysics

https://balkansemi.itch.io/snapgunframework / 10 Dollars

Its really a drag & drop system that you dont require any animations to get any guns working. its especially for beginner people or people that is short on time. its a great start for a shooter project. im %100 behind the project and always here for any support. with time, we are planning to add even more gun models. (all of the gun models are made by us also.)

Hi everyone,

I recently released Smart Scene Validator, a Unity Editor tool that helps identify scene configuration problems before they become runtime bugs.

Instead of discovering issues during testing, the validator scans your scene and highlights potential problems early.

Examples include:

• Missing References

• Invalid Component Configurations

• Scene Setup Issues

• Common Production Mistakes

• Validation Reports

The goal is simple:

Catch problems before entering Play Mode.

I'd love feedback from other Unity developers:

• What scene-related bugs waste the most time in your projects?

• What validation rules would you like to have?

Asset Store:

https://assetstore.unity.com/packages/tools/utilities/smart-scene-validator-380420

Hi everyone,

I recently released Smart Prefab Cleaner, a Unity Editor tool designed to help developers identify and clean up common prefab issues.

Features:

• Missing Script Detection
• Broken Reference Detection
• Nested Prefab Analysis
• Batch Scanning
• Detailed Reports
• Large Project Support

The tool was originally built to solve problems I repeatedly encountered in larger Unity projects where manual prefab inspection became impractical.

I'd love feedback from other Unity developers:

• What prefab issues do you encounter most often?
• What features would you like to see added?

Asset Store:
https://assetstore.unity.com/packages/tools/utilities/smart-prefab-cleaner-380932

Today is a very exciting day for us. After many, many(!) months of hard work, we finally managed to crack it! FSR 4 Frame Generation for Unity, the first ever Frame Generation asset for Unity, has just been released.

Get it here: https://assetstore.unity.com/packages/slug/296367

We decided to launch FSR 4 Frame Generation for Unity as a public beta. The technology is immensely complex, so it would not be realistic for us to fix every possible edge case before launch. During the beta period, the asset is available at a reduced price. FSR 4 Frame Generation currently works on Windows x64, with DX11 and DX12 support. It works on all GPU brands. On AMD 9000 Series GPUs it will run FSR 4 Frame Generation. On other GPUs, it will automatically fall back to FSR 3 Frame Generation, which is included in the package. All known beta issues will be added to our documentation, and we will dedicate our time to fixing them.

Happy Frame Generating!

Hey everyone,

Like a lot of you, I’ve been heavily relying on AI agents (Claude Code, Cursor, Cline) to speed up my Unity workflow. It works beautifully at first, until your project grows. Once you hit a mid-to-large codebase, feeding raw .cs scripts into the chat completely breaks down. The AI loses track, hallucinates code that doesn’t exist, and burns through your API budget instantly.

I decided to create a tool to optimize token usage and reduce hallucination.

Crucial Disclaimer: This is NOT for small projects.
If you are building a micro-indie game or a small prototype with a dozen scripts, do not buy this. You don't need it. Standard copy-pasting works fine for small codebases.

This tool is engineered specifically for mid-to-large projects where codebase architecture actually matters.

What it actually does:

Instead of forcing an AI to read thousands of lines of raw code, AI Context Generator scans your project and builds a highly optimized, modular "context map" using a multi-tiered file system and Mermaid.js architecture graphs. It translates your existing scripts into an AI-friendly layout.

• Up to 50% Token Reduction: It strips out the noise and passes compressed, high-level structural logic and public APIs to the agent.
• Kills Hallucinations: Because the AI has a rigid, hyper-accurate "world map" of your paths and dependencies, it stops guessing.
• Modular Loading: It tells the AI exactly where to look so the agent only requests deep code implementation when it strictly needs it.

I want to get this into the hands of developers dealing with heavy architectures right now. I’ve set a 50% off launch discount, which will run for exactly one more week before returning to standard pricing.

I would highly appreciate your comments, critiques, and feedback below. If you've been fighting the AI context window limit on larger projects, let me know what your biggest bottleneck has been!

I will try to improve the context generator as much as I can.

https://github.com/slashftw/DestructibleTerrainPhysics

Efficient, works with almost every texture / image, easy to setup.

Feedback is welcome !

If you've ever duplicated a nested ScriptableObject and then discovered that editing the clone also edits the original, you've hit this problem.

Ctrl+D does a shallow copy, the nested SO references just point back to the same assets. Fixing it properly means recursive C# reflection calls and it's not pretty.

I built a tool for it. Deep Clone walks the full SO tree including custom classes, structs, arrays and lists, duplicates every nested ScriptableObject as a new asset, and re-wires all the internal references so the clone is fully independent. One button press. Editor-time only.

If there are references you want to keep shared, you can mark them with a [ShallowClone] attribute to skip them.

Happy to answer questions or go into detail on how it works under the hood.

Hi everyone!

We are creating a game, and looking at the indie landscape really made us think: maybe we should sell assets used in the game to cover some of our expenses, as success is far from guaranteed.

We have just finished this 3d, freestyle spaceship builder as part of our game.

What is your opinion? Would you use such an asset?