Asset Store newest packages

Number of Audio Wavs: 36

Sample Rate / Bit Rate: 48 kHz / 24 bit / Stereo

Does Audio Loop: YES

Minutes of Audio Provided: 63 minutes

Supported Development Platforms:

• Windows: Yes
• Mac: Yes

Documentation Link: DEMO

Important/Additional Notes: Have fun with it!

Rap Loops – Westcost features 36 high-quality tracks inspired by classic West Coast rap. Smooth grooves, heavy basslines, and laid-back yet powerful beats give your game, film, or media project an unmistakable West Coast vibe. Perfect for creating a cool, confident atmosphere with authentic hip-hop flavor and timeless street character.

DEMO

DEMO on Youtube

[ASSET INFO] [Website] [Support]

[ASSET HIGHTLIGHTS]

• 121x tileable alien magma & lava ground texture sheets
• Material Variants:
• Standard
• HDRP Lit
• URP Lit
• Relief Parallax
• Tessellation Parallax
• All pipelines available
• 2k texture size
• Map channels:
• Color/Albedo
• Metallic
• Roughness
• Metalness
• Normal map
• Height map
• Ambient Occlusion
• Custom shaders included
• Downloadable (here) Terrain Masks

[DESCRIPTION]

Alien Magmatic Materials brings your worlds to life with over 120 tileable textures designed for maximum flexibility. Each material is optimized for all render pipelines (Standard, HDRP, URP) and enhanced with Relief and Tessellation Parallax custom shaders for added depth.

Every texture comes in 2K resolution with full map support (Albedo, Metallic, Roughness, Normal, Height, AO, Emissive). Perfect for sci-fi environments, nature landscapes, alien landscapes, or even fantasy worlds.

[ALIEN MATERIALS COLLECTION]

[ALIEN ROCK MATERIALS]

[ALIEN GROUND ICE & SNOW]

[ALIEN GROUND SAND]

[ALIEN GROUND ORGANIC]

[ALIEN GROUND PEBBLES]

[ALIEN GROUND DIRT]

[ALIEN GROUND GRASS]

[ALIEN GROUND MUD]

[SCI FI ASSETS COLLECTION]

[OUTER WORLDS]

[NEON CITY BUNDLE]

[NEON CITY]

[PLATFORM CITY]

[SPACE COLONY]

[SPACE BASE]

[SPACE STATION HEAVY]

[TERRAIN ASSETS COLLECTION]

[ALIEN TERRAIN PACK]

[NATURE WORLDS]

[ESSENTIAL TERRAIN]

[MEDITERRANEAN NATURE]

[ANCIENT CAVERNS]

[WINTER LANDS]

[WINTER ASSETS]

If you liked the package please let me know your opinion rating the asset and writting a review, thanks! If you need more info click on the "Asset info" link above.

Includes:

• Trees
• 2 Conifers + LODs & Billboard
• 1 Birch + LODs & Billboard
• 1 Maple + LODs & Billboard
• Smaller Foliage
• 1 Juniper + LODs & Billboard
• 1 Bush + LODs & Billboard
• 1 Fern + LODs
• 1 Flower + LODs
• 1 Grass Clump + Grass Texture for Unity Terrain Grass
• Props
• 2 Mushrooms + LODs
• 4 Rocks + LODs
• Extras
• 2 Particle Systems
• 3 Individual Leaf Materials for Particles
• 1 Ground Grass Texture + Normal Map
• GPUInstancingDemo script
• 4 Demo Scenes
• 3 Shaders

Skog is built for the Universal Render Pipeline (URP). HDRP and Built-in are not supported.

Unity Version

• Unity 6 / 2023 LTS or later
• Render Pipeline: Universal Render Pipeline (URP)

This pack includes trees, bushes, rocks, mushrooms and more to help you quickly populate your Unity scenes with foliage.

All foliage assets are tintable, enabling hundreds of variations from a small core set. The included shaders support:

• Wind animation
• Splatmap tinting
• Random per-instance tinting
• Slope-based effects for adding snow or moss

Most assets include LODs and billboards. All foliage uses one material per object and is GPU Instancing–compatible for high performance.

Key Features -

Momentum-based movement system

Smooth walking, sprinting, and directional speed control

Configurable jumping with forward momentum

Toggleable crouch with smooth height transitions

Camera FOV sprint effects

Camera landing dip

Head-bob system with adjustable frequency and amplitude

Clean, well-organized code

Uses Unity CharacterController (no Rigidbody required)

No external dependencies

Easy plug-and-play setup

Customization

All movement values adjustable from the Inspector

Optional features can be enabled/disabled via toggles

Suitable for both prototyping and full production projects

Supported Platforms -

Windows

macOS

Linux

(Works on any platform supported by Unity CharacterController)

Unity Version -

Unity 2022.3 LTS and newer recommended

Documentation -https://drive.google.com/file/d/1cJN12Ry2Tqf3jfeMqaRqIgzpozn94qNv/view?usp=sharing

Momentum FPS Controller is a lightweight, plug-and-play first-person character controller designed for smooth, responsive, momentum-based movement.

It features configurable walking, sprinting, jumping, crouching, camera effects, and head-bob, all built on Unity’s CharacterController for stability and ease of use. The system focuses on clean motion, natural acceleration, and player control without relying on rigid animations or physics-based hacks.

The controller is highly customizable via the Inspector and requires no coding to set up or tweak. It is suitable for a wide range of genres including:

First-Person Shooters (FPS)

Fast-paced action games

Parkour and movement-focused games

Prototypes and gameplay demos

A demo scene is included to showcase all features in action.

Key Features:

• 10 Unique Color Variants: Pre-configured prefabs including Red, Blue, Green, Cyan, Yellow, Pink, Purple, Orange, Black, and White.
• High-Quality Models: Smooth, detailed silhouettes optimized for PC, Console, and High-end Mobile platforms.
• URP Native: Built specifically for the Universal Render Pipeline (URP) to ensure the best performance and visual results.
• Professional Organization: Clean folder structure with an included Demo Scene and documentation for a smooth, plug-and-play workflow.

Specifications:

• Triangle Count: ~8,284 Tris per potion bottle (Total).
• Texture Resolution: 2,048 x 2,048.
• Texture Maps: Includes Base Map (Albedo), Metallic Smoothness, and Normal Map.
• Number of Prefabs: 10.
• Render Pipeline: Universal Render Pipeline (URP).

The MiracleArt Potion Pack provides developers with a collection of high-quality stylized assets featuring smooth silhouettes and crystal-clear details. Perfect for fantasy RPGs, these assets are designed for close-up interactions where visual fidelity and aesthetic appeal are key.

Key Highlights:

• Highly Customizable: Easily create endless color variations by duplicating materials and adjusting the Base Map color to suit your game's needs.
• Smooth Visual Fidelity: With a focus on clean geometry, the liquids and bottles maintain a perfectly round and polished look even when viewed from very close distances.
• Genre Versatility: While ideal for Fantasy and RPG settings, the clean, stylized art style also fits beautifully in casual, mobile, or puzzle games.

- Editor only - zero runtime overhead

- Full source code included

- No dependencies

- Works with all render pipelines

- Data saved to ProjectSettings folder

- JSON format for easy backup

Todo List Pro is a simple task manager built right into Unity Editor.

The Problem:

Switching between Unity and external task apps breaks your flow. Notes get lost. Tasks pile up.

The Solution:

Todo List Pro keeps your tasks inside Unity, right where you work.

Task Management:

- Add tasks with one click

- Edit inline - no popups

- Mark complete with checkbox

- Delete individual or clear all done

Organization:

- Priorities - High (red), Medium (yellow), Low (green)

- Categories - Bug, Feature, Task, Art, Code, Audio, UI, Other

- Due Dates - With overdue highlighting

- Descriptions - Add notes to any task

Visibility:

- Progress Bar - See completion percentage

- Color Coding - Spot priorities instantly

- Search - Find tasks fast

- Filters - By priority, category, status

Data:

- Auto-Save - Never lose tasks

- Per-Project - Each project has own list

- JSON Format - Version control friendly

- Portable - Copy between projects

Perfect For:

- Solo developers

- Small teams

- Game jams

- Daily task tracking

- Bug tracking

Requirements:

- Unity 2021.3 or newer

- Editor only

- Editor only - zero runtime overhead

- Full source code included

- No dependencies

- Works with all render pipelines

- Windows: Full registry support

- Mac/Linux: Basic support

Prefs Editor Pro gives you full control over Unity's PlayerPrefs directly in the Editor.

The Problem:

Unity provides no built-in way to view or edit PlayerPrefs. You're debugging blind.

The Solution:

Prefs Editor Pro shows all your saved preferences in a clean, organized interface.

Core Features:

- View All Prefs - See every key and value at a glance

- Edit Inline - Click to modify any value instantly

- Add New - Create int, float, or string prefs

- Delete - Remove individual keys or clear all

- Search - Filter by key or value name

- Sort - By key, type, or value

Visual Features:

- Type Colors — Blue for int, green for float, orange for string

- Stats Bar — Total count and breakdown by type

- Alternating Rows — Easy to read lists

Data Management:

- Export to JSON - Backup all prefs to file

- Import from JSON - Restore or share configurations

- Copy to Clipboard - One-click value copying

Play Mode:

- Auto-Refresh - See values update in real-time

- Live Editing - Change values during gameplay

Perfect For:

- Debugging save systems

- Testing different configurations

- QA and bug hunting

- Development cheats (set health, unlock levels)

Requirements:

- Unity 2021.3 or newer

- Windows, Mac, or Linux Editor

- Editor window - zero runtime impact

- Full source code included

- No dependencies

- Works with all render pipelines

- Helper class works in builds

- Settings persist between sessions

Console Pro is a powerful replacement for Unity's built-in Console window.

Why Console Pro?

Unity's default console is basic. Finding specific logs in a wall of text wastes time. Console Pro brings colors, organization, and powerful filtering to your debugging workflow.

Core Features:

- Colored Logs - Gray for info, yellow for warnings, red for errors

- Tag System - Use [Tag] prefix to categorize logs

- Tag Filtering - Dropdown to show only specific tags

- Search - Find text with yellow highlighting

- Timestamps - See exactly when each log occurred

- Collapse - Group identical messages with count

- Auto-Scroll - Always see newest logs

Productivity Features:

- Export Logs - Save to text file for bug reports

- Click to Open - Double-click to jump to source code

- Adjustable Font - Resize for readability

- Resizable Panels - Drag splitter to customize layout

- Clear on Play - Auto-clear when entering Play mode

- Pause on Error - Stop game when error occurs

ConsolePro Helper Class:

- Easy logging: ConsolePro.Log("message")

- Tagged logging: ConsolePro.LogCombat("hit!")

- 18 preset tags: Combat, UI, Network, AI, Player, Save, and more

- Conditional logging: ConsolePro.LogIf(condition, "msg")

- Performance timing: ConsolePro.LogTimed("label", action)

Perfect For:

- Large projects with many systems

- Team debugging

- Bug tracking and reports

- Performance profiling

Requirements:

- Unity 2021.3 or newer

- Editor window (no runtime overhead)

Features:

• Manager: ProgressionManager (Singleton, generic-safe).
• Math: Strategy Pattern implementation for custom curves.
• Events: Observer Pattern (IProgressionListener) for zero-coupling UI updates.
• Assembly Definitions: Included (AlkirenGames.LevelUpEngine.Runtime & Editor) to speed up compilation and prevent namespace pollution.
• Testing: Includes Editor Tests (NUnit) for validating math logic.

Compatibility:

• Works with Built-in, URP, and HDRP (Logic only).
• No external DLL dependencies.
• Namespace: AlkirenGames.LevelUpEngine.

Stop writing spaghetti code for your Leveling System.

The LevelUp Engine is a professional, architecture-first solution for managing Experience, Levels, and Progression. Built by a Senior Software Engineer, it replaces messy Update() loops and hardcoded math with a clean, Event-Driven architecture.

Why use this?Most assets force you to use their UI or rigid systems. This engine is "Headless" and modular. It handles the math and state, then emits clean Events (OnLevelUp, OnXpGained) that your game listens to.

Core Features:

• 🛡️ Senior-Grade Architecture: Built on the Observer and Strategy patterns.
• 📈 3 Built-in Math Curves: Linear: Standard progression. Exponential: Gets harder as you level (Level^2). MMO: The classic "Runescape" curve (Compounding 20%).
• 🔌 Drop-in Inspector: Switch difficulty curves via a simple dropdown. No coding required.
• 🧪 Unit Tested: Includes NUnit tests verifying the math logic so you don't have to.
• 🚀 Zero Bloat: Pure C# logic. No heavy textures or unnecessary dependencies.

What's Included:

• ProgressionManager (Singleton)
• Demo Scene (Plug-and-play example)
• Full Source Code (Assembly Defs included)
• Documentation & Unit Tests

Perfect for: RPGs, MMOs, Shooters, and any game needing a robust progression backend.

Number of textures:

6

Texture dimensions:

2048x2048

Polygon count of:

Coin1: Verts: 364 | Faces: 156 | Tris: 724

Coin2: Verts: 704 | Faces: 236 | Tris: 1404

Coin5: Verts: 2010 | Faces: 1078 | Tris: 4016

Minimum polygon count:

724

Maximum polygon count:

4016

Number of meshes/prefabs

3 prefabs

Rigging: No

Animation count:

No animation included

Animation type list:

None

UV mapping:

Yes

LOD information (count, number of levels):

Only one. Original for all

Types of materials and texture maps (e.g., PBR):

Normals and BaseColors with UV wrapping.

Coins don't need to be set up. You can just drop in a pre-color and they'll appear on the stage. However, ridigibodies, tags, and scripts need to be added separately as needed. 

Main Genres
RPG and Action RPG: Ideal for currency systems, boss loot, treasure chests, and equipment shops – for example, in games like Skyrim or The Witcher.
Roguelike and Dungeon Crawler: Coins as rewards for peace, scattered throughout dungeons for immersion during exploration.
Strategy and Survival: Trading resources, bartering in settlements, or piling gold in bases – suitable for games like RimWorld or medieval crafting sims.

⚠️ PREREQUISITE: NodeCanvas by ParadoxNotion (sold separately) This asset generates NodeCanvas Behavior Trees and will not function without NodeCanvas installed. 

 KEY FEATURES 

- Natural Language Input — Describe behaviors in plain English 

- NodeCanvas Integration — Creates native NodeCanvas BT assets 

- Local AI Processing — Uses Ollama for offline, private inference 

- No Recurring Costs — One-time purchase, no API fees 

- Fast Generation — 3-20 seconds depending on complexity 

- Automatic Blackboard Setup — Generates variables with correct types 

- Production-Ready Output — Generates Selectors, Sequences, Decorators, Actions  

SUPPORTED NODECANVAS NODES 

- Composites: Selector, Sequencer, Parallel 

- Actions: MoveTo, Wait, RotateTowards, and custom actions 

- Decorators: Loop, Cooldown, Timeout, Conditional 

- Blackboard Variables: Bool, Float, Vector3, GameObject, etc.  

REQUIREMENTS 

- NodeCanvas 3.x+ (REQUIRED - not included) 

- Unity 2022.3 LTS or Unity 6+ 

- Ollama (free from ollama.ai) 

- GPU: 4GB+ available VRAM (or CPU with 16GB RAM) 

- Editor only: Windows, macOS, Linux  

WHAT'S INCLUDED

 - BehaviorForge Editor Window 

- Complete C# source code 

- Documentation & quick start guide - Sample behavior descriptions 

- Discord community access

𝗥𝗘𝗤𝗨𝗜𝗥𝗘𝗦 𝗡𝗢𝗗𝗘𝗖𝗔𝗡𝗩𝗔𝗦

BehaviorForge generates assets for NodeCanvas by ParadoxNotion. You must own NodeCanvas (sold separately) to use this tool. → Get NodeCanvas: https://assetstore.unity.com/packages/tools/visual-scripting/nodecanvas-14914

KEY FEATURES

- Natural Language Input — Describe behaviors in plain English

- Complete Asset Generation — Creates Behavior Tree + Blackboard assets

- Local AI Processing — Uses Ollama for offline, private inference

- No Recurring Costs — One-time purchase, no API fees or subscriptions

- Production-Ready Output — Generates Selectors, Sequences, Decorators, Tasks, Services

- Fast Generation — 3-20 seconds depending on complexity

- Multiple Model Support — Works with 3B models (most GPUs) or 7B (high-end GPUs)

- Automatic Blackboard Setup — Generates keys with correct types (Bool, Vector, Object, etc.)

- JSON Intermediate Format — Debug, inspect, or manually edit before asset creation

- Editor Window Integration — Clean UI inside Unity Editor

SUPPORTED NODES

- Composites: Selector, Sequence, Parallel

- Tasks: MoveTo, Wait, RotateToFace, MakeNoise, PlaySound

- Decorators: Loop, Cooldown, TimeLimit, Blackboard Conditions

- Services: DefaultFocus, custom service support

TESTED BEHAVIORS

✓ Patrol between waypoints

✓ Chase player when seen

✓ Investigate noises and return

✓ Flee when health low

✓ Collect items and return to base

✓ Follow leader, assist in combat

✓ Random wander with cooldowns

✓ Multi-phase boss behaviors

✓ Stealth detection states

✓ Squad coordination

REQUIREMENTS

- Unity 2022.3 LTS or newer (Unity 6 supported)

- Ollama (free download from ollama.ai)

- GPU: 4GB+ available VRAM recommended

- Disk: 2-5GB for AI model

- Platforms: Windows, macOS, Linux (Editor only)

⚠️ IMPORTANT: This asset requires NodeCanvas by ParadoxNotion. BehaviorForge will not function without it. Please ensure you own NodeCanvas before purchasing.

WHAT'S INCLUDED

- BehaviorForge Editor Window

- Complete C# source code

- Documentation & quick start guide

- Sample behavior descriptions

- Discord community access: https://discord.gg/nJqDGWmw

Number of VFX Graphs: 40 

Number of VFX Prefabs: 40 

Number of Materials: 20 

Number of Shadergraphs: 6

💻 Supported Development Platforms

💻 Windows: (Yes) | 🍎 Mac: (Yes)

🕹️PLAYABLE DEMO MAP / 📖DOCS

🔥 Unity Fire VFX – The Best In The Asset Store!

Built for high-end Unity projects, this AAA-quality Fire VFX Pack delivers realistic flames, embers, sparks, smoke, and dynamic lighting that hold up in close-ups, cinematics, and real-time gameplay. Its fully modular system lets you easily create anything from small ambient fires to massive wildfires and destruction scenes with natural, non-repetitive results. Perfect for realistic, fantasy, and action-driven environments.

🔥Features🔥

• 🔥 Highly realistic fire visuals suitable for AAA games

Physically believable flame motion, embers, sparks, smoke, and light response designed to hold up in closeups, cinematics, and gameplay. Works for grounded realism, dark fantasy, and high intensity scenes.

• 🔥 Fully modular large scale fire system

Large fires are built from modular fire elements that can be mixed, duplicated, and layered to create massive wildfires, burning fields, ruins, or destruction scenes. Build organic, non repetitive fire layouts instead of relying on a single effect.

• 🔥 Exposed VFX parameters for deep customization

All fire systems include user friendly parameters such as fire scale, velocity, ember spawn rate, glow strength, light radius, light intensity, refraction strength, and more. Quickly tune effects without touching VFX graphs.

• 🔥 Wind influence system ready for weather integration

Fire reacts to multi directional wind via exposed VFX parameters. Flames bend naturally based on wind strength and direction and can be plugged directly into dynamic weather systems.

• 🔥 Multiple fire intensity levels per effect

Many effects include built in low, medium, and high intensity variants. Reuse the same fire type for smoldering ruins, active fires, or full infernos.

• 🔥 Wide variety of fire types included

Includes large scale ground fires and wildfires, campfires, torches, torch clusters, fire braziers, fireplaces, candles, and fire bursts including character engulf effects.

• 🔥 Magical fire variants with full color control

Includes magical torch fire with adjustable color and scale plus preset magical variants such as green wildfire, arcane flame, and shadow style flames for fantasy and RPG projects.

• 🔥 Texture based fire spawning for symbols and shapes

Drive ground fires using any 2D texture or alpha map. Create flaming symbols, magic circles, pentagrams, ritual patterns, or custom shapes simply by swapping a texture.

• 🔥 Vertex painted fire and material overlays

Use vertex painting to place fire particles and fire material overlays exactly where needed on meshes such as barrels, props, walls, or debris for precise artistic control.

• 🔥 Seamless environment integration

Fire effects sit naturally on terrain, rocks, architecture, props, and characters, ensuring grounded placement with no floating or disconnected visuals.

• 🔥 Dynamic fire lighting built in

Fire emits dynamic light that scales with intensity, adding realistic illumination to caves, ruins, interiors, and nighttime scenes without extra setup.

• 🔥 Performance conscious VFX setups

Designed to scale from small ambient fires to massive scenes by adjusting parameters and intensity levels while keeping performance under control.

• 🔥 Ready to use presets plus modular building blocks

Includes polished drop in presets for common use cases along with modular components for artists who want full control and custom fire assemblies.

DISCLAIMERS

*Scene on the renders is for demonstration purposes only!

*Supports HDRP and URP.

*Built-In Render Pipeline is not supported.

SaveSmart Easy is a schema-first save system for Unity.

Define your save data in the editor, generate typed C# accessors, and save game data without string keys, boilerplate, or manual serialization. SaveSmart Easy includes a built-in Save File Editor (Play Mode Supported) that lets you inspect and modify save data directly as raw JSON.

Designed for indie, VR, and mobile games that need a clean, reliable local save solution.

Documentation

🟩 What is SaveSmart Easy?

// Loads from memory

using SaveSmartEasy;

int coins = SaveSmart.SaveData.Coins;

Color themeColor = SaveSmart.SaveData.ThemeColor;

int[] levelScores = SaveSmart.SaveData.LevelScores;

List<int> scoreList = SaveSmart.SaveData.ScoreList;

// Saves to disk immediately

using SaveSmartEasy;

SaveSmart.SaveData.Coins += 100;

SaveSmart.SaveData.ThemeColor = Color.red;

SaveSmart.SaveData.LevelScores = new int[] { 10, 20, 30 };

SaveSmart.SaveData.ScoreList.Add(100);

That’s it. Typed, cached, and automatically stored as JSON.

// Key-based get/set also works

string username = SaveSmart.GetString("Username");

SaveSmart Easy is a lightweight, schema-first save manager for Unity.

Instead of scattering string keys across your codebase, you define your save schema once in an editor tool. SaveSmart Easy then generates typed C# accessors, so you can read and write save data using normal properties with full IntelliSense support.

No manual serialization. No typo-prone keys. No fragile glue code.

🟩 Core Design Philosophy

Schema first, code second

• Define all save fields in one place.
• Generate strongly typed accessors automatically.
• Use simple property assignments to save data.
• Keep gameplay code clean and safe from string-based errors.

This approach scales better than PlayerPrefs and stays far simpler than full custom serialization systems.

🟩 Key Features

🟥 Schema-First Workflow

• Centralized Definition: Define all save fields in a dedicated editor window to keep your data organized.
• Robust Editor Tools: The schema editor supports full Undo/Redo, reordering, and field comments for a developer-friendly experience.
• Automatic Code Generation: Generate typed C# accessors instantly, eliminating boilerplate and manual serialization.

🟥 Type Safety & IntelliSense

• No More Typos: Replace fragile string keys like PlayerPrefs.SetInt("HihgScore") with strongly-typed properties.
• Full Autocomplete: Access your data via SaveSmart.SaveData.YourVariableName with full IntelliSense support and compile-time safety.
• Hybrid API: While property-based access is recommended, traditional key-based APIs (e.g., GetInt, SetString) remain available for dynamic use cases.

🟥 Designed for Performance and Simplicity

• In-Memory Caching: Save data is loaded once and cached per slot, ensuring subsequent reads are instant and never block your gameplay.
• Immediate Persistence: Each write updates both the memory cache and the disk automatically, ensuring data safety without requiring manual save calls.
• Optimized for Indie & VR: Designed specifically to provide a clean, reliable, and lightweight storage solution for mobile and VR platforms.

🟥 Flexible Storage & Security

• Multiple Save Slots: Easily manage multiple saves (e.g., save1.json, save2.json) with simple APIs to switch or clear slots.
• Readable JSON: Files are stored as standard JSON under Application.persistentDataPath for easy debugging and inspection.
• Optional Encryption: Includes built-in AES-based encryption to deter casual save editing and protect player progress. This is intended as basic protection, not security-grade encryption.
• Cloud Ready: Use built-in APIs to read or write Raw JSON, making it simple to sync local data with backends or cloud providers.

🟩 In-Editor Save File Editor (Play Mode Supported)

This tool works even while the game is running (Play Mode), making it ideal for rapid testing and debugging without restarting the game.

• Quickly switch between existing save slots (SaveData1.json, SaveData2.json, etc.).Save Slot Selection
  
• Re-read the file from disk to reflect changes written by the game at runtime.Reload From Disk
  
• JSON is automatically formatted and ordered based on your schema for readability.Direct JSON Editing
  Edit save values directly in a text editor.
  
• The running game sees the updated values instantly.Safe Save & Hot Reload
  JSON is validated before saving.
  Changes are written to disk and the in-memory cache is updated immediately.
  
• Open the save folder directly in the system file manager for inspection or backup.Reveal in File Explorer
  

Typical Use Cases

• Test different save states during gameplay (e.g. set CurrentStage = 5).
• Debug progression, unlocks, or checkpoints without replaying content.
• Inspect or repair corrupted or partial save files.
• Verify cloud sync or encryption behavior by inspecting decrypted JSON.

🟩 Supported Data Types

• Primitive Types: Int, Long, Float, Double, Bool, String.
• Unity Types: Vector2, Vector3, Color, Color32, Quaternion, Rect.
• Standard Types: DateTime.
• Array Variants: Supports all types above (e.g., IntArray, Vector3Array, Color32Array, etc.).
• List Variants: Produces List<T> properties for all types above (e.g., IntList, QuaternionList, DateTimeList, etc.).
• Custom Objects: For complex data structures, use a String field to store JSON strings via JsonUtility or other JSON libraries.

🟩 Typical Use Cases

Well suited for:

• Game settings
• Player progress and checkpoints
• Unlocks and achievements
• Single-player or local save systems
• Indie, VR, and mobile games

Not intended for:

• Massive live-service architectures
• Per-frame telemetry logging
• Server-authoritative MMO save pipelines

🟩 Performance Notes

• Reads are served from memory after the first load.
• Each write persists immediately to disk.
• Avoid writing every frame or inside tight loops.

This design favors data safety and simplicity over ultra-high-frequency write scenarios.

🟩 Why Resources?

The schema config asset is saved and loaded from a Resources folder by design, ensuring predictable availability across all platforms.

• Used only for loading the schema
• Loaded once and cached
• No Addressables required
• No runtime asset modification

The config is a ScriptableObject, stored as a .asset file and persisted with your project.

🟩 Unity Version

• Unity 2020.3 or later (LTS recommended)

LayoutGuides Easy is a Unity Editor-only tool that brings the familiar alignment experience from Canva, Figma, and Photoshop into the Unity Editor.

Up to 10× faster layout iteration for common alignment tasks.

It adds layout guides and smart snapping for both UI and 3D objects, helping designers align elements faster and more accurately.

The tool is performance-optimized and only adjusts object positions. It automatically disables itself in Play mode, ensuring zero runtime impact on your game.

Documentation

Key Features

Editor-Only & Performance-Optimized

Runs entirely in Edit mode and automatically disables itself in Play mode, ensuring zero runtime impact.
Only object positions are adjusted. Rotation, scale, and all other properties remain untouched.

Zero Setup Required

Simply add the LayoutGuidesEasy component to a parent object and it works instantly with all child elements.
No additional setup, no components required on children. Smart guides, snapping, and alignment are available immediately.

Manual Guides

Create and drag layout guides for X, Y, and Z axes in both UI and 3D scenes.
Guides can be locked to prevent accidental movement and customized with different colors and line styles.
In 3D mode, guides appear as semi-transparent planes and can be hidden until snapping occurs.

Center Snap Between Guides
When two manual guides exist on the same axis, objects can snap precisely to the center between them.
Supports X, Y, and Z axes, with simultaneous multi-axis center snapping (for example, X and Y at the same time).

Visual Snap Feedback

Provides clear visual feedback with an outline glow when an object is within snapping range.
This makes snapping behavior predictable and easy to understand while positioning objects.

Smart Guides

Smart guides appear automatically while dragging objects.

• UI elements: 9-point alignment (left, center, right, top, middle, bottom)
• 3D objects: Border-to-border snapping on all axes

Guides are displayed only between the objects being aligned, keeping the Scene view clean.

Equal Spacing

Detects evenly spaced groups of three or more objects and displays spacing indicators.
Helps maintain consistent spacing across all axes during layout adjustments.

Distance Display

Displays real-time distance values between objects when their bounds overlap on one axis.
Inspired by distance indicators in tools like Canva and Figma.
Text and background colors are fully customizable.

Multi-Mode Support

Fully supports:

• Canvas render modes: Screen Space Overlay, Screen Space Camera, World Space
• Standard 3D objects using Renderer or Collider bounds

Why LayoutGuides Easy?

Unity’s built-in tools are powerful but can be slow for precise layout work.

LayoutGuides Easy focuses on clear visual feedback, fast iteration, and designer-friendly workflows, making object alignment feel natural and intuitive.

Perfect for:

• UI menus, HUDs, and responsive layouts
• Level blockouts and prop placement
• Designers and solo developers who want faster iteration

A must-have editor tool for UI and level designers who want fast, precise alignment in Unity.

Not a Runtime Layout System.

LayoutGuides Easy focuses exclusively on Edit Mode alignment workflow with smart guides and visual snapping inspired by Canva, Figma, and Photoshop.

Requirements

• Unity 2020.3 or later
• Editor-only tool (no impact on builds)

ButtonAnimator Easy: Elegant, Precise, and High-Performance uGUI Animations

"Drag, Drop, Done." UI animation shouldn't be complicated.

ButtonAnimator Easy is a powerful, lightweight animation system designed specifically for Unity uGUI. By moving away from complex Animator Controllers and State Machines, we provide an intuitive Preset-first system that lets you breathe life into your UI in seconds.

Documentation

Why Choose ButtonAnimator Easy?

• The Ultimate VR Companion: Uses Base Scale Caching to keep a stable scale reference for UI interaction, significantly reducing Raycast instability issues in World Space Canvases commonly caused by scale animations in VR.
• LayoutGroup Compatible: Automatically generates a __BAE_Anim Wrapper to handle position animations flawlessly without breaking Horizontal, Vertical, or Grid Layout systems.
• Performance Optimized: Designed for VR high-frame rates (90/120 FPS), the Update loop performs only a minimal boolean check, ensuring near-zero CPU overhead.
• Advanced Color Control: Automatically detects and animates multiple components simultaneously, including the Button Background, Icon, and TextMeshPro labels.
• Flexible Override Logic: The Local Override system allows you to maintain global visual consistency via Presets while fine-tuning specific parameters for individual buttons.
• Built-in Spatial Audio: Trigger 3D spatial sound effects at the button’s exact world position without the need to manually manage AudioSource components.

Core Features

Animation System:

• No coding required - Everything can be done in the Unity Inspector
• Preset-first design - Use high-quality ScriptableObject presets or create your own
• Local Override system - Override specific animation parameters without breaking preset updates
• Three animation states - Hover, Click, and Disabled animations
• DOTween-powered - Fast and efficient animations using DOTween

Audio System:

• Built-in audio support - Play sound effects on Hover and Click events
• Preset audio settings - Configure audio clips and volumes in presets
• Per-button audio override - Override audio settings for individual buttons
• No AudioSource required - Uses AudioSource.PlayClipAtPoint for simple setup
• VR spatial audio positioning - Sounds play at the button's world position, providing accurate 3D spatial audio localization for VR applications

Preset System:

• Many presets included - Organized by physical properties: Scale, Position, Rotation, Color & Alpha, Compound & Special, Punch, and Shake
• Easy preset switching - Change presets without losing local overrides
• Re-Apply functionality - Reset to preset values with one click

Editor Integration:

• Custom Inspector - Beautiful, intuitive UI with status indicators
• Preview system - Test Hover, Click, and Disabled animations without entering Play Mode
• Override toggle - Easy switching between Preset and Local Override modes
• DOTween dependency checker - Automatic detection and setup guidance

Runtime Features:

• Automatic interactable handling - Disabled animations trigger automatically when Button.interactable = false
• LayoutGroup compatible - Base scale caching prevents layout issues
• CanvasGroup support - Automatically adds CanvasGroup when alpha animations are needed, prioritizes CanvasGroup.alpha over Graphic.color.a
• Button transition management - Automatically sets Button.transition to None to prevent conflicts
• Multi-touch safe - Independent Tween IDs per state prevent conflicts
• TimeScale independent - Animations work correctly in pause menus
• Debug mode - Optional detailed debug logging for troubleshooting

Design Philosophy

ButtonAnimator Easy is built on three core principles that guide every design decision:

• Preset-first - Design animations once, reuse everywhere. Instead of customizing each button individually, create presets that can be shared across multiple buttons, ensuring visual consistency and rapid iteration.
• Inspector-driven - No Animator Controllers, no state machines, no code. Everything is configured directly in the Unity Inspector, making UI animations accessible to designers and developers alike without the complexity of traditional animation systems.
• Safe-by-default - Animations never break your UI layout or interfere with game time. Base scale caching prevents LayoutGroup issues, and TimeScale-independent animations ensure buttons work correctly even in pause menus.

When to Use / When Not to Use

Good For

• uGUI Button - Designed specifically for Unity's legacy UI system (uGUI)
• Mobile, PC, and VR UI - Works across all platforms that support uGUI
• World Space Canvas - Fully compatible with World Space Canvas for VR applications. Base Scale Caching ensures precise Raycast detection even during scale animations, solving a common issue where other uGUI plugins cause Raycast to break when button scale changes. All animations (Scale, Position, Rotation, Color, Alpha) function correctly regardless of Canvas Render Mode.
• Projects requiring quick consistent animation styles - Preset system enables rapid UI animation setup with consistent visual language

Not Suitable For

• UI Toolkit (UIElements) - ButtonAnimator Easy is built for GameObject-based uGUI, not the newer UI Toolkit system
• UI deeply bound to Animator Controller - If your UI animations are already tightly integrated with Unity's Animator system, this tool may conflict or be redundant

Features:

• Editor-Only Tool: Zero runtime overhead in your final build.
• Code Architecture: Fully namespaced (SOEvolver) and uses Assembly Definitions (.asmdef) to separate Editor logic from Runtime data.
• Migration Runner: Handles sequential chaining (e.g., automatically running V0→V1, then V1→V2).
• Backup System: Stores backups in the project's Library/ folder to avoid cluttering version control, with options to restore specific batches.

Requirements:

• Unity Version: 2022.3 (LTS) or higher recommended.
• Compatibility: Works with standard ScriptableObjects, Addressables, and Asset Bundles.
• Scripting: Requires .NET Standard 2.0 or 2.1 API Compatibility Level.

Files:

• Includes full C# source code (No DLLs).
• Includes Documentation in Notion.

Never lose data when refactoring ScriptableObjects again.

Unity's serialization is powerful but unforgiving. If you delete a field from your script before migrating the data, that data is lost forever. If you work on a team, changing shared data structures often leads to merge conflicts.

SO Evolver solves these problems by adding explicit version control and a safe migration framework to your ScriptableObjects.

KEY FEATURES

• Explicit Versioning: Assets track their own schema version (V0 → V1 → V2).
• Safety First: Automatic timestamped backups are created before every migration.
• Dry Runs: Preview exactly what will change in a log report before modifying files.
• One-Click Restore: Undo mistakes instantly from the dashboard using the backup history.
• Audit Logs: Keeps a complete history of all migrations in your project logs.
• Team-Friendly: Uses a linear versioning model to prevent merge conflicts.
• Batch Operations: Migrate hundreds of assets in a single click.

THE WORKFLOW

1. Inherit: Change your class to inherit from VersionedScriptableObject.
2. Modify: Add new fields to your script (keeping the old ones temporarily).
3. Migrate: Write a simple C# migration script to map old data to new data.
4. Execute: Use the SO Evolver Window to Dry Run and apply changes to all assets.
5. Clean: Safely delete the old fields from your script.

PACKAGE INCLUDES

• Migration Dashboard (Editor Window)
• Core Base Classes (VersionedScriptableObject, SOMigration)
• Automatic Backup & Restore Systems
• Comprehensive Documentation (Quickstart, Safe Workflow, API Reference)
• 10+ Real-world Migration Examples

If you find this tool useful, please leave a review! It helps me add new features.

⭐ KEY FEATURES

Key Features (FR)

• Génération automatique de structures adaptées (Débutant → Avancé)
• Scanner intelligent : dossiers manquants, vides, inconnus
• Protection avancée contre les suppressions accidentelles
• Suppression sécurisée avec double confirmation
• Presets personnalisables et exportables
• Interface claire, thème clair/sombre
• Compatible avec tous les pipelines Unity
• Aucun package externe requis ✨

Key Features (EN)

• Automatic structure generation (Beginner → Advanced)
• Smart scanner: missing, empty, unknown folders
• Advanced protection against accidental deletion
• Safe deletion with double confirmation
• Customizable and exportable presets
• Clean UI with light/dark theme
• Compatible with all Unity pipelines
• No external dependencies ✨

⭐ REQUIREMENTS (FR/EN)

Requirements (FR)

• Unity 2021.3 ou version supérieure
• Compatible Windows, macOS et Linux
• Fonctionne avec tous les Render Pipelines (Built‑in, URP, HDRP)
• Aucun package additionnel nécessaire

Requirements (EN)

• Unity 2021.3 or higher
• Compatible with Windows, macOS and Linux
• Works with all Render Pipelines (Built‑in, URP, HDRP)
• No additional packages required

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

⭐ CATEGORY & INTENDED USERS (FR/EN)

Pour qui ? (FR)

Conçu pour les débutants qui veulent un projet propre dès le départ, et pour les développeurs professionnels cherchant un workflow rapide, fiable et organisé.

Who is it for? (EN)

Designed for beginners who want a clean project from day one, and professional developers who need a fast, reliable and organized workflow.

⭐ P.S.A Project Structure Assistant

Description :

Project Structure Assistant PRO , est un outil conçu pour offrir une organisation claire, professionnelle et évolutive à vos projets Unity. Il génère automatiquement des structures adaptées à votre niveau, analyse votre projet grâce à un scanner intelligent, protège vos dossiers sensibles et vous permet de créer vos propres presets. Interface soignée, thème clair/sombre, workflow simplifié et projet toujours propre. Un assistant pensé pour les développeurs exigeants. ✨

Description :

Project Structure Assistant PRO , is designed to bring clean, professional and scalable organization to your Unity projects. It automatically generates structures based on your level, scans your project with a smart analyzer, protects sensitive folders and lets you create custom presets. Polished interface, light/dark theme, streamlined workflow and consistently clean project structure. A tool built for developers who want efficiency and clarity. ✨

- Editor only - zero runtime overhead

- Full source code included

- No dependencies

- Works with all render pipelines

- Instant setup - no configuration required

- Settings persist across sessions

Hierarchy Enhancer Pro transforms your Unity Hierarchy window into a powerful, organized workspace.

Why Hierarchy Enhancer Pro?

Large projects become messy fast. Finding objects in a sea of gray text wastes time. Hierarchy Enhancer Pro brings color, structure, and clarity to your workflow.

Visual Organization:

- Separators - Create visual dividers with "---" prefix

- Headers - Colored section titles with "#" prefix

- Color Rules - Auto-color objects by tag, layer, name, or component

- Alternating Rows - Easier to scan long lists

Information at a Glance:

- Component Icons - See attached components instantly

- Active Indicator - Spot inactive objects immediately

- Static Indicator - Identify static objects for optimization

- Tree Lines - Visual parent-child connections

Fully Customizable:

- Every color adjustable

- Enable/disable any feature

- Custom prefixes for separators and headers

- Unlimited color rules

Zero Setup Required:

- Import and it works immediately

- No configuration needed

- Settings window for customization

Color Rules Support:

- Tag matching (Player, Enemy, etc.)

- Layer matching (UI, Water, etc.)

- Name contains text

- Name starts with text

- Has specific component

Perfect For:

- Large projects with many objects

- Team collaboration

- Level designers

- Anyone who values organization

Requirements:

- Unity 2021.3 or newer

- Editor only (no runtime impact)

It is not necessary to import the demo from this bundle. It is a modified version of sample

scene from Mossy Cedrus Forest to merge all packages in a single level.

Join SeedMesh Discord Server!

This product may not be used in datasets for, in the development of, or as inputs to generative AI programs.

All these products have a value of $160, get a discount of -$20 for buying all thogether.

The assets are high quality with 4K textures (the resolution can be adjusted by the developer manually) and optimized with many LODs, this way the assets are usable for a wide range of projects, from optimized games to high fidelity visualizations.

Check the complete details visiting the page of each package.

List of Assets:

• Mossy Cedrus Forest
• Forest Oak Trees
• Realistic Mushrooms Scans
• Forest Moss Scan
• Wild Ivy

Purchasing this bundle will unlock access to the products listed above from the Unity asset store.

• Render Pipeline: Universal Render Pipeline (URP)
• Models:  
• - Custom-made, stylized assets  
• - Optimized for real-time use  
• LOD Groups:  
• - Included only for the tree asset  
• Textures:  
• - Base Color  
• - Normal Map  
• - Optimized texture sizes  
• Materials:  
• - Simple URP-compatible materials  
• - Easy to customize  
• Animations:  
• Tree and foliage includes wind animation using vertex movement
• Includes a particle system for falling leaves, ready to use
• Aquatic plants are static by design
• Wind animation was intentionally not applied, as it does not make sense for water vegetation
• Water-based animation was left for users who want to customize it for their own systems
• Effects:  
• - Lightweight particle system for falling leaves  
• Prefabs:  
• - Ready-to-use prefabs with scale set to (1,1,1)  
• Scale:  
• - Assets are created using real-world scale reference  
• - Scene scale can be adjusted freely without affecting prefabs  
• Compatibility:  
• - Unity version: 6.1  
• - Render Pipeline: URP only  
• Intended use:  
• - Stylized games  
• - Prototypes  
• - Real-time environments

The Stylized_Tree_and_Foliage_Bog is a stylized environment asset pack designed for real-time projects in Unity (URP).

This package includes optimized tree and foliage assets built with performance in mind, featuring tree LOD levels to ensure smooth rendering across different distances and hardware targets.

The assets include simple wind animation for foliage movement and a lightweight particle system for falling leaves, adding subtle life to the environment while keeping performance costs low. All materials are simple and optimized, focused on base color, making them easy to integrate, customize, and extend inside your own projects.. Prefabs are ready to use — just drag and drop into your scene.

This pack is ideal for stylized games, prototypes, and real-time environments where visual clarity and performance are essential.