Asset Store newest packages

This Core asset will serialize/deserialize the following

GameObject

Transform

Serializable Structs and Classes

as well as

C# Primitives

.Net Collections

Common Unity structs such as Vectors, Quaternion, Colors etc

See documentation for a complete list.

This edition contains functionality for Save/Load to the Network and limited JSON support

NOTE: This asset is distributed as Plugin dll's. Only example source code is provided.

Saving and Loading data should be easy and simple, fast, safe and secure, often it is not!

Whatever you need to save call Save.method() and let our custom binary serializer do the rest. No setup, no fuss. Bringing it back is as simple as Load.method() We have done the hard work so you don't have to.

Our simple to use API let's you save what you want in just 2 lines of code and if you don't want to code we supply No Code options for Saving and Loading.

Want to save your procedurally generated world? No problem, we save both values and references so nothing gets lost.

GameObjects, Components, Monobehaviours, Primitives, Structs, Classes, .Net Collections, Key Value pairs, ScriptableObjects, we have it covered. See technical details for more information.

Easy. Fast. Efficient. Secure.

Synchronous or Asynchronous saving and loading, compression by default, bring your own encryption if required.

Save/Load using a file for local storage or a Steam for online.

Our modular add-on system means you only have the overhead for the things your project needs. Need more? Add a module. Need less? Delete a module, it's that simple.

The ONLY Complete Save and Load Data System on the market

Despite the claims of others no one comes close to serializing the range of data types supported by the Save for Unity system. More Primitives and C# objects. More .Net Collections. More than 200 Unity objects. All 'out of the box'.

Because WE do NOT rely solely on Reflection for serialization (unlike other well known save/load systems), we will always be the Ultimate Solution for saving and loading your data in terms of ease of use, speed, I/O size and coverage.

Network Support

This edition of the Core module includes support and server examples for TCP, HTTP and UnityWebRequest network saving and loading.

Why Binary Serialization matters to YOU?

String based serializers (JSON, XML, YAML etc) are slow and create large data files with lots of garbage to be collected. Binary serializers however create small data files faster with little or no garbage collection. Smaller data files mean less system IO which translates into faster save and load times. Binary deserialization means no string parsing increasing speed whilst decreasing overhead. See our performance comparison tests here

Still not convinced? This edition supports JSON saving and loading so you can test the difference.

Optimization Built in

Here at SteveSmith.Software we care about YOUR project performance. Our unique optimization utility will remove the usage of Reflection during serialization (improving save and load times by over 20%) and remove any unused code (reducing build times and the load time of your finished game)

Want to know more?

Read the Documentation | Discord | Email | Website

SteveSmith.Software offers multiple solutions for your data requirements. See our product comparison chart, above, to decide which one best fits you and your project.

✅ Works on Unity 2022.3.62f1 through Unity 6.1.

⚠️ May not be compatible with Unity versions earlier than 2022.3.62f1

WebSite | Discord

Easy Effect Viewer is a tool designed to make effect management within your projects smarter.

🔍 Key Features

■ Automatic Thumbnail Generation & Listing for ParticleSystem / VFX Graph Prefabs Automatically detects ParticleSystem and VFX Graph assets in your project.

It generates thumbnail captures of effects during playback and displays them in a list. Having thumbnails allows you to find the desired effect at a glance. This can significantly contribute to improving development efficiency.

■ Tagging & Filtering Freely set tags according to usage.

Classify effects into categories like "Explosion," "Sparkle," or "For UI," and narrow down to the specific effect you need simply by clicking its tag. Tagging can also be done via drag-and-drop or right-click, making the operation intuitive.

■ Inspector Preview

you can play its effects directly at the bottom of the Inspector,when you select a Prefab in the Project window.

It supports playback control (play/stop), changing playback speed, and camera operations such as zoom, rotation, and pan. There is no need to place it in the scene separately, making verification very smooth. Additionally, you can set captured images within the preview as thumbnails.

🎯 Recommended For:

• Users who have installed external assets, have a large number of effects in their project, and want to quickly find the effects they need.
• Users who want to organize effects in a shareable way for teams including artists, designers, and engineers.
• Users who want to select effects based on their "visual atmosphere," which is difficult to find with text search alone.

🧰 Supported Environments:

• Unity 2019.4 or later
• Supports Built-in, URP, and HDRP

🌟Just Create Discord🌟

Gamedev community where you can share your works, read asset announcements and get customer support

Create an expansive, explorable sci-fi military base and resource colony on an alien planet with this massive modular pack!

Perfect for survival, base-building, strategy, and exploration games.

This pack includes hundreds of prefabs designed for easy drag-and-drop use and fully optimized for performance. Featuring large buildings, modular interiors and a wide variety of props, you can build a believable and functional planetary base quickly and efficiently.

Key Features:

• Massive ready-to-use sci-fi buildings
• Fully modular base
• Modular interiors: walls, floors, ceilings
• Large set of interior and exterior props
• Weapons
• Vegetation
• Optimized using shared texture atlases for best performance
• Demo scene included to explore how everything fits together instantly

Whether you’re prototyping a survival experience or building a complete sci-fi military colony, this pack gives you all the tools needed to create a large-scale, modular planetary base.

Optimized for:

- Universal RP - Unity 2022.3+ (default)

- Standard RP - Unity 2022.3+ (included .unitypackage)

- High-Definition RP - Unity 2022.3+ (included .unitypackage)

Featured Assets:

- Low Poly Sci-Fi Characters

- Low Poly Sci-Fi Planet Base

- Low Poly Sci-Fi Cyberpunk City

- Low Poly Sci-Fi Cyberpunk Interiors

Join the Just Create Studio community on: Discord | Twitter | Instagram

info@justcreate3d.studio - customer support

- Unity version tested: Unity 6.x

- Render Pipeline: Universal Render Pipeline (2D Renderer)

- Weather types: Sunny, Cloudy, Windy, Rainy, Stormy, Snowy, Foggy

- Smooth weather transitions with no visual popping

- Wind system with direction, strength, gusts, and wobble

- Wind-driven rain, snow, clouds, and visual effects

- Fog system with player cutout and mask refill

- Snowflake and wind swoosh visual effects

- Global lighting dimming during storms

- Optional sun and time-of-day integration

- Editor setup window and Defaults asset

- Demo scene included

- Documentation included

Timbeaux’s 2D Weather Toolkit is a modular, runtime-driven weather system designed for 2D games using the Universal Render Pipeline (URP).

It provides smooth, believable transitions between weather states without visual popping, while remaining easy to integrate and extend. Wind is treated as a first-class system and influences clouds, rain, snow, fog effects, and ambient audio.

The toolkit is built around a clean architecture:

• One authoritative weather state
• One transition manager that owns interpolation
• All visual and audio systems react to weather, never control it

This makes behavior predictable, extensible, and safe to integrate into gameplay systems.

Included weather features:

• Sunny, Cloudy, Windy, Rainy, Stormy, Snowy, and Foggy states
• Smooth weather transitions (no snapping or popping)
• Wind-driven clouds, rain, snow, and visual effects
• Snowflake flyby effects affected by wind
• Fog system with player cutout and refill
• Thunder and lightning support
• Global lighting dimming during storms
• Optional day/night sun and time integration

Editor & workflow features:

• One-click setup via an Editor Window
• Defaults asset for fast prefab assignment
• Demo scene showcasing all weather types
• Debug UI for forcing weather and testing transitions

Gameplay extensibility:
The package includes an example of a weather-reactive NPC (a ghost that appears only during Snowy weather), demonstrating how gameplay elements can respond to weather states without tight coupling.

Documentation is included directly in the package, covering quick setup and full system architecture.

- Configurable 2D day/night cycle with adjustable day length

- URP 2D Lighting support using Global Light 2D

- Optional overlay-based lighting system for non-URP projects

- Time periods (Dawn, Day, Dusk, Night) with custom definitions

- Period, hour, and minute-based event hooks

- Inspector-driven setup (no code required for common use cases)

- Ambient audio and lighting example implementation

- ScriptableObject-friendly architecture for save/load integration

- Includes demo scene, prefabs, and documentation

Timbeaux’s 2D Day/Night System provides a clean, extensible way to add a full time-of-day cycle to 2D games.

The system supports both URP 2D Lighting and non-URP projects. In URP mode, lighting is driven entirely by Global Light 2D for natural light falloff and dramatic night lighting. For non-URP projects, an optional overlay-based solution is included as a fallback.

Time progresses continuously and is divided into configurable periods (such as Dawn, Day, Dusk, and Night). Developers can trigger events when periods change, at specific hours, or at specific minutes. This makes it easy to drive gameplay logic, lighting changes, ambient audio, or visual effects.

The package includes a polished demo scene showcasing:

- A smooth day/night transition

- URP 2D lighting integration

- Period-based events

- Ambient night audio

- Time-based light activation

All systems are modular, inspector-driven, and designed to integrate cleanly with ScriptableObject-based save systems.

• Single FloatingPickup2D component for sprite-based pickups

• Configurable bobbing, sway, spin, and scale pulse effects

• Preset prefabs for common pickup behavior styles

• Works with animated and non-animated sprites

• Does not modify Z position or interfere with 2D sorting

• Render-pipeline agnostic (Built-in, URP, HDRP)

• No external dependencies

• Includes demo scene and documentation

Floating Pickups 2D is a small, drop-in animation toolkit for 2D games that adds polish to collectible items such as coins, gems, hearts, and loot.

The toolkit provides a single, flexible component that can be added to any SpriteRenderer-based pickup to apply floating, bobbing, rotation, sway, and optional scale pulsing effects. All motion is configurable per object and designed to work cleanly in top-down or side-view 2D projects.

Several preset prefabs are included to help you get started quickly, or you can apply the script directly to your own existing pickup objects. The system is lightweight, does not affect gameplay logic, and is safe to use alongside Animator-driven sprite animations.

This package is ideal for developers who want to add visual polish to pickups without adding complex systems or dependencies.

AAA Rpg Choices

Advanced Dialogs

Multiple endings

Time control for cutscenes

Built to call methods between choices and dialogs

Wizard combat system with advanced AI

Complete third person movement

Require new input system package to be installed

Require Post Processing for Built-In to be installed

Require AI Navigation package

Wizard School RPG Choices and Dialog System contains Wizard School Fighting Engine. If you only want the wizard combat system, you can get it here for a lower price:

WIZARD SCHOOL FIGHTING ENGINE

Also want fly with Broomstick? Get Broomstick Engine:

WIZARD SCHOOL BROOMSTICK ENGINE

Ever dreamed of creating your own wizard combat RPG or open-world magic adventure? Wizard School RPG Choices and Dialog System is an action-packed RPG Choice and Dialog system, designed for AAA RPGs, bringing intense wizard duels, powerful spells, and epic magic battles to your game

Design emotionally charged conversations, branching storylines, and long-term consequences that shape the world, the characters, and the player’s ultimate fate. From subtle dialog variations to radically different endings, this system is crafted to support narrative depth at a professional production level.

Read to build your own wizard world with multiple choices and endings? Maybe you’ve tried other systems, but they were either too complicated or didn’t deliver the AAA wizard action you were looking for. Either way, your wait is over.

Wizard School RPG Choices and Dialog System is an easy-to-use, action-focused system that lets you build high-quality exploration with multiple story paths, consequences and an advanced combat system with AI for RPGs and open-world adventures. Inspired by AAA wizard duels, it gives you everything you need for dynamic, spell-fueled battles.

Here’s what you get with our powerful third-person wizard combat controller:

• Advanced RPG Choice and Dialog system
• Magical attacks, defenses, and cinematic spellcasting
• Target by distance or lower health
• Full third-person movement
• Wizard combat AI
• Full support for Xbox, Nintendo Switch, and PlayStation controllers
• Simple drag and drop system
• Use new Input system package to simplify player input

Engineered for ambitious projects, it scales effortlessly from intimate character moments to complex, interconnected narrative arcs. Whether you’re building a dark fantasy epic, a narrative-focused RPG, or a story-rich adventure, this asset gives your team the freedom to direct the story like a film, without sacrificing performance or iteration speed.

Create branching destinies. Deliver multiple endings.

Build AAA narratives powered by your creativity.

• Material_Palette.unity
• palette.mat
• readme.pdf
• One of each for each material
• Material (.mat file)
• Albedo (2048 × 2048 .tga)
• Height (2048 × 2048 .tga)
• Normal (2048 × 2048 .tga)
• Occlusion (2048 × 2048 .tga)
• Specular (2048 × 2048 .tga)
• Terrain Layer (.terrainlayer)

Derived from nature TERRAIN_Drawn provided 600 .tga textures 2048 × 2048 assembled into 120 stylized materials and terrain layers.

Materials and terrain layers are provided in a stylization that resembles a comic book style with shapes and forms being outlined in thin dark borders drawn-like.

The collection includes 10 categories:

• dirt
• forest fall
• grass
• mud
• plant
• rock
• snow
• sand
• snow grass
• stones

For more information and assets:

Instruction Manual: https://darkmattermagic.com/terrain_/

More Unity Assets: DarkMatterMagic - Asset Store

or https://darkmattermagic.com/assets/

• Logs development sessions with timestamps and tags.
• Calculates average hours worked per day, week, and month.
• Summarizes hours spent per task/tag and individual entry durations.
• Plain ASCII log format for easy editing and parsing.
• Configurable settings for customization.
• Works in the Unity Editor, but can be adapted for runtime use.

DevTime is a Unity plugin that logs development sessions with start and end times, tags, and descriptions. It helps developers track how long they spend on specific tasks or features. The plugin can summarize total hours, average daily/weekly/monthly work, and time spent per task. DevLog entries are stored in a simple ASCII format, making it easy to read, edit, or integrate with other tools. Suitable for solo developers, teams, or projects where tracking workflow and productivity is important.

All content is fully customizable, and tags can be adapted for any type of project or workflow.

- Architecture
- Three-tier system: Creation (GraphView), Storage (ScriptableObjects with SerializeReference), Runtime (DialogueManager)
- Graph Editor
- Dialogue/Branch/Event/Symphony nodes, Start Node, move/copy/paste/undo
- “Generate Example Graph” and “Build Runtime (DialogueData)” buttons
- Runtime Dialogue
- Typewriter effect with Voice-Over sync (CPS = chars / audio duration)
- Text tag parsing for portraits: [happy], [neutral], [sad], etc.
- Optional input to advance lines (Space by default)
- Branch evaluation via Blackboard (int/bool/string with operators)
- Event node UnityEvents; Symphony node BGM mood transitions
- Integrations
- Portrait bridge (IPortraitController) + GenericPortraitController sample
- Audio bridge (IAudioService) + GenericAudioService sample
- Tools
- Localization CSV export
- Search All across DialogueData and Graphs
- First-time Welcome/Tutorial editor window
- Samples
- One-click Sample Scene generator (player movement, NPC trigger, UI panel)
- Interaction prompt (“Press E to Talk”), bottom dialogue UI panel
- Compatibility
- Unity 2020.3+ recommended; UIElements fallbacks included
- Works with Legacy Unity UI; easy to swap to TextMeshPro

NarrativeLink is a robust, production-ready, node-based narrative engine for Unity. It cleanly separates creation, storage, and runtime so designers and programmers can collaborate efficiently. Build conversations with a visual Graph Editor (Dialogue, Branch, Event, Symphony nodes), export to lightweight ScriptableObjects, and play them through a flexible Dialogue Manager that drives UI, portrait animation, and audio.

The package includes a complete sample scene (player/NPC, prompt to talk, bottom dialogue panel), generic portrait/audio bridges for out-of-the-box demos, and editor tooling for Localization (CSV export), content-wide Search, and a first-time Welcome/Tutorial window. It’s suitable for visual novels, RPGs, action-adventures, and any 2D project that needs branching, dynamic dialogue with minimal boilerplate.

Key parts are interface-driven (IPortraitController, IAudioService) so you can plug in your own animation/audio stacks (e.g., pixie2dstudio, symphony) or keep the included generic implementations.

Visit Vector Studios to contact us for more information ..thank you

• CoreGlobal tempo clock and DSP-aligned beat/bar scheduling (SymphonyManager)
  StepSequencerPattern with tracks (Percussion/Synth), stepsPerBeat, swing, free move
  Per-track controls: volume, pan, mute/solo, mixer channel, probability, humanize, speedMultiplier
  
• PlaybackManualSequencerPlayer with voice pooling and prewarming to minimize allocations
  ArrangementPlayer spawns per-clip sequencers; region trimming; dynamic loop window; bar-sync start option
  Per-clip audio overrides: slicePackOverride, synthOverride, mixerOverride
  Current playhead reporting for Editor transport and UI
  
• Procedural generationMelodyGenerator and ChordProgressionEngine with scale/seed settings
  ProceduralMusicPlayer scheduling harmony/bass/perc layers to the DSP clock
  
• Mixer & FXSymphonyMixer with channels (name/volume/pan) and FX slot chains
  AudioFXDefinition + IAudioEffect pipeline for per-voice processing
  Editor Mixer Console to add/remove/reorder FX slots
  
• Editor toolingSymphony Studio: step sequencer, rhythm tools (Euclidean fill, trap hats), slice palette
  Piano Roll: synth note editing, scales/presets, marquee, copy/paste, snapping
  Song Builder: FL-style playlist lanes, clip paint/drag/split/resize, drag-and-drop from library, transport
  Arrangement Editor: lightweight timeline view with add-clip panel
  Sound Engines: browse & preview Synth plugins and Slice packs, assign defaults
  Browser: search and group assets (patterns/slices/synths/mixers/arrangements/automation)
  Audio Settings: DSP buffer presets and performance asset integration
  Exporter: offline export to WAV/MIDI (OGG/MP3 via plugins), stems, mixer FX, normalization, peak ceiling
  
• ExportPattern and Arrangement export pipelines
  Stems per track, optional mixer FX application, equal-power pan law, final normalization
  Peak ceiling control (e.g., -0.3 dBFS) for validator compliance
  Note: OGG/MP3 require external encoders (Vorbis/LAME) and defined symbols
  
• Performance & stabilitySchedule-ahead time and DSP buffer tuning
  Pooled players and voices (reduced GC)
  Safe scheduling lookahead; trimming at step/pattern ends
  Max concurrent clip cap to prevent overload
  
• ExtensibilityCreate SynthPluginBase derivatives
  Implement custom AudioFXDefinition processors
  Add editor windows and workflows using SerializedObject/Property
  
• CompatibilityUnity 2020.3+ (LTS recommended)
  Works in Editor and runtime; export features require readable AudioClips (Decompress On Load)
  
• Limitations & notesOGG/MP3 export not included by default; integrate encoders
  Advanced mixer sends/aux and automation lanes are not included (can be extended)
  
• Documentation & supportComprehensive README and in-editor help texts
  Optional markdown-to-PDF documentation scripts included
  Clear troubleshooting for stutter, export clipping, and setup issues
• For more info contact us via website https://vectorstudios.kesug.com and also check out other assets created by us in the asset store
  

Symphony is a complete, modular music system for Unity that lets you design, perform, and export adaptive scores without leaving the Editor. Build rhythms and melodies in a step sequencer or piano roll, arrange clips across lanes on a global timeline, route tracks through a mixer with FX chains, and export stems or full mixes to WAV/MIDI (OGG/MP3 via plugins).

Designed for games and interactive experiences, Symphony balances creative workflow and runtime stability. It features a global tempo clock with sample-accurate scheduling, per-track swing/humanize, speed multipliers, and an arrangement player that respects clip boundaries and loops cleanly at the content end. Powerful editor windows (Studio, Song Builder, Mixer Console, Sound Engines, Audio Settings, Exporter) give you FL-style productivity inside Unity.

Suitable for many genres:

• Electronic, trap/hip-hop (euclidean rhythms, hat rolls, slice-based percussion)
• Orchestral/synth hybrid (procedural harmony/chords, layered synth voices)
• Ambient and adaptive scores (layers toggle at runtime, timeline cueing)
• Casual/mobile titles (lightweight synth and efficient scheduling)

Fully customizable:

• Create your own synth plugins and FX processors
• Author slice packs for percussion
• Build mixer channels and FX chains
• Extend arrangement clips with per-clip audio overrides

Contact us via https://vectorstudios.com.ng

 for more enquiries in the contact section

Documentation

Some of the most memorable games let the developers talk directly to the player — explaining design choices, technical tricks, cut ideas, and the occasional “what were we thinking?”

DOCUMENTATION

WEBGL DEMO

This asset lets you add optional in-game developer commentary, inspired by titles like Half-Life, Portal, and Superliminal.

Record commentary using your microphone directly inside the Unity Editor, place commentary nodes in your scenes, and trigger events along the audio timeline to highlight moments, mechanics, or behind-the-scenes details.

Players can enable or disable commentary globally, so it’s there for the curious — and invisible for everyone else.

More games should have developer commentary.

Now yours can.

• Uses runtime UI Toolkit which allows for clear scene hierarchy, and customization
• Have automatic stripping of DebugPanelComponent's from scene upon release build
• Have a static binding feature, scans all codebase for StaticBoundButtonAttribute to populate them withing UI (upon build caches all this, to prevent expensive runtime lookup)
• Optional console tab that capture logs

Problem that it solves (Why it was created?)

Created to easily test mobile games. Allows to add cheat buttons, like: 'Add currency', 'Switch between levels', 'Kill all mobs on level', etc. Fully manages UI layout for these cheats and provides a Tab and Groups system to pack a lot of Cheat UI on a small mobile screen.

👁️Documentation👁️ (Samples available in package manager)

🟩Features🟩

• 📱Ideal for cheats in mobile games
• 📃Build hierarchies: Tabs -> Groups (Vertical↕️↔, Horizontal↔️, Collapsible🔽) -> UIElemts (Buttons, Toggles, Dropdowns)
• 📈Built with UI Toolkit to minimize scene clutter and enable easy customization
• 🚀Create complex layouts with a few lines of code
• 🔄️Iterate without playmode (Generated UI can be previewed without entering playmode)
• 🗑️Automatic stripping from release build
• 🔗Static Binding - define buttons from anywhere in the project with an attribute
• 🪵Built-in logs tab
• 🧑‍🏫Comes with built-in samples

Compatible with Unity 2022, Unity 6 and higher

About development

Essentially, it evolved from manually calling OnGUI() to draw a set of buttons to a fully responsive UI solution built with UI Toolkit. It manages text size, button sizes, layouts, etc, that regular OnGUI() does not.

Created initially for adding cheats in mobile games for testing purposes.

• ScriptableObject-based dialogue data
• Clear separation between runtime logic and UI
• Choice-based and linear dialogue support
• Explicit dialogue event system
• Minimal assumptions about UI or game structure
• Editor-friendly and Asset Store–ready architecture

This asset is designed to handle dialogue flow and structure only. UI, gameplay logic, and side effects are intentionally kept outside the core system.

Key Features:

   One-click Canvas to UI Toolkit conversion

   Generates UXML, USS, and C# controller files

   Supports 20+ uGUI components (Button, Toggle, Slider, InputField, Dropdown, ScrollRect, Image, Text, etc.)

   Full TextMeshPro (TMP) support with rich text preservation

   Layout groups converted to CSS Flexbox (Horizontal, Vertical, Grid)

   9-slice sprite border extraction

   CSS variable generation for colors and common values

   Style deduplication and optimization

   Type-safe C# bindings with null-safe operators

   Auto-generated event callback stubs

   Configurable naming conventions (camelCase, PascalCase, kebab-case)

   Multiple layout strategies: PreferFlexbox, PreserveAbsolute, MixedLayout

   Live UXML preview in Migration Wizard

   Batch conversion of multiple canvases

   No runtime dependencies - editor tool only

   Clean, readable, production-ready output

   Preserves hierarchy structure and naming

   Anchor and pivot conversion

   Padding and spacing preservation

   Full source code included

  Requirements:

   Unity 2021.2+

   UI Toolkit package (built-in)

  Supported Components:

  Button, Toggle, Slider, Scrollbar, InputField, Dropdown, ScrollRect, Image, RawImage, Text, TextMeshProUGUI, Mask, RectMask2D, LayoutGroups, ContentSizeFitter, AspectRatioFitter

uGUI to UI Toolkit Migration Tool

  Seamlessly migrate your existing uGUI Canvas interfaces to Unity's modern UI Toolkit system with just one click. Save hours of manual conversion work and future-proof your UI codebase.

  What's Included:

   UXML Generation - Automatically converts your Canvas hierarchy to properly structured UXML documents with semantic naming and correct element nesting

   USS Stylesheet Generation - Extracts colors, fonts, spacing, and layout properties into clean, optimized USS stylesheets with CSS variable support

   C# Code Generation - Creates type-safe MonoBehaviour controllers with element bindings, properties, and event callback stubs ready for your logic

   Full Component Support - Converts 20+ uGUI components including Button, Toggle, Slider, InputField, Dropdown, ScrollRect, and more

   Layout Conversion - Transforms HorizontalLayoutGroup, VerticalLayoutGroup, and GridLayoutGroup to CSS Flexbox equivalents

   TextMeshPro Support - Full TMP text conversion with rich text tags, alignment, and styling preserved

   9-Slice Images - Automatically extracts sprite border values for proper slicing in UI Toolkit

  Key Features:

   Intuitive Migration Wizard with step-by-step guidance

   Live UXML preview during configuration

   Multiple layout strategies (Flexbox, Absolute, Mixed)

   Style deduplication and optimization

   Configurable naming conventions

   No runtime dependencies

  Requirements:

  Unity 2021.2 or later

  Perfect for teams modernizing legacy UI or developers wanting to leverage UI Toolkit's performance benefits while preserving existing designs.

• Render Pipeline: URP
• UI System: Unity uGUI + TextMesh Pro
• Resolution independent (Canvas Scaler supported)
• Modular and reusable UI prefabs
• Inventory UI with item details and action buttons (Use / Equip / Drop)
• Settings panels with functional UI logic
• Includes demo scene
• Fully customizable colors, fonts and layouts
• No third-party Asset Store dependencies

Dark Game UI is a clean, modern and fully customizable user interface pack designed for Unity URP projects.

This package includes ready-to-use UI screens such as:

• Inventory system with item details and action buttons
• Settings menu (Audio, Graphics, Controls)
• Main Menu and Pause Menu
• HUD elements (bars, indicators, panels)

All UI elements are built using Unity UI (uGUI) and TextMesh Pro, with a modular structure that allows easy customization and extension. Colors, layouts, animations and scripts can be adjusted to fit different game genres such as RPG, survival, horror, sci-fi or action games.

The package is optimized for performance and designed to be easy to integrate into existing projects.

• 30 VFX prefabs.
• Textures and meshes for various types of effects.
• A versatile custom effects shader.

• Includes a variety of complex visual effect examples, such as magic arrows, buffs/debuffs, hit effects, offensive spells, and lasers, ready for direct use in your project.”
• You can also mix and match the prefabs from the examples to create your own custom effects.
• The examples also include a versatile custom effects shader that covers nearly all features required for VFX. It separates functional modules using variants, allowing you to strip unused feature variants in your project to save resources.

This doll can be CUSTOMIZED with:

- 5 faces * 5 different colors/each

- 5 hairs * 5 different colors/each

- 5head-accessories * 5 different colors/each

- 5 pants * 5 different colors/each

- 5 tops * 5 different colors/each

- 5 shoes * 5 different colors/each

- 5 weapons * 5 different colors/each

- 4 skin colors for each pants and top.

Image size is 1024*1024.

ANIMATIONS included:

- Idle (3)

- Walk

- Run (2)

- Attack (3)

- Cast magic

- Being hit

- Lose / Run away

Sample scene with code (as the video) is included.

The sample scene run well on Unity 6.0 (6000.0.63f1)

There are public functions to change face, hair, top, pants, etc; Or you can change the spite manually.

Please use it for your reference.

Thank you.

PS: We do NOT use AI in any part of the process.

Number of Audio Files: 112

Audio Type: WAV and MP3

Sample rate / bit rate: 48,000 Hz / 24-bit

Loopable: No

Minutes of audio provided: 2:35

Additional : Mono

This voice pack includes various common sounds and phrases for all-purpose NPCs, with two variations for each line. Clean audio recorded in WAV and MP3 formats allows for use in many different settings and genres. 

Included Lines:

• Greetings
• Idles/Observations
• Farewells
• Small Talks
• Curious Lines
• Expressing Gratitude
• Disappointed
• Reacting to Player Actions

Technical Overview:

• Meshes/Prefabs: 205 meshes / 418 prefabs
• Materials: 3 diffuse (non-PBR)
• Textures: 2 × 2048x2048
• UV Mapping: Yes (optimized for palette-based recolors)
• LOD Support: 418 prefabs with LODGroup (3 levels)
• Rigging/Animations: None

Polygon Count (Meshes / LODs):

• Min: 20 tris (e.g. EA_Env_Water_River_Segment_01a_LOD0)
• Median: 364 tris (e.g. EA_Env_Generic_Cloud_Blob_01b_LOD0)
• Max: 2,894 tris (e.g. EA_Env_Bridge_Wood_StoneBase_01c_LOD0)

Polygon Count (Prefabs):

• Min: 42 tris (e.g. EA_Env_Water_River_Segment_01a_PRE)
• Median: 846 tris (e.g. EA_Env_Props_Fence_Mossy_01c_GRAD_PRE Variant)
• Max: 6,076 tris (e.g. EA_Env_Bridge_Wood_StoneBase_01c_GRAD_PRE Variant)

Any questions or suggestions?

Feel free to get in touch with us on our Discord

Build charming, stylized natural environments with LumaGrove: Wonky Woods — a low poly asset pack featuring over 200 modular prefabs in a clean, minimalist visual style. Designed for fantasy, cozy, and adventure games, this collection lets you quickly assemble varied biomes, forest paths, riversides, and meadows.

The package includes prefabs in two variants:
Solid Color – the default, recommended option, fully consistent with my other Asset Store packs.
Gradient – an alternative for projects with a unique, more artistic visual style.
Both variants are organized in a clean folder structure for easy integration and efficient workflow.

Render Pipeline Support: Requires Universal Render Pipeline (URP)

Key Features:

• 200+ modular prefabs (trees, bushes, bridges, fences, rivers, rocks, signs, etc.)
• Palette-based gradient visual style using one shared diffuse texture (2048x2048)
• Lightweight meshes with full UV mapping (Color-ID Grid)
• All prefabs include LODGroups (3 levels)
• Demo scene included with neatly organized asset overview
• Clean folder structure and logical pivot placement

The project started as an exploration of stylized game art and evolved over two years into a complete modular toolkit. Each asset is built to be visually adaptable — allowing you to easily tweak color palettes and overall tone to match your project’s style.

All models use a shared diffuse texture based on color gradients and palette blocks, delivering both visual consistency and high performance. Ideal for mobile titles, top-down games, and lightweight 3D worlds. Assets are modular, optimized, and ready to use out of the box.

Say Hi! Discord | Contact | Webpage | Facebook | Twitter | Bluesky | Mastodon

Prefab Breakdown (201):

• Wooden and stone-based bridges (6)
• Bushes (6)
• Colorful trees (8)
• Flower clumps and clusters (15)
• Ground cover patches (3)
• Grass variants (30+)
• Green trees (10)
• Mushrooms (3)
• Tree stumps (10)
• Beehive (1)
• Individual flowers: red, blue, white (3)
• Stylized clouds (4)
• Meadow trees: colorful (5), green (5)
• Campfire (1)
• Fences: straight (5), crooked (6), mossy stone (5)
• Signposts (6)
• Rocks: large (6), flat (5), roadside (5), gravel (2), stone tables (6)
• Water plants: cattails (2), lily pads (6)
• River segments (20+)
• Water ponds (4)

Technical Info:

• Number of meshes/prefabs: 201
• Texture: 1 × 2048x2048 diffuse
• Materials: 1 (non-PBR)
• UV Mapping: Yes (Color-ID Grid)
• LODs: All 201 prefabs with 3 LOD levels
• Animations: None
• Rigging: None
• Dependencies: None

Geometry Stats:

• Min: 20 tris (river segment)
• Median: 386 tris (fence segment)
• Max: 2,894 tris (bridge)

Sample Prefabs:

• River segment: 42 tris
• Stone fence: 850 tris
• Bush: 1,682 tris
• Bridge: 6,293 tris

Say Hi! Discord | Contact | Webpage | Facebook | Twitter | Bluesky | Mastodon

Low Poly Nature Project Series:

Medieval Slavica | Forest and meadows | Tinty Trees And Rocks | Toon Trees

Available FREE Remake LowPoly Style Packs:

• Remake Swamp Mega Art Pack
• Remake Meadows Mega Art Pack
• Remake Tiny Trees And Rocks Art Pack
• Remake WoodLand Mega Art Pack

Available Masive LowPoly Style Packs:

• LowPoly Stylize Medieval Slavica Town And Village
• LowPoly Stylized Harboria Town
• LowPoly Cartoon Vampiric Town
• LowPoly Stylized Necropoly Graveyard

Available Other Masive Packs

• 1980 - MidPoly Retro Rooms
• Metro 3D Hand Made PixelArt
• High Quality Surreal Sci-Fi Plasticine Plants

Any questions? Contact me

Enjoy and thank you for downloading!

Feel free to leave a review if you enjoy it :-)