Asset Store newest packages

Technical Details

• Unity version: 2021.3 LTS and newer
• Render Pipeline: Built-in (URP compatible)
• File formats: FBX
• Prefabs: Included
• Polycount:
  Average: 300–1,200 triangles per asset
  Largest assets: approx. 2,500–3,000 triangles
• Texture resolutions: 512x512 and 1024x1024
• Materials: Unity Standard materials
• Textures: Fully set up and optimized
• Animations: None
• Colliders: Included
• LODs: Not included

Use Cases

• Tropical and island-themed games
• Stylized open-world environments
• Mobile-friendly projects
• Prototyping and game jams
• Simulations and interactive scenes

Notes

• Assets are game-ready and require no additional optimization
• Materials and meshes are easy to customize
• No external shaders or third-party packages required

Low Poly Tropical Assets Pack #2

Low Poly Tropical Assets Pack #2 is a stylized environment asset collection designed for fast scene building and performance-friendly game development. The pack contains approximately 40 low-poly, game-ready assets, ideal for tropical islands, beach environments, stylized worlds, and rapid prototyping.

All assets follow a consistent scale, art style, and level of detail, making them easy to combine into complete environments with minimal setup.

Included Assets

• Palm trees and tropical foliage
• Palm leaves and vegetation elements
• Wooden bridges and structures
• Water elements
• Tropical props and decorative objects

Scenes Included

Demo Scene
Showcases a fully assembled tropical environment and demonstrates how the assets can be combined for lighting, composition, and visual reference.

Layout Scene
Displays all assets in a clean, organized overview, allowing quick browsing, selection, and testing.

Key Features

• ~40 handcrafted low-poly assets
• Consistent stylized tropical art style
• Optimized for real-time performance
• Ready-to-use prefabs for fast scene building
• Ideal for mobile, PC, and indie game projects
• Perfect for rapid prototyping and level design

Technical Details

• Unity version: 2021.3 LTS and newer
• Render Pipeline: Built-in (URP compatible)
• File formats: FBX, PNG
• Polycount:
  Average: 300–1,200 triangles per asset
  Largest assets (mountains): approx. 3,000 triangles
• Texture resolutions: 512x512 and 1024x1024
• Materials: Standard Unity materials
• Animations: None
• Colliders: Included
• LODs: Not included

Perfect for

• Indie developers
• Mobile and low-end hardware optimization
• Stylized open-world environments
• Rapid prototyping and game jams

Materials are fully set up and optimized using Unity Standard materials.
Textures are optimized for performance, using 512x512 and 1024x1024 resolutions.
No external shaders or packages are required.

Build fast. Build beautiful. Build your world!

Low Poly Stylized Environment Pack – MoewisDesign3D

Create complete stylized environments quickly and efficiently with this versatile Low Poly Environment Pack by MoewisDesign3D. Designed for developers who want a consistent art style, fast level building, and excellent performance across platforms.

This package includes 40+ low-poly environment assets, suitable for open-world games, survival games, RPGs, mobile games, and rapid prototyping.

All major assets include a winter variant, making it easy to switch between seasons or create multiple visual themes without additional work.

Included Assets

• Stylized trees (multiple variations)
• Rocks and cliffs
• Ground tiles and terrain elements
• Water objects
• Decorative props
• Mountains and large-scale environment pieces
• Winter versions of all major elements

Key Features

• 40+ handcrafted low-poly assets
• Consistent stylized art style
• Summer and winter theme included
• Designed for fast scene building and prototyping
• Optimized for mobile, PC, and VR projects
• Easy to customize materials and colors

Collision: Yes

LODs: No

Average Poly Count: Around 100 to 2K

Number of Meshes: 179

Number of Materials: 4

Number of Textures: 4

Number of Images: 175

Supported Development Platforms: All Platforms

DEMO SCENE included!

On the demoscene, you can see all the assets of this collection.

Low Poly Factory Machine Pack includes 140 game-ready assets, optimized for low-end devices and ready to use in your game projects.

PACKAGE CONTAINS

40 Factory Building Prefabs

20 Enviroment Prefabs

100 Item Prefabs

If you have any questions or suggestions about the assets, please contact us.

CONTACTS

Join the Shuter Game Studio community on: Discord

Contact email: shuter.game.studio@gmail.com

Technical Overview

Scriptable Studio Pro is an editor-only Unity tool designed to operate directly on existing ScriptableObject assets using Unity’s native serialization pipeline. It introduces a structured, data-oriented editing layer without altering your runtime architecture or requiring any changes to your existing asset classes.

Core Architecture

• No runtime code is included. The tool has zero impact on builds or player performance.Operates entirely within the Unity Editor
  
• No inheritance, base classes, or attribute requirements. Existing assets work immediately.Works with existing ScriptableObject classes
  
• Fields are discovered dynamically with strict type validation to ensure data safety and consistency.Reflection-based field discovery
  
• Fully compatible with Unity’s serialization system, and AssetDatabase workflows.Native Unity integration
  

Data Handling & Type Support

• Including primitives, enums, nested classes, structs, and lists. Supports all Unity-serializable data types
  
• RectNative handling for Unity-specific types, including:
  AnimationCurve
  Gradient
  Vector2 / Vector3 / Vector4
  Color
  
• UnityEvents with full persistent call editingSpecialized editors for commonly used asset types
  AudioClip with waveform preview and playback
  Texture and Sprite previews
  GameObject and Prefab references
  
• All batch operations support preview, validation, and undo.Safe bulk editing
  

Grid-Based Editing System

• Providing a consistent, table-based editing model.ScriptableObjects are represented as rows, fields as columns
  
• Only compatible fields are displayed and edited together.Multi-asset editing with aligned fields
  
• Row reordering for list-based dataAdvanced data operations
  Sorting per column
  Logical filtering and search queries
  
• Customizable column visibility and reusable layout presets.Layout control
  

Formula Engine

• Familiar syntax designed for designers and technical users.Excel-style expression parsing and evaluation
  
• Formulas can reference other fields within the same asset or row.Field-to-field references
  
• Support for progressive and relative calculations using previous and next row context.Contextual functions
  
• Results are predictable, reproducible, and previewed live before application.Deterministic evaluation
  
• Includes math, interpolation, clamping, rounding, randomization, and progression utilities.Built-in function support
  

Import & Export Pipeline

• Direct copy and paste support for Excel and Google Sheets.Spreadsheet integration
  
• Supports CSV, JSON, SQL, and TSV formats.File-based import and export
  
• Handles nested data, collections, and Unity-specific types during transfer.Robust structured data parsing
  
• Import operations include schema validation and detailed error feedback.Validation and error reporting
  

AI Integration (Optional)

• Used for content creation, balancing, and bulk data iteration.AI-assisted generation and refinement of structured data
  
• Ensures generated data strictly matches field types and structures.Schema-aware output enforcement
  
• Existing assets and metadata are used to guide generation and refinement.Context-driven prompts
  
• AI services are configurable by the user and not hard-coded to a single provider.Provider-agnostic architecture
  

Workflow & Safety

• Designed to handle large batch edits safely and efficiently.Custom Undo/Redo system
  
• All changes can be previewed before being applied to assets.Non-destructive editing
  
• Optimized for large datasets, deep nesting, and long-term project maintenance.Production-scale design
  

Scriptable Studio Pro

The Ultimate Data Pipeline for Unity

[ Documentation ] | [ Discord ] | [ Tutorial ]

🚀 Stop fighting the Inspector. Start architecting your data.

Scriptable Studio Pro is a professional Unity Editor tool for creating, editing, validating, and managing ScriptableObject assets at scale. It replaces slow, click-heavy Inspector workflows with a fast, grid-based data editor designed for real production use.

Whether you are balancing an RPG, managing large inventories, or maintaining thousands of content assets, Scriptable Studio Pro provides a structured, spreadsheet-style workflow that scales cleanly from early prototyping to live content updates.

Designed for both professional studios and solo developers, the tool bridges external data workflows like Excel and Google Sheets with Unity’s native serialization system while remaining entirely inside the Unity Editor.

🌟 Core Features

📊 Grid-Based ScriptableObject Editor

Edit ScriptableObjects as rows and columns instead of clicking through individual assets.

• View and edit hundreds or thousands of assets at once
• Multi-selection editing for fast batch changes
• [Health] > 500 && [Type] == "Enemy"Advanced search and filtering using logical expressions
  Example:
  
• Sort by any field and reorder rows via drag and drop

⚗️ Dynamic Formula System

Balance game data directly inside the editor using Excel-style formulas.

• =[Level] * 100 + [BaseHealth]Field referencing
  Example:
  
• Built-in math functions including Lerp, Random, Clamp, Sin, Cos, Pow, and more
• Context-aware functions like Prev and Next for progression curves
• Live preview of calculated values before applying changes

🔄 Professional Import & Export

Integrate smoothly with external data pipelines.

• Copy and paste directly between Scriptable Studio Pro and spreadsheets
• Import and export CSV, JSON, SQL, and Google Sheets
• Smart parsing preserves nested data, lists, and Unity-specific types
• Data integrity is maintained with strict validation

🛠️ Advanced Editing Tools

Built for real-world data authoring needs.

• Smart autocomplete for enums, references, assets, and formulas
• Drill into nested classes and lists without leaving the grid
• Example: Enemy_{Type}_{#}Bulk rename assets on disk using dynamic patterns
  
• Find and replace across entire datasets

🎨 Native Unity Type Support

Scriptable Studio Pro goes far beyond basic data editing.

• AnimationCurves and Gradients with visual editors
• Vectors and Colors with inline editing
• AudioClips with waveform preview and playback
• Prefabs with thumbnails and spawn actions
• UnityEvents with full visual editing of persistent calls
• Custom serialized class or structs
• List and arrays works parfectly fine

⚡ Workflow Enhancements

• Save window layouts, column sets, and filters as presets
• Robust undo and redo support, even for large bulk operations
• Drag and drop assets directly into the grid
• No base classes, inheritance, or code changes requiredWorks with existing ScriptableObject classes
  

🧠 Optional AI-Assisted Workflow

Scriptable Studio Pro includes an optional AI-assisted feature designed to accelerate data authoring and refinement.

AI Asset Architect

• Generate structured data suggestions based on your existing ScriptableObject schemas
• Analyze selected assets to match naming conventions, tone, and structure
• “Make descriptions more playful”Refine existing content with natural language instructions such as:
  “Fix spelling and tone inconsistencies”
  “Rebalance cost based on rarity”
  

All AI-generated output is validated against your exact data types, including Enums, LayerMasks, AnimationCurves, Gradients, and more.

Supported providers:

OpenAI, Google, OpenRouter, and Ollama (local models)

🔍 AI Usage Disclosure

• AI features are fully optional
• The core tool functions completely without AI
• All AI-generated suggestions require user review
• No datasets or AI services are included with the asset
• Users provide their own API keys or local models
• Read full legal notice here

Scriptable Studio Pro is primarily a data editing and management tool. AI is provided strictly as an optional productivity assistant.

🏆 Who Is This For?

• Balance stats, economies, and progression systems without writing codeGame Designers
  
• Avoid building custom editors for every data typeProgrammers
  
• Manage dialogue, quests, and lore in a clean, readable table formatWriters & Narrative Designers
  

🧩 Designed for Real Production

Built for large, long-term projects.

Scriptable Studio Pro performs reliably with thousands of ScriptableObjects and deeply nested data. All operations are editor-only, optimized, and safe, avoiding unnecessary asset reimports or serialization overhead.

🛡️ Safe, Predictable, and Team-Friendly

• Every bulk operation supports undo
• Changes are previewed before applying
• Schema validation prevents accidental corruption
• Suitable for solo developers and multi-discipline teams

🔌 Extensible by Design

• Add custom formula functions
• Extend AI prompts and presets
• Integrate with existing editor pipelines
• No lock-in and no fragile hacks

🏁 Why Scriptable Studio Pro?

ScriptableObjects are powerful, but the default Inspector workflow does not scale.

Scriptable Studio Pro turns raw data editing into a structured, fast, and reliable process. It reduces friction, minimizes errors, and provides a professional data pipeline that feels closer to a database editor than a cluttered Inspector.

If your project is data-heavy, this tool quickly becomes indispensable.

Core Features - Your AI Building Blocks

Mix and match these stackable components to create any character archetype you can imagine.

The AI Brain (EnemyController)

The central nervous system of your AI. A single component where you define the character's entire personality.

• Archetype Switching: Make your character a brave fighter, a cowardly civilian, a ranged attacker, or a melee brute just by ticking a few boxes.
• Automatic State Management: Intelligently switches between behaviors like Patrolling, Chasing, and Attacking for you.

Movement Behaviors

• SimplePatrol: Visually design complex patrol routes directly in the scene editor. The path is drawn in real-time as you move waypoints.
• WaypointAction: Add life to your patrols! Make characters pause, play animations, or trigger events at specific points in their route.
• SimpleChase: A high-performance chase component that uses Unity's NavMesh to intelligently pursue targets.
• FleeBehavior: The opposite of chase. Perfect for creating civilians, animals, or cowardly enemies that run away from threats.

Perception Systems

• PlayerDetector: The AI's "eyes." A proximity sensor with a clear, adjustable radius gizmo in the editor.

Combat Modules

• RangedAttack: Create archers or soldiers. Manages attack range, fire rate, and even "kiting" behavior by backing away if the target gets too close. All ranges are visualized in the editor.
• MeleeAttack: Perfect for zombies, knights, or beasts. Manages attack rate and range for close-quarters combat.

Advanced Intelligence & Social AI

• SearchBehavior: Your AI now has a short-term memory. Instead of instantly giving up, it will go to the target's last known position and search the area.
• Alerter & AlertReceiver: Create tactical squads! When one AI spots a threat, it can alert its nearby allies, who will all react and converge on the target. The alert radius is fully visualized.

What's Inside the Box?

• 14+ Robust C# Scripts for all behaviors.
• 10+ Custom Editor Scripts for an enhanced workflow.
• Complete set of Demo Scenes showcasing multiple AI archetypes (Archer, Zombie, Civilian, Guard) working together.
• Comprehensive PDF Documentation.

Stop Wrestling With Complex AI Scripts. Start Designing Characters.

Are you tired of giant, monolithic AI scripts that are impossible to debug and a nightmare to modify? Frustrated with tangled state machines that break every time you want to add a new behavior?

We've been there. That's why we built the Modular AI Behavior Kit.

This isn't just another AI asset; it's a complete design philosophy built for speed, flexibility, and creative freedom. Our unique "Brain + Behaviors" architecture lets you build incredibly complex and believable AI characters by simply stacking simple, powerful components. Define a character's personality with a few clicks, and watch them come to life.

Why Choose This Kit?

• Truly Modular: Only use the behaviors you need. Keep your characters lightweight and your project organized.
• Visual-First Workflow: Our professional, custom editors allow you to design and debug your AI's logic directly in the scene view, not in code. What you see is what you get.
• Built for Performance: Uses an efficient, event-driven architecture and a self-registration pattern to avoid slow FindObjectsOfType calls.
• Extensively Documented: Comes with a comprehensive PDF manual detailing every component, its setup, and practical examples.
• Clean, Commented Code: The full C# source code is included and written to be easily understood and extended.

Stop Rewriting Interaction Logic. Start Crafting Engaging Worlds.

Are you creating unique scripts for every door, chest, lever, or NPC interaction? This leads to mountains of redundant code, endless bugs, and a slow development process.

The Modular Interactables Kit is your definitive solution for creating any interactive object in your Unity project with unparalleled flexibility and zero code. Designed for developers and empowering for designers, this kit allows you to define complex interactions by simply selecting behaviors and connecting UnityEvents in the Inspector.

Philosophy: Universal Interactable + Modular Behaviors

Our core philosophy revolves around a single, powerful Interactable component that can host any number of InteractionBehaviors. This means one component handles how an interaction starts (player proximity, click, event), and separate, modular scripts define what happens. This keeps your project clean, scalable, and a joy to work with.

Key Features - Build Any Interaction

The Universal Interactable Component

• Single Source of Truth: Attach one Interactable.cs script to any object to make it interactive.
• Multiple Activation Modes: Define how the interaction starts: On Proximity: Player simply walks near the object (e.g., for dialogue). On Input Press: Player presses a key/button while near (e.g., for opening doors, picking up items). On Click: Player clicks directly on the object (e.g., for UI elements, strategy games). On Event Trigger: Activated by external events (e.g., another switch activates this one).
• Can Be Interacted Flag: Control when an object is interactable (e.g., a chest might only be interactable once).
• Visual Feedback: Built-in options to show a UI prompt (e.g., "Press E to Open") when the player is in range.

Modular InteractionBehaviors (What Happens When You Interact?)

Attach one or more of these MonoBehaviour scripts to the Interactable object to define its action.

• OpenableBehavior: For doors, chests, gates. Triggers animations, sound effects, and controls their open/closed state.
• LightToggleBehavior: Perfect for switches and environmental puzzles. Toggles one or more lights on/off.
• DialogueTriggerBehavior: Integrate with your dialogue system. Triggers specific dialogue lines or sequences.
• TeleportBehavior: Instantly move the player to a new location or load a new scene (integrates seamlessly with your MasterSceneLoader!).
• CollectableBehavior: For items, pickups, and loot. Adds items to an inventory (your inventory system), plays sounds, and destroys the object.
• CustomEventBehavior: The ultimate flexibility! Triggers any UnityEvent you configure in the Inspector, allowing you to call any function on any component without writing code.

Why Choose This Kit?

• Developer-Friendly, Designer-Empowering: Build robust interactions in code, then let your designers implement them visually.
• Highly Extensible: Easily create your own InteractionBehaviors by simply inheriting from a base class.
• Decoupled Architecture: Interaction logic is separated from interaction triggers, leading to clean, reusable code.
• Performance-Optimized: Efficient detection and event-driven updates.
• Visual Workflow: Clear Inspector setups and optional debug gizmos.
• Comprehensive PDF Documentation: Get up and running quickly with detailed guides and examples.
• Clean, Commented Code: Full C# source code included for transparency and customization.

What's Inside the Box?

• 1 Universal Interactable Script
• 6+ Ready-to-Use InteractionBehavior Scripts
• Custom Editor Scripts for an enhanced workflow.
• 1 Complete Demo Scene showcasing various interactables.
• Comprehensive PDF Documentation.

Streamline your development and create dynamic, interactive worlds in minutes! Add the Modular Interactables Kit to your cart today!

Polycount: 5.2k Tris

Textures: 4K texture set (Normal, Diffuse, Spec+Gloss)

Animation: No

Rig: Splitted to parts with all pivots setted up.

All parts made carefully to match real reference. 

Animation is not included but all pivots for parts animation setted up.

Polycount: 5.2k Tris

Textures: 4K texture set (Normal, Diffuse, Spec+Gloss)

Rig: Splitted to parts with all pivots setted up.

Core Gameplay Systems

• Classic Asteroids-style movement with rotation, thrust, and shooting
• Physics-driven ship controller with configurable thrust, rotation, and max speed
• Bullet system with lifetime management and hit detection
• Procedural asteroid spawning with wave progression
• Asteroid splitting system (Large → Medium → Small)
• Screen-wrap logic for player and asteroids
• Player death, scoring, and best score saving

Visual & FX Systems

• Twinkling multi-layer starfield with parallax and procedural generation
• Camera shake system for hits, explosions, and player death
• Bullet trail renderer
• Spark impact VFX on asteroid hits
• Ship thrust flame controlled via script
• Squash and stretch effect during thrust for added visual feedback
• Asteroid rotation and scale pulsing animation

UI & Game Flow

• Logo scene, main menu, options menu, and game scene
• In-game score and best score display
• Game Over panel with restart and menu options
• Options panel with music and SFX volume sliders
• Clean, modular scene loading and state management

Audio

• Lightweight AudioManager with separate Music and SFX channels
• One-shot SFX system for shooting and explosions
• Looping background music support

Project Structure & Extensibility

• Modular C# scripts with clear separation of systems
• Easy to customise visuals, gameplay, difficulty, and UI
• Prefab-based workflow for ship, asteroids, bullets, and VFX
• No custom shaders; fully compatible with Built-in RP and URP/HDRP sprite workflows
• Suitable for rapid prototyping or use as a foundation for larger projects

This asset is provided as a starter game template.

It includes core systems, example gameplay, and a clean project structure intended to help developers prototype faster and build their own games.

This package is not a finished or content-complete game.
Users are expected to:

• Modify visuals, gameplay rules, and balance
• Add additional features, polish, and content
• Adapt the template to their own design goals

If you are looking for a ready-to-publish game with final art, progression systems, monetization, or full content, this package may not be suitable.

If you want a clear, extendable starting point that saves development time and encourages customization, this template is built for that purpose.

Solo Asteroids is a complete 2D arcade shooter template inspired by the classic Asteroids, rebuilt with modern Unity workflows and polished visual feedback. It provides smooth physics-based controls, procedural asteroid waves, shooting with trails and impact effects, camera shake, a twinkling parallax starfield, game flow management, and clean UI.

The project is fully modular and easy to customise. All core systems are written in clear, extendable C# scripts, making it suitable for beginners learning Unity or developers who want a fast starting point for a commercial arcade project.

You can easily change the ship, asteroids, UI, visuals, sound effects, movement, spawning, scoring, difficulty settings, or add new mechanics such as enemies, power-ups, or weapons. Because every feature is separated into logical systems, you can remove or replace parts without breaking the template.

The package includes a Logo scene, Menu scene with options, complete Game scene, prefabs, art, audio, camera effects, VFX, and a lightweight audio manager with separate music and sound channels.

This template is ideal for anyone creating a retro arcade shooter, space survival game, score-based action project, or any 2D game that benefits from modular, well-structured systems and polished presentation.

Requirements

• FREE Starter Pack - Sidekick Modular Characters by Synty (import first)
• Sidekick Tool & Database (install after the Starter Pack and before HeroBridge)
• TextMeshPro Essentials (required for Example UI)

Compatibility

• Works with all current Sidekick Modular Character Packs
• Supports Built-in, URP, and HDRP
• Tested in WebGL, Windows, and Mac builds

Included

• Full source code
• Runtime Character Customizer example scene
• Quick Start & Setup documentation

Integration Notes

HeroBridge Standalone is designed to work alongside third-party character controllers, but integration without scripting is not guaranteed for all setups.

To improve compatibility, HeroBridge Standalone includes an option to disable Animator rebuilding, allowing existing controllers to keep full control of their Animator setup. This makes integration more likely to work with controllers that manage animations internally.

For best results, it is recommended to review your character controller’s documentation to ensure it supports runtime model or mesh changes through code or exposed APIs.

Note

No character models are included.

HeroBridge Standalone provides a set of components that can be attached to GameObjects to control Sidekick Modular Characters at runtime.

With the apply modes On Enable, On Disable, On Button Press, On Invoke, and Unity Events it's easy to hook character alterations into UI, gameplay logic, or state-based systems.

Every component is based on an integrated, user-friendly API that can be used to run HeroBridge Standalone in code.

💥 NEW RELEASE DISCOUNT!

Get 50% off for the first two weeks at $19.99 (regular $39.99).

⚡ Key Features

✅ Works with All Sidekick Modular Character Packs

Compatible with all current Sidekick modular packs.

✅ Runtime Character Control Methods:

• Set Part: Modify any of the 38 modular components, such as the head, body, legs, hair, or accessories.

• Set Preset: Apply complete character presets including head, body, shape, and color settings.

• Set Expression: Control 19 facial expressions using blendshapes.

• Cycle Part: Cycle through parts of any type using next, previous, or random options.

• Generate Dynamic Part Icons & Buttons: Automatically generate dyanmic icons for all parts at runtime and create UI buttons for them.

• Export as Prefab: Turn your character into a prefab. The included customizer isn’t just for runtime, you can also use it as an editor tool, letting you create and save characters directly in the editor.

…And More

✅ Built-in Save System

HeroBridge Standalone includes a simple, slot-based save system for character customization data. Character parts, colors, and blendshape values can be saved and restored at runtime without relying on external save frameworks.

✅ Efficient Runtime Performance & WebGL Support

HeroBridge Standalone caches data such as parts, colors, and presets into JSON files for faster runtime performance and also support for WebGL builds.

✅ Flexible Character Setup

Designed to integrate with custom and third-party character controllers. Includes an option to enable or disable Animator rebuilding, allowing you to adapt HeroBridge Standalone to your specific setup.

✅ Runtime API Access

HeroBridge Standalone builds on parts of Sidekick’s Runtime API and adds its own API layer for controlling character customization at runtime.

✅ Part Overview Window

Includes a dedicated overview window that displays all Sidekick character parts currently installed in your project, organized into clear categories such as hips, torso, and other body sections.

✅ Animation Patcher

Most animations set Jaw Close blendshape to 0, making characters appear with an open mouth. The Animation Patcher tool automatically fixes this by setting Jaw Close to 1.

💡 Example of Runtime Character Customization

A runtime character customizer example scene in HeroBridge Standalone shows how Sidekick Modular Characters can be altered during gameplay, similar to character designers found in role-playing and adventure games.

The example demonstrates how HeroBridge can be used to create systems that allow players to:

• Browse clothing, accessories, and hairstyles
• Modify character parts
• Change colors for hair, eyes, and clothes
• Use blendshapes to alter body shape

Additionally, the sample shows how part icon buttons are automatically generated at runtime.

🎮 Try It Yourself!

You can preview the character customizer directly in your browser or download the Windows build on Itch.io

📦 What’s Included

✔ Full Source Code

✔ Quick Start Guide

✔ Example Character Customizer Scene

🔗 Links

📖 Documentation

📚 Setup Guide

💬 Discord (New)

📅 Roadmap

🧠 Prefer Visual Scripting?

HeroBridge Standalone supports component based workflows and Unity Events, with optional API access when needed.

For a fully visual scripting experience, see HeroBridge – Sidekick Integration for Game Creator 2.

All character models shown in screenshots and marketing materials are not included with this package. They are taken from the FREE Starter Pack – Sidekick Modular Characters by Synty Studios, which is required as a dependency for HeroBridge Standalone.

HeroBridge Standalone is an independent asset for Synty’s Sidekick Modular Character System. It is not affiliated with or endorsed by Synty Studios.

Number of textures - 4

Texture dimensions - 4096

Polygon count of Spiked_baton - 5916

Number of meshes/prefabs - 1

Rigging: No

Animation count - No

UV mapping: Yes

LOD information - No

Types of materials and texture maps PBR

Please write any requests for help or suggestions for errors, I will help and fix them as soon as possible.

Low-poly model. Suitable for your projects of genre: RPG, strategy, first person

shooters, etc.

Polycount:

• Vertices - 3319
• Edges - 9195
• Triangles - 5916

Textures:

• 4k PBR Textures (png)
• 1 material
• 4 textures (Albedo, MetallicSmoothness,Normal,AO)

• Plug-and-Play Setup – Works instantly with zero configuration.
• Asynchronous Saving & Loading – Non-blocking operations ensure smooth gameplay.
• Easily Expandable Architecture – Add custom types, slot systems, encryption, or autosave with minimal code.
• Cross-Platform Compatibility – PC, mobile, consoles, and WebGL supported automatically.
• Platform-Aware Save Logic – Automatically adapts behavior for each runtime environment.
• Automatic Component Discovery – Any script implementing ISaveComponent is included.
• Supports Common Unity Types – int, float, bool, string, Vector2/3/4, Quaternion, and more.

Simple Save gives you a system that is:

• Fast
• Powerful
• Reliable
• Future-proof
• Designer-friendly
• Multi-platform
• Extremely easy to use

All in a compact, production-ready package.

Key Features

• 8 Preset Categories - Graphics, Logic, Audio, UI, Managers, World, Lights, Effects with pre-configured colors and icons
• Unlimited Custom Categories - Create your own with custom names, colors, and icon selection
• Visual Icon Picker - Browse and select from 24+ Unity icons with live preview
• Bookmark System - Mark important GameObjects with priority levels (0-10)
• Context Menu Integration - All features accessible via right-click in hierarchy
• Component Icon Display - See which components are attached at a glance
• Prefab Highlighting - Visual indicators for prefab instances
• Group/Ungroup Tools - Organize or flatten GameObject structures quickly
• Collapsible Inspectors - Clean, organized component editors with tooltips
• Debug Logging Toggle - Enable/disable console output on demand
• Assembly Definitions - Proper runtime/editor code separation for fast compilation
• Comprehensive Test Suite - Full PlayMode and EditMode test coverage included
• Non-Destructive Organization - Objects stay as siblings, hierarchy structure preserved
• Persistent Settings - Configuration stored in scriptable object (version control friendly)
• Color Customization - Customize all header and bookmark colors globally
• Add to Existing Categories - Easily add more objects to previously created custom categories

Hierarchy Organizer is the tool I built because I was tired of scrolling through chaotic hierarchies trying to find that one camera or manager buried somewhere. It lets you add visual headers, color-coded categories, and bookmarks right in your hierarchy - no more guessing where things are.

What You Can Do With It

Organize with Visual Headers - Drop in colored category headers (like "━━━ GRAPHICS ━━━" or "━━━ AUDIO ━━━") to section off your hierarchy. Comes with 8 presets (Graphics, Logic, Audio, UI, Managers, World, Lights, Effects), but you can create unlimited custom categories with your own names, colors, and icons.

Bookmark Important Stuff - Mark critical GameObjects so they stand out. Great for things like your main camera, player controller, or that one manager you always need to tweak.

Pick Icons Visually - Forget typing "Camera Icon" and hoping it works. There's an actual icon picker that shows you what's available with live preview.

Quick Actions via Right-Click - Everything's accessible through context menus. Group objects, add categories, bookmark things - all without opening extra windows.

Keep It Clean - Toggle debug logging on when you need it, off when you don't. The console stays quiet unless you're troubleshooting.

Who's This For?

Anyone who works with Unity scenes that have more than 20 GameObjects (so... everyone?). Especially useful if you:

• Work on small teams and need consistent scene organization
• Jump between multiple scenes frequently
• Build complex levels with lots of systems
• Just want your hierarchy to not look all grey

Customization

Everything's tweakable – colors, icons, category names, whatever. The presets are just starting points. You're not locked into any specific workflow or naming convention.

• Full hierarchy serialization
• Local transforms support
• Mesh serialization (vertices, normals, UVs, triangles)
• Skinned and static mesh support
• Reconstruction of hierarchy, transforms, MeshFilter, MeshRenderer
• Applies selected default material
• Render-pipeline independent
• Runtime & Editor support
• Context menu tools for quick export/import
• Works on all major Unity platforms

Model to JSON & JSON to Model is a universal Unity tool that allows you to serialize any 3D model into a JSON file — including full hierarchy, transforms, meshes, materials, and textures — and then reconstruct the model back into the scene with a single click.

This asset is perfect for:

• procedural generation
• networking applications (sending models between client and server)
• modding systems
• saving/loading complex models
• content streaming
• editor tools

⭐ Core Features

🔷 Model → JSON Serialization
Saves:

• full object hierarchy
• local transforms
• Mesh data (vertices, normals, UVs, triangles)
• object active state
• node names

🔷 JSON → Model Reconstruction
Automatically restores:

• object tree
• meshes
• transforms
• active state
• MeshRenderer + MeshFilter
• applies your chosen defaultMaterial

🔷 Render Pipeline Independent
Works with:

• Built-in Render Pipeline
• URP
• HDRP
  You choose which material is applied during reconstruction.

🔷 MeshFilter & SkinnedMeshRenderer Support
Both static and skinned meshes are fully serialized.

🔷 Easy to Use

• context menu options: "Export Full JSON" and "Build From JSON"
• minimal setup
• works in Runtime and Editor

🚀 Why you need this tool

Model to JSON & JSON to Model enables you to:

• transfer 3D models between devices without AssetBundles
• store models in the cloud
• build custom model-editing tools
• generate complex scenes from JSON
• create modular content-storage systems
• export models directly from your game

A lightweight, fast, and fully self-contained solution for working with 3D content through JSON.

📦 Requirements

• Unity 2021.3+ (supports Unity 6)
• Any Render Pipeline
• Android, iOS, Windows, macOS, WebGL support

💡 Support
If you have questions or need assistance, feel free to contact me. Integration help for specific projects is also available.

Auto-generate consistent C# namespaces from folder structure. Perfect for cleaning existing projects. Batch process scripts with custom overrides.

SF Namespace Generator

Ever started a project, added dozens of scripts, then realized you forgot namespaces? This tool fixes that AND automatically adds the missing `using` statements that come with adding namespaces.

What It Does

1. Adds proper namespaces to your scripts based on folder structure
2. Automatically adds missing `using` statements when scripts reference each other
3. Fixes those "type not found" errors that happen after adding namespaces

Key Features

• ✅ Smart Namespace Generation: Creates namespaces from folder paths (Assets/Scripts/UI → YourGame.Scripts.UI)
• ✅ Automatic Using Statements: Detects when ScriptA uses ScriptB and adds `using YourGame.Scripts.UI;`
• ✅ Type Detection: Finds references in generics, attributes, switch cases, and casts
• ✅ Batch Processing: Update hundreds of files at once
• ✅ No Manual Work: One click adds namespaces AND fixes dependencies

Perfect For:

• Projects that grew without namespaces
• Fixing "missing reference" errors after organizing code
• Preparing code for sharing or asset store
• Cleaning up messy codebases

How It Works:

1. Select your project folder
2. Set your root namespace
3. Preview what will change
4. Click apply - gets namespaces AND using statements right

No more manually adding dozens of `using` statements after organizing your code!

Number of textures: 13

Texture dimensions: 4096x4096

Polygon count of [Model Name]

Minimum polygon count: 68416

Maximum polygon count: 68416

Number of meshes/prefabs: 1

Rigging: Yes

Animation count: 26

Animation type list:

UV mapping: Yes

LOD information: N/A

Types of materials and texture maps: PBR

Description

Dragon Worm is a high quality, production ready rigged and animated boss creature for Unreal Engine. It is designed for cinematic reveals, arena encounters and close ups where you need a believable giant wyrm without spending weeks on setup, rigging and animation.

The Dragon Worm uses a custom skeletal rig with a clean bone chain through the whole body, so it deforms smoothly with the included animations and is easy to animate further. The mesh is optimized for real time and keeps a strong, readable silhouette at boss scale.

This pack focuses on encounter-ready animations: burrow in/out, multiple attack variations, strong hit reactions, two posture states (upright and snake/ground), plus grab and throw and a clear death animation for finishing the fight.

Length: approximately 30 meters (3000 cm) - perfect scale for a giant boss encounter.

Included Animations (26)

Attacks and actions:

• DWorm_AttackA
• DWorm_Attack_Left
• DWorm_Attack_Right
• DWorm_Attack_Air
• DWorm_AttackD_AOE
• DWorm_SnakeAttack
• DWorm_GrabNThrow

Burrow:

• DWorm_Burrow_In
• DWorm_Burrow_Out

Reactions and death:

• DWorm_HitReact_Front
• DWorm_HitReact_Back
• DWorm_HitReact_L
• DWorm_HitReact_R
• DWorm_Death

Idles and roars:

• DWorm_IdleA
• DWorm_IdleB
• DWorm_Low_Idle
• DWorm_Low_Idle_In
• DWorm_Low_Idle_Out
• DWorm_SnakeIdle
• DWorm_Roar
• DWorm_SnakeRoar

Crawl variations (animation clips included as movement variations, not a full locomotion system):

• DWorm_Crawl
• DWorm_CrawlSmallAmp
• DWorm_CrawlSmallAmpSnake
• DWorm_CrawlSnake

MODEL DETAILS :

SM_CD

vertices: 1,262

Edges: 3,780Faces 2,520

Triangles: 2,520

SM_hashi

vertices: 232

Edges: 690

Faces 460

Triangles:460

SM_MT

Objects 13

vertices: 54,534

Edges: 161,378

Faces 106,876

Triangles:106,876

SM_CFM

vertices: 61

Edges: 48

Faces: 28

Triangles: 288

TEXTURES DETAILS

textures QTD: 180

Type: PBR (Metallic/Roughness)

Resolution: 4096 x 4096

PBR support: Unity HD render, OpenGL

Skins: 9

Game Ready

Asset Sync: The Essential Workflow Bridge for Professional Unity Teams

Asset Sync is the robust, feature-rich tool that automatically handles the tedious, error-prone task of keeping your source art (from programs like Blender, Maya, Photoshop, etc.) perfectly synchronized with your Unity project.

Key Benefits: Automate Your Workflow, Preserve Your Work

• Seamless Integration: Establish a one-way sync link between any external source folder and a target folder in your Unity project.
• Time-Saving Sync Modes: Choose between fully automatic, real-time syncing for instant updates, or Manual Mode to queue changes for user review and approval.
• Intelligent Material Preservation: Save hours of re-work! When a 3D model is updated, Asset Sync intelligently attempts to preserve any existing material assignments you've made within Unity.

Professional-Grade Control and Review

Asset Sync gives you the precise control and review capabilities demanded by professional studios:

• Visual Diff Tool (Manual Mode): Eliminate guesswork. Before syncing, open a dedicated diff window to visually compare the pending source asset against the current version in your project. Supports textures and 3D models.
• Comprehensive Exclusion System: Keep your project clean and clutter-free.
  Easily manage file and folder exclusions with the intuitive SyncTree Manager, a user-friendly tree view with checkboxes.
  Filter exactly which file extensions (e.g., .fbx, .png, .psd) should be monitored and synced.
  Exclusion rules are persistent across sessions.
• Initial Bulk Sync: Use a dedicated function to perform a fast, one-time, full sync of a large source directory, perfect for initial project setup.

Stay Informed at a Glance

Never wonder about your sync status. Asset Sync provides clear, at-a-glance status indicators via:

• A detailed status box in the main Monitor Window.
• An optional icon in the main Unity toolbar.
• An optional, clickable overlay in the Scene View.

Ready for Any Project

The "Stop Monitoring" cleanup feature provides a clean way to completely decouple the folders and reset your configuration. Built on a foundation of automated tests, Asset Sync is a reliable and stable addition to your development toolkit.

Asset Sync is the 'set it and forget it' solution for integrating external art assets, ensuring your team always works with the latest files without ever breaking existing scene work.

POLYCORE - Low Poly City Life

Create your dream city with this stylized, modular asset pack! Designed specifically for hyper-casual games, city builders, and mobile projects, PolyCore offers a clean and vibrant aesthetic without compromising performance.

All assets are modular and use a shared texture atlas, making them extremely lightweight and optimized for mobile devices.

Key Features

• Modular Workflow: Snap buildings and roads together to create endless city layouts.
• Mobile Ready: Low polygon counts and optimized geometry for high FPS.
• Vibrant Style: Eye-catching colors and clean designs suitable for all audiences.
• Drag & Drop: Prefabs are ready to use with correct pivot points and colliders.

Package Includes

• Buildings: Apartments, Shops, Offices, Hospitals, Restaurants.
• Road System: Straight roads, Corners, T-Intersections, Crossroads (snap-ready).
• Props: Traffic lights, Street lamps, Barriers, Trees, and urban details.
• Demo Scene: A fully assembled sample city to showcase the assets.

Compatibility:

• Works with Built-in Render Pipeline by default.
• Easily upgradable to URP or HDRP using Unity's standard material upgrader.

Features:

• Total Prefabs: 100+
• Texture Dimensions: 128*128, 512x512, 1024x1024, 2048x2048
• Polygon Count: Buildings: 400 - 5000 tris average
• Rigging: No
• Animation: No
• UV Mapping: Yes

## Technical Details

* Full source code included.

* Non-destructive editing workflow.

* Supports any `Texture2D` asset that Unity can import.

* Works with all rendering pipelines (Built-in, URP, HDRP).

* Processing is done via a custom high-performance shader.

* Settings are stored in custom ScriptableObject assets (`.grade.asset`).

* Requires Unity 2020.3 or newer.

Take full control of your texture's appearance directly within the Unity Editor with qs.Texture Grade. 

This extension provides a comprehensive suite of color grading tools that allow artists and developers to fine-tune textures without ever leaving Unity.

Whether you need to tweak the color balance of a single asset or ensure color consistency across your entire project, qs.Texture Grade offers a streamlined, non-destructive workflow that integrates seamlessly into your pipeline.

### Key Features:

* **Non-Destructive Workflow:** Your original textures are always safe. qs.Texture Grade creates a backup of your texture when you start an editing session. You can apply your changes, cancel the session, or revert to the original at any time.

* **Real-time Preview:** See the results of your adjustments instantly. The interactive preview window shows your changes as you make them, allowing for precise control over the final look.

* **Live Histogram:** Analyze the tonal range of your texture with a built-in histogram that updates in real-time. View the combined RGB channels or inspect Red, Green, and Blue channels individually.

* **Levels Control:** Adjust the shadows, mid-tones, and highlights with precision. You can control input/output levels and gamma for Luminosity (all channels) or for R, G, and B channels independently.

* **Professional Color Grading:**

* **Lift, Gamma, Gain:** Use familiar color wheels to adjust the dark, mid, and bright tones of your image.

* **HSL & Contrast:** Fine-tune the Hue, Saturation, and Lightness of your texture, and adjust the overall contrast.

* **Advanced Curve Editor:** Get ultimate control with a full curve editor. Adjust the master curve or manipulate the Red, Green, and Blue channels individually for precise color correction.

* **Seamless Integration:**

* Access the tool from the `Assets` context menu for any `Texture2D` or from the `Tools/qs.TextureGrade` menu.

* Settings are saved in a convenient `.grade.asset` file right next to your texture, making it easy to manage and version control.

**qs.Texture Grade** is the perfect tool for any Unity developer looking to enhance their visuals and streamline their texture workflow.

Technical Details

• Total Prefabs: 20 (5 Elements x 4 Types)
• Texture Resolution: 512 x 512 px
• Texture Type: Base Color, Alpha, Emission
• Shader Type: Particle Standard (Mobile compatible) / Shader Graph (for URP/HDRP)
• Polygon Count: Approximately 240 - 360 triangles per mesh-based effect.
• Supported Render Pipelines: Standard (Built-in) Universal Render Pipeline (URP) High Definition Render Pipeline (HDRP)
• Mobile Ready: Yes (Highly optimized for low-end to high-end mobile devices)
• Requirements: Unity 2022.3.62f2 or higher.

Sasual EffectVFX Pack is a lightweight and versatile elemental VFX pack specifically optimized for mobile platforms. It features 5 essential elemental properties—Fire, Water, Grass, Poison, and Dark—each designed to provide high-quality visual feedback without compromising performance.

With 20 pre-configured prefabs, this package covers all the fundamental combat effects needed for an RPG or Action game. Each element includes four distinct types of effects: Hit, Sword Slash, Aerial Explosion, and Ground Explosion. These are designed to be "plug-and-play," allowing you to enhance your game's combat feel instantly.

Key Features:

• 5 Elemental Themes: Fire, Water, Grass, Poison, and Dark.
• 4 Combat Essentials per Element: Hit, Sword, Aerial Explosion, and Ground Explosion.
• Mobile Optimized: Designed with low-draw calls and efficient texture usage for smooth performance on mobile devices.
• Cross-Pipeline Compatibility: Full support for Built-in, URP, and HDRP.