Asset Store newest packages

Procedural Features:

• Grid-Based Generation: Scalable panel system for any roof size.
• Dynamic Profiles: Customize corrugation shapes using standard AnimationCurves.
• Spline Deformation: Bend and shape geometry along complex paths using the Unity Splines package.
• Global Coordinate Cutting: Define precise edges and cutouts without destructive mesh editing.

Modifiers & Effects:

• Procedural Noise: Add realistic dents, weathering, and surface variations.
• Smart UV Mapping: Automatic tileable UVs optimized for PBR materials.
• Integrated Vertex Colors: Pre-computed data for advanced shader effects like rust and moss.

Optimization & Export:

• Multi-LOD Support: Automated generation of 3 LOD levels (High, Mid, Low).
• FBX Baker: One-click export of procedural geometry to standard FBX assets for external optimization or static batching.
• SRP Compatibility: Supports Built-in Render Pipeline, URP, and HDRP.

The Infinite Corrugated Roof (ICR) package provides an intuitive, spline-based workflow to create realistic corrugated surfaces in seconds. Built on a clean, SOLID-based architecture, ICR allows artists to focus on design while the system handles geometry calculation, UV mapping, and LOD management.

Whether you are building a vast industrial warehouse or a small weathered shed, ICR offers the flexibility to customize every aspect of your roof—from wave profiles to structural weathering. The integrated modifier system includes spline deformation for curved surfaces and procedural noise for realistic surface imperfections.

• Documentation
• Demo (Under Development)

Technical details

Number of Unique Meshes: 35

Vertex Count: 4000 to 20000

Collision: Yes-automatically generated

LODs: No

Number of Materials: 44

Number of Material Instances: 0

Number of Textures: 161

Texture Resolutions: 4k

A high-quality, game-ready Wizard’s Study designed for Unreal Engine 5 Perfect as a magical landmark for RPGs, fantasy worlds, cinematics, or open-world environments

I'm using the URP rendering pipeline. If you import materials into your project and they appear pink, just modify the materials accordingly.

Enhance your urban environments with this high-quality Urban Street Props 3D Model Pack, designed for games, simulations, and real-time applications in Unity.

This pack includes a wide variety of essential city street props, perfect for building realistic streets, public spaces, and modern environments. All assets are optimized for performance and easy to integrate into your projects.

📦 Included Assets:

• Bus Stop
• Park Bench
• Traffic Light
• Streetlight
• Fire Hydrant
• Mailbox
• Telephone Booth
• Trash Can (Standard & Blue Variants)
• Road Signs
• Cone-shaped Roadblock
• Stone Roadblock
• Carton Boxes
• Wooden Crates
• Industrial Containers
• Metal Drums
• Vehicles: Bus & Taxi

🚀 Features:

• Clean topology and game-ready models
• Optimized for real-time rendering
• Modular design for flexible scene building
• Suitable for urban, city, and street environments
• Compatible with Unity (Built-in / URP / HDRP – if applicable)
• Easy to customize and extend

🎯 Use Cases:

• City-building games
• Open-world environments
• Simulation projects
• VR / AR experiences
• Architectural visualization

Create immersive urban scenes quickly with this versatile and production-ready asset pack.

I'm using the URP rendering pipeline. If you import materials into your project and they appear pink, just modify the materials accordingly.

Contact Me:

If you have any questions, please feel free to contact me.

Email: liuerjie20131314@163.com

Details:

• Each hedge ranges from 30k to 90k triangles, depending on the number of cards per mesh.

• Hedges include an LOD component for improved performance.

Render Pipeline

• Built-in Render Pipeline

• Universal Render Pipeline

Unity Version

• Unity 2021.3 LTS or newer

Procedural Hedge lets you quickly create stylized hedge fences directly in Unity.

The asset generates hedge meshes procedurally, allowing you to control size, density, leaf distribution, and overall shape without manually modeling each variation. 

It also includes a foliage shader with wind animation and color tinting for a more natural look.

Ideal for gardens, parks, fences, mazes, and outdoor environments.

Audio file types : WAV

Sample rate: 44.1k

Bit depth: 16

Loopable: Yes

Additional: Stereo

Royalty Free

Heavy guitars, massive drums, squealing solos! This music pack includes six tunes, perfect for boss battles, mini bosses, combat, or any other moments you might need some massive, epic music. Inspired by Hades, Naruto, and hair bands, this music pack is meant to kick you in the teeth! All tracks are YouTube safe. Music pack artwork by ivanwithvodka.

Tracklist (.wav, 16bit, 44.1k) (All tracks include a loop and non-loop version)

1. All Out [1:38]

2. Speed Demon [1:23]

3. Dodge and Weave [1:21]

4. Slow Motion Explosion Walkout [1:39]

5. Hackin' and Slashin' [1:24] (Includes version with/without guitar solo)

6. Turf War [1:27]

Models

• Number of statues: 10
• Meshes per statue: 1
• LODs per statue: 5
• Approx. triangle count (LOD0): ~15,000
• Lowest LOD triangle count: ~5,000
• Scale: 1 unit = 1 meter
• Orientation: Z forward, Y up
• Pivot: At base

Textures & Materials

• Texture resolution: 4K (4096×4096)
• Mask Map (R = Metallic, G = Occlusion, B = Edge (unused), A = Smoothness)Texture types included: Albedo / Base Color Normal
• PBR workflow
• Separate materials provided per render pipeline

Colliders

• Simple mesh colliders generated from input meshes (can be replaced or customized as needed)

Compatibility

• Supported platforms: All platforms supported by Unity
• HDRPRender pipelines: Built-in URP

Additional Notes

• No runtime scripts included
• No third-party dependencies
• No project settings are modified on import

10 Dark Fantasy Statues is a curated pack of stylized statues designed for dark fantasy worlds.

Each statue is optimized for real-time use and includes multiple LOD levels for performance scalability.

Mesh

Each statue is baked into a single mesh for maximum performance, this is also true for statues with a Plint were everything is joined into one mesh object.

Features

• 10 unique statues
• Dark fantasy / stylized art direction
• PBR materials
• Multiple LODs per statue
• Consistent scale and orientation for game-ready use
• Demo scene for preview and inspection

Render Pipeline Support

This asset includes separate materials for:

• Built-in Render Pipeline
• Universal Render Pipeline (URP)
• High Definition Render Pipeline (HDRP)

No project settings are modified on import.

An optional editor-only helper is included to assist with material assignment in URP and HDRP.

Screenshots

All screenshots were taken on the Built-in Render Pipeline and contain no post processing.

Demo Scene

A lightweight demo scene is included for preview purposes.

It contains a simple camera orbit controller for inspection only and does not modify project settings or input mappings.

Contact:

monoassetshop@gmail.com

Web Page:

https://monoassetshop.carrd.co/

Polygons 16,513

Vertices 17,256

Number of textures 4

Texture dimensions 4096x4096

Number of prefabs 1

Rigging No

UV mapping Yes

Types of materials and texture maps PBR

A high-quality, low-poly stylized rocket perfect for games, animations, and mobile apps. This model features a clean, "toony" aesthetic with a vibrant blue and white color scheme. Despite its optimized geometry, it includes high-resolution 4K textures to ensure crisp details even in close-up shots.

- Prefabs: 53

You can choose from five different body colors and nine different facial expressions. You can see images of all the prefabs. All of them are already set up.

- Animations: 7

Idle, Walk, Run, Jump, Sit, Sleep01, Sleep02

- Demo scene: 3

- Polygon count: 7456

- Textures: 59

- Texture size: 1024x1024

- System requirements: Ver.2019.4.41 or higher

Please feel free to contact us if you have any questions or problems.

You can choose from five different body colors and nine different facial expressions. You can mix and match the striped body and face parts to create your own cat. (There are 53 pre-set prefabs in total.)

Its simple design and low-poly style make it perfect for mobile games.

---------------------------------------- short technical description -----------------------

• Vertex counts of characters: 26884
• Texture Resolutions: (body x4096 weapons x2048)
• Number of Animations: 46

------------------------------------------------ SUPPORT ----------------------------------

Email: dyl.props.environment.artist@gmail.com

---------------------------------------------Demon Swordsman----------------------------

Demon Swordsman - https://youtu.be/pOT-gMJ5jGo

------------------------------------------------ FEATURES --------------------------------

• fabric simulation
• 3 sets of unique texturesanimation;
• Sword

7x attack

1x death

2x hit

2x idle

1x rage

2x run

6x Walk

1x Jump

1x Turn Left 90

1x Turn Right 90

1. monster

8x attack

1x death

2x hit

2x rage

2x idle

2x run

2x walk

1x fear

1x fear run

1x hysterics

Asset Content:

• 30+ Unique Meshes: Environment pieces, tools, furniture, industrial machines, and props (.FBX). （Below are the polygons of the unique meshes）
• BenchDrill:4954
• BluedNut:168
• BluedScrew:250
• CoffeeSign:2
• Gear:786
• Hammer:688
• Nut:168
• PlasticNut:168
• PlasticScrew:250
• Screw:250
• SM_BandSaw:4091
• SM_Barrel:872
• SM_Cabinet:596
• SM_Cardbox:156
• SM_CeilingLight:1560
• SM_CeilingLight_NoCable:1528
• SM_CoffeeBag:282
• SM_CoffeeBrewer:2538
• SM_CoffeeGrinde:1898
• SM_CoffeeMug:448
• SM_CoffeePortafilter:1008
• SM_CoffeePot:1640
• SM_Dustbin:962
• SM_DustbinBucket:576
• SM_DustbinLid:386
• SM_PropBox:456
• SM_Rack:528
• SM_WoodenCrate:728
• SM_Workbench:788
• WarningSign:2
• Wrench1:544
• Wrench2:478
• Textures: High-quality 2K PBR Maps (Albedo, Normal, Metallic/Smoothness, Ambient Occlusion).
• Texture Dimensions: 2048 x 2048 pixels
• Texture Types:
• BaseMap
• Normal Map
• Mask Map
• Ambient Occlusion (AO) Map
• Emission Map
• Materials: 6 Tiling materials for floors/walls and various decal textures to break up repetition.

Character & Animation:

• 1 Stylized Engineer: Fully rigged humanoid character.
• LODs: 3 Levels of Detail for performance optimization.
• Animations: Basic locomotion set (Idle, Walk, Run) and simple interaction animations.
• Scripts: Includes a lightweight, easy-to-use Character Controller script (and even a AI script).

Render Compatibility:

• Universal Render Pipeline (URP) - Recommended
• Built-In Render Pipeline

Additional Info:

• Designed specifically for Top-Down/Isometric views but suitable for Third-Person cameras.
• Demo scene included.

Kickstart your next project with the Stylized Engineering Workshop!

This all-in-one asset pack provides everything you need to construct a cozy, bustling workshop, factory, or garage. Designed with a clean, semi-realistic art style, this package is optimized for Top-Down perspectives (management sims, ARPGs) but detailed enough for Third-Person exploration.

✨ Complete Environment Kit

From brick walls and wooden storage to heavy industrial machinery like drill presses and bandsaws, you can build a scene that feels lived-in and functional. The assets utilize 2K PBR textures to ensure they look great under any lighting condition.

👷 Meet Your Engineer

Bring the scene to life immediately with the included Engineer character. He comes fully rigged with 3 LOD levels and a suite of essential animations (locomotion + interaction). We’ve even included a simple, plug-and-play character controller so you can start walking around your level right away.

☕ Priorities First

While the heavy machinery is impressive, we’ve included the most critical piece of equipment for any engineering project: The Coffee Machine. Complete with mugs and coffee bags, your digital workforce will never suffer from a lack of caffeine. 

Key Features:

• Render Pipeline: Built for URP, but fully compatible with the Standard (Built-in) Render Pipeline.
• Custom Shaders: Includes a custom 2-Layer Height Blend shader to create seamless, realistic transitions on floors and walls.
• Versatile: Perfect for strategy games, tycoons, or stylized adventures.

Unity Version: 2021.3 LTS or newer

Render Pipeline: Built-in / URP / HDRP compatible

Platforms: All Unity-supported platforms (PC, Mobile, VR, Console*)

Dependencies: None (no third-party packages required)

Audio Middleware: Uses Unity’s native AudioSource system

Architecture

• Centralized AudioSystem
• Data-driven SoundDefinition
• Struct-based PlayContext (no runtime allocations)
• Deterministic QueueController
• Pooled AudioVoice instances
• Runtime Debug Window (Editor only)

Layered Flow:

AudioTrigger → AudioSystem → QueueController → AudioVoice → AudioSource

Performance & Optimization

• Zero runtime allocations during playback
• No LINQ usage
• No reflection
• No dynamic GameObject creation during play
• AudioSource pooling (no instantiation spikes)
• Global voice limit protection
• Deterministic voice stealing
• Safe shutdown handling

Suitable for:

• Mobile projects
• VR applications
• UI-heavy systems
• Dialogue-heavy games
• Long-running sessions

Features

• QueueAllClip selection modes:
  Single
  Sequence
  RandomWeighted
  
• Per-sound or per-category queueing
• Cooldown & anti-spam protection
• SingleGlobal instance mode
• Protected voices
• Delay modes (Fixed / RandomRange)
• Runtime queue control (Next / Prev / Skip / Clear)
• PlayContext temporary overrides
• Zero-code AudioTrigger component
• Editor Debug Window (Active + Queued sounds)

Code Quality

• No static global state corruption
• No hidden runtime editor coupling
• Clear public API surface
• Deterministic execution order
• Safe under heavy load

Documentation

• Structured workflow documentation
• API reference examples
• Usage best practices
• Performance notes
• Common mistake guidance

🎧 Woi Audio System

Clean. Simple. Deterministic. Production-Ready.

🧩 Simple to Use

Add AudioSystem → Create SoundDefinition → Call Play()

That’s it.

No setup chaos. No hidden magic. Just structured audio.

🎮 Live Demo

Try the system directly in your browser or pc:

🔗 WEB DEMO | PC DEMO

Important Note:

This package does not include any music, sound effects, or demo audio clips.

Any audio used in preview videos, promotional content, or demonstration materials is for presentation purposes only and is not included in the package.

👨‍🎨 Designer-Friendly

All behavior lives inside SoundDefinition.

No hardcoded rules.

No scattered logic.

Use AudioTrigger for zero-code playback.

Designers control behavior. Programmers just send intent.

🚀 Why Developers Choose It

🧠 Deterministic Playback

No unpredictable overlap. Clear execution rules.

⚡ Optimized & Safe

Zero runtime allocations during playback

AudioSource pooling

Global voice limit protection

Safe shutdown handling

🔁 Advanced When Needed

Queue system

Sequence / Random / QueueAll

SingleGlobal rules

Cooldown & anti-spam

Runtime queue control

🔍 Built-In Debug Window

See active sounds

See queued sounds

Skip / Clear instantly

No more “Why is this not playing?” questions.

🎮 Built for Indie PC Developers

Perfect for:

• Story-driven games

• UI-heavy projects

• Dialogue systems

• Audio-sensitive mechanics

• Small teams that need structure

Lightweight enough for indie scale.

Structured enough for production.

📚 Well documented

🤝 Ongoing support

🧱 Clean architecture

⚙ Production-safe

Woi Audio System keeps audio predictable, optimized, and scalable — without overengineering.

• Architecture: Pure C# implementation using Unity.Collections, Unity.Jobs, and Unity.Burst.
• Solver Type: XPBD (Extended Position Based Dynamics) with constraint regularization.
• Performance: Fully multi-threaded simulation step. Zero-garbage collection during runtime (uses NativeArray and persistent allocators).
• Supports: Standard, URP, and HDRP (via standard Material support).
• Rendering:Procedural Mesh generation on the GPU/CPU boundary using Burst.
• Dependencies: Requires Burst and Mathematics packages (installed via Package Manager).
• Compatibility: Compatible with Unity 2021.3 LTS and newer.
• Platforms: Supports PC, Mac, Linux, Consoles, and High-End Mobile (iOS/Android) due to Burst optimization.
• Included: Full source code, 5 demo scenes (Grappling Hook, Bridge, Stress Test, Cutting, Winch), and PDF documentation.

Tensio is a cutting-edge rope simulation framework designed for developers who need more than just a visual line renderer. Whether you are building a physics puzzle, a swinging mechanic, or a realistic environment, Tensio provides the stability and performance required for gameplay-critical physics.

Built on the Extended Position Based Dynamics (XPBD) method, Tensio simulates elasticity, stiffness, and mass with high precision. It fully leverages Unity's Data-Oriented Technology Stack (DOTS) to handle hundreds of particles across multiple ropes with minimal CPU overhead.

Key Features

• XPBD Physics Solver: Stable, jitter-free simulation that supports both stretchy elastic ropes and rigid, non-stretching chains using sub-stepping.
• Two-Way Coupling: Real physics interaction; ropes can pull Rigidbodies, and Rigidbodies can pull ropes.
• Environment Collision: High-performance SphereCast collision for continuous detection against static and dynamic world geometry.Advanced Collision:
  Self-Collision: Ropes won't pass through themselves.
  Inter-Rope Collision: Multiple ropes can tangle and interact complexly.
  
• Aerodynamics: Built-in wind and turbulence simulation with air drag.Dynamic Interaction:
  Runtime Cutting: Slice ropes at any point in real-time.
  Grabbing & Pinning: Attach particles to objects or move them via script.
  
• Procedural Rendering: Smooth, tube-based mesh generation with support for textures, normal maps, and UV tiling. Includes Visual Stress (ropes thin out/change color under tension) and specialized Chain Rendering.
• Editor Tools: Intuitive Bezier curve editing for defining initial rope shapes directly in the scene view.

Immersive Procedural Audio:

• Tension-Based SFX: Dynamic creaking and snapping sounds that automatically modulate pitch and volume based on real-time physical stress. Hear the rope strain before it breaks!
• Velocity Whoosh: Aerodynamic wind sounds driven by the speed of individual rope particles during swings.
• Spatial Accuracy: Sound sources follow the exact point of highest tension or impact along the curve for fully 3D spatialized audio.

Third-Party Notice: This asset uses various audio and texture files under the CC0 1.0 Universal License; see the Third-Party Notices.txt file in the package for details.

1.Professional UI element design

Centered around scifi and cyberpunk, the unique and professional design is suitable for various scifi-themed games.

2.Richly styled elements

Buttons(4 states),popups,panels,sliders,labels,tabs,frames,input fields,check box,swiths,radios,tips,drop-down menu,liner progress,circular progress,etc.

3.UI elements as prefabs

Prefabs for individual elements were ready ,so you can easy to use them! All you need to do is drag the prefabs into your scene to easily create your own UI, or you can directly use the pre-built Canvas UI.

4.Sliced sprites

9-Sliced sprites were ready,so you can change size and color easily in unity 3d.

5.Customizable

Each element is separate, so you can use your own icon, text, etc.The white UI elements in the components are layered and their colors can be customized.

6.Resolution

Demo scene:1920*1080px

Components:3840*2160px

---------------------------------------------------------------------------------

✪ Asset Content ✪

■ Textures

1800+ png textures(from 128px*128px to 3840px*2160px)

■ Prefabs

400+ prefabs

■ Scenes

2:Demo scene and component scene

■ Canvas

Scene Canvas:25

Components Canvas:20

■ Scripts

14 scripts

■ Animations

6 animations

---------------------------------------------------------------------------------

If you have any questions or have better suggestions about this asset, please contact us immediately.Thanks.

Support:dfystudio.art@gmail.com

Key Features

• gameplay loop:
  Planting
  Growth stages
  Watering
  Fertilizing
  Harvesting
  
• Built entirely using Game Creator 2 systems (no custom runtime code required)
• Fully integrated with Game Creator 2 Inventory
• Seeds, crops, and tools are standard Inventory items
• Per-crop configuration via Scriptable Objects / data assets
• Visual, inspector-driven setup
• Demo scene included

• THIS ASSET DOES NOT CONTAIN CROPS, ONLY SYSTEM WITH GC2 INTEGRATION. (there is a AI Generated Carrot with 5 stages of growth and a soil planter meant for learning and demonstration purposes only)

Requirements

• Unity 2021 LTS or newer
• Game Creator 2 (Core)
• Game Creator 2 Inventory Module
• Game Creator 2 Inventory Examples (required)
• TextMeshPro

Game Creator 2 Farming System is a modular and fully data-driven farming framework suitable for a wide range of game genres, including survival, RPG, life-sim, cozy games, and farming simulators.

The system uses Game Creator 2 Actions,Variables and custom scripts allowing designers to configure farming plots, crops, and interactions visually without scripting.

All farming behavior including growth stages, watering requirements, fertilization, spoilage, and harvesting can be customized per crop.

A demo scene and Quick Start window are included to help users get up and running quickly.

This asset is ideal for developers who want a robust farming system that feels native to Game Creator 2 and follows its no-code philosophy.

🛠 Technical DetailsFast Reload bypasses Unity’s heavy Domain Reload process by using a Roslyn-based incremental compiler to inject modified logic directly into memory.

• Performance: Average injection time of ~0.5s (may scale with dependency chain complexity).
• State Preservation: Automatically transfers field data from old instances to new logic using our custom StateManager.
• Dynamic Injection (New): Supports real-time addition and initialization of new fields and C# Event Actions during Play Mode.
• Smart Callbacks: Use the [InvokeOnFastReload] attribute to trigger initialization logic immediately after a patch.

⚠️ Technical Notes & LimitationsTo maintain engine stability and transparency, certain structural changes require a standard Unity Re-compilation:

• Inspector Visibility: Newly added fields exist in memory but will not appear in the Unity Inspector until a formal re-compile.
• Unity System Callbacks: Engine-level callbacks (Awake, Start, OnCollisionEnter, etc.) must exist in the script before entering Play Mode to be patched.
• Generic Refresh: When editing a Generic method, you must also save the script that calls it to refresh the dependency chain.
• Auto-Properties: Currently, manual properties with backing fields are recommended over auto-implemented properties.

📋 System Requirements

• Unity Version: 2022.3 LTS or higher (Including 2023, and Unity 6).
• Operating System: Windows 10/11 Only (Uses kernel32.dll for memory protection and redirection).
• Scripting Backend: Mono (This is an Editor-only tool; it does not affect IL2CPP build stability).

💡 Pro Tip

If injection speed slows down after dozens of consecutive edits, simply hit the Manual Compile button in the Fast Reload window to refresh the engine state and restore peak performance.

Document

Fast Reload: Professional Hot Reloading for Unity "Keep your code as it is. Only the speed changes."

As projects grow, compilation times do more than just make you wait—they shatter your creative flow. Fast Reload is a high-performance Hot Reload solution that dramatically increases your development speed by injecting code changes into your live game in ~0.5 to 1 second, without a single domain reload.

🚀 Why Fast Reload?

• Zero Configuration: No extra using directives, script inheritance, or complex settings. Just import and code.
• Dynamic Field & Event Support (NEW): Add new variables and initialize them instantly. Support for adding and triggering C# Events during Play Mode is now fully available.
• Stay in the Zone: Don't stop Play Mode. The moment you save, your logic is injected via high-speed 64-bit Method Detouring.
• Identity Preservation: Our StateManager preserves the values of static fields and Singleton instances, keeping your game state intact.
• Unbeatable ROI: The time saved in just one day of development pays for this asset many times over.

🔥 Unmatched Power & Industry-Leading Feature CoverageFast Reload is engineered to handle real-world C# complexity that standard tools struggle with:

• Lambdas & LINQ: Real-time editing for complex queries and closure captures.
• Generics: Full support for modifying Generic classes, methods, and 'where' constraints.
• Dynamic Signatures: Change method parameters, return types, or add/remove methods on the fly.
• Modern C# Syntax: Full support for Switch expressions, Pattern matching, Null-coalescing, and Local functions.
• Specialized Attributes: Use [InvokeOnFastReload] to trigger custom initialization logic immediately after an update.

Invest your time in building great games, not watching loading bars. Once you experience this speed, there’s no going back.

- **Unity version**: 6000.0 or later

- **Dependencies**: com.unity.ugui 2.0.0

- **Optional dependency**: UniTask 2.0 or later (auto-enabled when installed)

- **Core features**:

- Command parsing/execution with pipelines and redirects

- Asynchronous execution via `async/await` (UniTask supported)

- Tab completion for commands and paths

- Shell variable define/lookup/removal

- Custom command registration (manual or assembly scan)

- FlyweightScrollView for large log output

- **Sample**: Basic Usage (Samples~/BasicUsage)

- **Documentation**: https://araiyuhki.github.io/UniTerminal_Reference/index.html

- **License**: MIT OR Apache-2.0

XTerminal is a string-based CLI execution framework that brings a Linux-like terminal experience into Unity. It supports shell constructs such as pipelines and redirects, and ships with built-in commands for file operations, text processing, and Unity object manipulation. With `async/await` execution and optional UniTask integration, it fits naturally into editor tooling, debugging consoles, and level-editing workflows.

**Key features**

- Shell syntax with pipelines (`|`) and redirects (`>`, `>>`, `<`)

- Built-in commands for file operations, text processing, and Unity-specific actions

- Easy extensibility for custom commands

- Variable expansion (`$NAME`, `${NAME}`) and tab completion

- Virtualized scroll view optimized for large logs

- Ctrl+C cancellation for long-running commands

Ideal for in-editor debug consoles, tool-integrated terminals, and in-game administration CLIs that boost productivity in Unity projects.

Texture Maps for Unity Universal Render Pipeline(URP) - Both Metallic and Specular Workflows

• AlbedoTransparent (4K) (2K) (1K)
• MetallicSmoothness (4K) (2K) (1K)
• SpecularSmoothness (4K) (2K) (1K)
• Normal (4K) (2K) (1K)

Unity High Definition Render Pipeline(HDRP) - Both Metallic and Specular Workflows

• Basemap (4K) (2K) (1K)
• MaskMap (4K) (2K) (1K)
• Specular (4K) (2K) (1K)
• Normal (4K) (2K) (1K)

Forklift Truck 03 Orange PolyCount Without Subdivision

1. Vertices - 79238
2. Faces - 72457
3. Tris -140171

Forklift Truck 02 Yellow PolyCount Without Subdivision

1. Vertices - 71444
2. Faces - 66043
3. Tris -127684

Features:

- UnityPackage is created using Built-in Render, URP and HDRP Textures are included in the package.

- Models with Glass and Transparent Meshes are assigned Unique Materials. So there will not any backface artifacts.

- Rig is created in Blender, this UnityPackage doesnot contain any Rig and Animations.

-Objects are grouped and named according to their real purpose, allowing the model to be rigged and animated easily.

-Clean and optimized topology is used for maximum polygon efficiency.

-All textures and materials are tailored and applied for high quality render results.

-Mid Poly and optimized for use for games, films, commercials, etc.

-All objects have fully unwrapped UVs and UVs are Overlapped to utilize more UV space and high texture quailty.

-No extra plugins are needed for this model.

Texture Maps for Unity
Universal Render Pipeline(URP) - Both Metallic and Specular Workflows
- AlbedoTransparent (4K) (2K) (1K)
- MetallicSmoothness (4K) (2K) (1K)
- SpecularSmoothness (4K) (2K) (1K)
- Normal (4K) (2K) (1K)

Unity High Definition Render Pipeline(HDRP) - Both Metallic and Specular Workflows
- Basemap (4K) (2K) (1K)
- MaskMap (4K) (2K) (1K)
- Specular (4K) (2K) (1K)
- Normal (4K) (2K) (1K)

Fantasy Trident 01

Vertices - 8796
Faces - 8567
Tris - 16836

Fantasy Trident 03

Vertices - 13547
Faces - 13280
Tris - 25872

Fantasy Trident 06

Vertices - 13299
Faces - 13132
Tris - 26068

Fantasy Trident 07

Vertices - 14147
Faces - 13851
Tris - 27992

Features:

- UnityPackage is created using Built-in Render, URP and HDRP Textures are included in the package.

- Models with Glass and Transparent Meshes are assigned Unique Materials. So there will not any backface artifacts.

- Rig is created in Blender, this UnityPackage doesnot contain any Rig and Animations.

-Objects are grouped and named according to their real purpose, allowing the model to be rigged and animated easily.

-Clean and optimized topology is used for maximum polygon efficiency.

-All textures and materials are tailored and applied for high quality render results.

-Mid Poly and optimized for use for games, films, commercials, etc.

-All objects have fully unwrapped UVs and UVs are Overlapped to utilize more UV space and high texture quailty.

-No extra plugins are needed for this model.

Unity Versions: 2021.3 LTS, 2022+, Unity 6
Render Pipelines: Built-in, URP, HDRP
Scripting Backend: Mono / IL2CPP
Input: Unity Input System (optional)
Localization: Unity Localization package (optional)
Documentation: Included
Source Code: Included

Why AXIS?

Every game needs settings.

Most teams rebuild them from scratch; menus, saving, rebinding, accessibility, events, profiles, graphics differences per pipeline…

AXIS solves this once, properly.

AXIS is a runtime-first settings and accessibility framework for Unity, designed to ship with real games.

It handles data, persistence, application, and events, so you can focus on UI and gameplay, not infrastructure.

Built for Unity 2021.3 LTS+ and Unity 6, AXIS works out of the box with UI Toolkit, Built-in, URP, and HDRP, and scales from indie projects to production pipelines.

What Makes AXIS Different?

• Not just a menu — a complete runtime settings architecture
• Accessibility-first design, not an afterthought
• Pipeline-agnostic graphics system via adapters
• Clean API & event system for reactive UI
• Designed to be extended, not locked down

Complete Settings Framework

• Graphics, audio, controls, accessibility, localization
• Centralized settings model with automatic persistence
• Apply settings instantly or via explicit Apply / Cancel flows

Accessibility Built In

• Text scaling
• High contrast mode
• Reduce motion support
• Fully configurable subtitles system
• Accessibility events for UI announcements

Cross-Render-Pipeline Graphics

• Built-in graphics adapters for: Built-in Render Pipeline, URP & HDRP
• Resolution, window modes, VSync, FPS limit, FOV
• Quality presets with smart fallbacks

Audio System Integration

• Master / Music / SFX / VO volume control
• Audio mixer–ready architecture
• Optional Night Mode support

Input Rebinding (Optional)

• Unity Input System support
• Runtime key rebinding
• Device-aware bindings
• Conflict detection events
• UI Toolkit–friendly rebind workflow

Profiles & Presets

• Create reusable settings profiles
• Apply presets at runtime (e.g. PC / Console / Accessibility presets)
• Capture current user settings into profiles

Modular & Extensible API

• Event-driven architecture
• Custom storage backends (JSON, PlayerPrefs, cloud, etc.)
• Replace or extend individual systems without modifying core code

Performance & Architecture

• Lightweight runtime footprint
• No per-frame polling
• Event-driven updates
• SRP-agnostic via adapter interfaces
• No dependency on legacy IMGUI

Compatibility

• Unity 2021.3 LTS or newer
• Unity 6 compatible
• Platforms: WebGL (with PlayerPrefs-based storage), PC, Consoles, Mobile
• Render Pipelines: Built-in, URP & HDRP
• Optional Packages: Unity Localization & Unity Input System
  

Included

• Full runtime framework
• Editor setup tools
• Sample scenes and scripts
• Example menus and integrations
• Complete documentation

Who Is This For?

• Indie developers who want professional-grade options & accessibility
• Teams shipping on multiple platforms
• Projects using UI Toolkit
• Developers who want clean APIs, not black boxes

Support

• Full documentation included
• Sample projects to learn from
• Clean, readable source code
• Designed for long-term project use

Bring modern, accessible, and scalable settings to your game with AXIS.

Technical Details

• Unity Version: Compatible with Unity 6 (6000.0.x) and newer.
• Dependencies: Requires com.unity.ui (UI Toolkit) - Standard in Unity 2022+.
• Build Support: Editor-only tool. Compatible with projects targeting All Platforms (Windows, Mac, iOS, Android, WebGL, Consoles).
• Assembly Type: Pre-compiled optimized DLL (Editor).
• Source Code: Core logic is DLL-encapsulated for compilation speed; Custom Rule templates are provided in C#.
• Documentation: Comprehensive PDF included.

Ship cleaner, faster, and safer with Asset Sentinel.

Is technical debt slowing down your development?

As projects grow, they accumulate "rot": missing scripts on prefabs, uncompressed audio files, duplicate assets, and debug materials left in release builds. Finding these manually is tedious and prone to human error.

Asset Sentinel automates this process. It acts as your project's gatekeeper, scanning thousands of assets in the background without freezing your Editor. It flags critical errors that break builds and optimization warnings that bloat your game size.

Key Features

• Build Guard: Never ship a broken build again. The pre-build processor automatically cancels the build process if Critical Errors (like Missing Scripts or Shader Errors) are detected.
• Asynchronous Scanning: Built on a time-sliced architecture, Sentinel scans massive projects without locking up your UI. Keep working while it scans.
• One-Click Fixes: Many rules implement IFixable. Fix texture compression, audio settings, or clean up empty folders instantly from the dashboard.
• Zero Runtime Overhead: The core system is compiled into a lightweight Editor DLL. No code or overhead is added to your player builds.
• Extensible API: Need project-specific checks? Create Custom Rules easily. The system automatically finds your scripts via reflection—no manual registration required.
• Modern Dashboard: Built with Unity's latest UI Toolkit, offering sortable columns, search filtering, and a clean, native look.

Included Rule Set (26 Built-in Rules)

Critical (Build Safety)

• Missing Script: Detects "Missing Behaviour" on Prefabs and ScriptableObjects.
• Scene in Build: Warns if a .unity file in your Scenes folder is not added to Build Settings.
• Shader Error: Detects materials using the broken (Pink) shader.
• Duplicate Assets: Detects binary identical files to save build size.

Graphics & Art

• Texture Power of Two: Ensures textures are POT for compression.
• Texture Compression: Flags textures set to "Uncompressed".
• Large Textures: Flags textures exceeding safe limits (default 2048px).
• Platform Override: Ensures specific overrides exist for Android/iOS.
• Read/Write Enabled: Flags Meshes with Read/Write enabled (memory waste).
• Mesh Tangents: Disables tangents on meshes without Normal Maps.
• Mesh Collider: Warns against expensive "Generate Mesh Collider" on import.
• Import Scale: Ensures models are imported at 1.0 scale.
• GPU Instancing: Checks if compatible materials have Instancing enabled.
• Double Sided GI: Flags materials with Double Sided Global Illumination enabled (expensive lightmapping).
• Sprite Atlas Size: Warns if Sprite Atlases exceed max texture dimensions.

Audio

• Audio Mono: Forces 3D SFX to Mono to save 50% memory.
• Load Type Optimization: Enforces "Decompress on Load" for short clips and "Streaming" for long music.

Performance & Code

• UI Raycast Target: Flags non-interactive UI elements (Images/Text) that block input.
• Particle System: Checks for excessive Max Particles or expensive Culling modes.
• Static Rigidbody: Flags Static objects that have Rigidbodies (high CPU cost).
• Empty Methods: Detects empty Update() calls in C# scripts.
• Huge Files: Warns about files > 100MB (VCS issues).
• Empty Folders: Detects empty directories cluttering the project.
• Static Mesh Animation: Flags Static objects that have Animator components attached.

Architecture

• Assembly Definition: Warns if a folder contains too many scripts (>20) without an .asmdef.
• Naming Convention: Checks standard prefixes (T_ for Texture, M_ for Material).