Asset Store newest packages

Unity version: 6000.3 (Unity 6.3) or later

Render pipeline: Universal Render Pipeline (URP). Example materials and shaders require URP. The procedural generation code itself is render-pipeline-independent; the example content can be adapted to HDRP or Built-In RP by replacing the included materials.

Editor-only components: the graph editor window, shape editor window, auto-regenerate postprocessor, and baker are editor-only and do not increase runtime build size

Dependencies: none beyond Unity's built-in packages; no Asset Store dependencies required

What is included:

• PlantSketchGenerator — MonoBehaviour component, the entry point for generation
• PlantSketchAsset — ScriptableObject graph container (nodes + edges)
• Graph editor window (Tools → PlantSketch Editor)
• Shape editor window (Tools → PlantSketch Shape Editor)
• Four geometry strategies: Quad, Revolution, Shape Extrusion, Prefab Variant
• Mesh merging and LOD system
• Prefab baker
• Auto-regenerate on asset save
• Full PDF/Markdown user guide with reference documentation
• Four example plants with assets, materials, and strategy configurations
• Two ready-made fallback prefabs (DefaultCylinder, DefaultCylinderShort)
• Plant surface shader (URP Shader Graph) with procedural stripe pattern, cell noise, and alpha mask support — ready to use on any generated geometry

Discord for Support: discord.gg/s6kECDkThw

Plant Sketch is an editor tool for creating procedural plants and organic 3D structures without writing any code. You design a plant by drawing a small graph — dots connected by arrows — and the tool builds the full 3D geometry in your scene. Move a point, change a slider, and the result updates immediately in the viewport.

The tool is built for artists and designers. Every feature is exposed through Unity's Inspector and two custom editor windows; no scripting knowledge is needed to create complex plants, vines, flowers, cacti, tendrils, or similar objects.

How it works

A plant is described as a directed graph. Nodes are anchor points; edges are branches. The angle and length of each edge in the canvas directly determine the growth direction and reach of the corresponding branch in 3D. A compact graph of four or five nodes is enough to produce a fully detailed plant.

Radial Count on any edge multiplies that branch symmetrically around the parent's growth axis — a single petal definition becomes a ring of five, eight, or twelve petals without drawing each one separately. Edge Shift staggers the origin points of child branches along the parent stem, creating alternating leaves or spiralling arrangements from a single graph entry.

Deformers — gravity, drift, noise, segment noise, twirl, and upright correction — shape each branch as it grows, giving curvature and organic irregularity without manual editing. Every parameter has a Min/Max range so the same graph produces natural variety across a group of plants while a numeric seed keeps results fully reproducible.

Geometry strategies

Four strategy types define the 3D shape of each segment:

• Quad — flat two-sided mesh for leaves, petals, and thin organic shapes. Configurable width profile, roll, fold, and twist per strategy asset, with multiple profiles blended through Variation T.
• Revolution — surface of revolution for berries, seed pods, rounded stem joints, and similar compact shapes. Profile curve defines the outline; close caps can be enabled or disabled.
• Shape Extrusion — extrudes a custom 2D cross-section along the branch path. Multiple consecutive edges sharing a Geometry Group Id merge into a single seamless tube — ideal for smooth, continuous stems with natural bends.
• Prefab Variant — spawns any hand-crafted prefab at each segment. A pool of variants lets one edge distribute a mix of different models, chosen randomly per segment.

Strategy assets are reusable and shareable across plants.

Shape Editor

A dedicated bezier editor inside Unity lets you draw the cross-section profiles used by the Shape Extrusion strategy. Points support Auto, Linear, and Free tangent modes. No external tools needed.

Additional features

• LOD support — strategies produce reduced-resolution meshes at distance, with configurable screen-height thresholds per level.
• Mesh merging — edges can be merged into a single mesh per group, reducing draw calls and eliminating seams between consecutive extruded segments.
• Baking — finished plants bake to static meshes and prefabs with one click. Baked results have zero runtime dependency on Plant Sketch.
• Auto Generate — when enabled, the plant regenerates automatically whenever you modify its asset in the editor, with no manual refresh needed.
• Graph export — the Inspector can print a readable text tree of the graph structure for documentation or debugging.
• Four example plants included to demonstrate a range of techniques.

• Unity Editor extension for scene performance analysis and safe-fix workflows.
• Works on the active scene without requiring runtime integration.
• Deterministic rule-based detectors for common scene optimization issues.
• Issue list with severity, impact, safe-fix filtering, and preview panel.
• Safe Preview Fix, Apply Fix, and Revert Fix flow with Unity Undo support.
• Fix history with per-fix revert and session-wide revert support.
• Scene and hierarchy debugging helpers including object selection, pinging, and optional light overlap overlays.
• Saved tool settings for target profile, filters, and scan thresholds.
• Conservative editor-side fixes for supported issue types.
• No Asset Store package dependencies required.

Supported OS:

• Windows
• macOS
• Linux

Opteurism is a Unity Editor extension focused on practical scene optimization workflows. It scans the active scene for common content-side performance risks, presents findings in a clean review window, and lets users inspect, preview, apply, and revert supported fixes without leaving the editor.

The package is designed as a deterministic first-pass optimization assistant. It detects issues such as unnecessary shadow casting on decorative props, overlapping realtime shadow-casting lights, unnecessary colliders on decorative clutter, missing static flags, duplicate material variants, oversized textures for mobile targets, excessive particle usage, and expensive post-processing setups. The tool favors conservative heuristics and safe editor-side changes over aggressive automation.

For supported issue types, users can preview exact proposed property changes before applying them. Fixes use Unity Undo and can be reverted individually or through the session fix history. The extension also includes filtering, issue selection helpers, rescan comparison flow, and light scene overlays for easier debugging.

Technical Details:

• Number of Meshes: 152
• Collision: Yes - automatically generated
• LOD stages: Yes, 1-4 per model
• Number of Prefabs: 165
• Number of Materials: 133
• Number of Particles: 1
• Number of Textures: 273
• Texture Resolutions: up to 4K
• Texture Formats: TGA and PNG

Modular Port is a game-ready industrial environment, including 150+ unique meshes, animated cranes, terrain with paint layers and water.

Example scene included!

URP Version Only!

Meshes:

152 unique meshes included: cargo ship, cargo containers and boxes, packages, barrels, oil tanks, lifts and many other props.

Prefabs:

Animated crane models included.

Forklift prefab included (comes with separate parts - easy to animate later).

Particles:

Steam particles included. 

Scene:

The example port scene is included in this pack!

Terrain with paint layers and water mesh included. Water shader included. 

Contact:

Email: info@dexsoft-games.com

Join our DISCORD server

Table-Based Data Editor

Browse and edit structured data through a powerful table interface inside the Unity Editor. View large datasets in a compact grid and edit values directly without navigating multiple inspectors.

Advanced Search and Filtering

Quickly locate specific records using powerful filtering and search tools. Sort, filter, and group data to focus on the information that matters.

Bulk Editing Tools

Apply changes across many records at once. Perform bulk edits, copy/paste operations, and batch updates to accelerate large-scale data maintenance.

Computed Columns

Define calculated columns based on expressions to derive additional values from existing data. This is particularly useful for balancing gameplay parameters such as DPS, efficiency, or cost ratios.

Flexible Data Architecture

Game Data Workbench Core separates the editor UI from the underlying data source. While ScriptableObjects are supported out of the box, the system can connect to any custom backend through pluggable data providers.

Possible integrations include:

• ScriptableObjects
• JSON or CSV data pipelines
• remote services or APIs
• custom file formats
• proprietary data systems

Import and Export Workflows

Import and export data using common formats such as CSV or JSON. This allows teams to integrate the tool into existing data pipelines or external balancing workflows.

Schema Creator

Define data schemas visually and generate corresponding C# structures. This allows teams to standardize data models and accelerate the creation of new datasets.

Collection and Complex Data Editing

Edit lists and structured data more efficiently than with the standard Unity Inspector, making it easier to manage nested or complex data structures.

Modular Architecture

Game Data Workbench Core is designed to be extended and customized. Developers can add their own:

• data providers
• custom cell drawers
• adapters and parsers
• additional modules

Optional Extensions (Coming soon)

The architecture allows additional modules to extend the workflow, such as:

• Balance tools for analyzing gameplay parameters
• Sync tools for reviewing data changes from external sources
• Validation tools for enforcing data rules and quality checks

A powerful data editing environment for Unity

Game Data Workbench Core is a professional Unity Editor tool designed to make working with structured game data fast, comfortable, and scalable.

Documentation | Discord

Typical Use Cases

Game Data Workbench Core is ideal for projects that manage large amounts of structured gameplay data, such as:

• Item databases for RPGs

• Enemy stats and balancing tables

• Skill and ability configuration

• Economy and crafting systems

• Localization or configuration tables

• Live-ops balancing and tuning

• Any large ScriptableObject dataset

Instead of editing large datasets through multiple inspectors and scattered assets, Game Data Workbench Core provides a table-based editing environment directly inside Unity. This allows developers and designers to browse, search, filter, and edit large amounts of data with the speed and clarity of a spreadsheet while remaining fully integrated into the Unity workflow.

The tool is particularly useful for projects that rely on data-driven gameplay systems, such as RPGs, strategy games, simulations, or live-ops titles where large datasets must be maintained and balanced continuously.

Game Data Workbench Core supports ScriptableObjects out of the box, but its architecture is not limited to them. Through a flexible data provider system, the editor can work with virtually any data backend. This enables teams to connect the editor to JSON files, CSV pipelines, external services, or proprietary formats while still benefiting from a powerful in-editor editing experience.

With advanced filtering, bulk editing tools, computed columns, and import/export workflows, Game Data Workbench Core dramatically improves productivity when managing complex game data.

Whether you are balancing gameplay parameters, maintaining item databases, editing enemy stats, or managing configuration tables, Game Data Workbench Core provides a fast and reliable environment to handle large datasets efficiently.

The package is also modular and extensible, allowing teams to integrate it into their own pipelines and extend its behavior with custom providers, drawers, and modules.

Game Data Workbench Core helps teams move from tedious inspector editing to a structured, scalable, and designer-friendly data workflow inside Unity.

• Converts lists of Vector3 points into simplified directional line patterns
• Pattern recognition system with configurable tolerance for angle and length
• Includes optional fuzzy logic, allowing for increased generosity in recognition
• Designed to interpret likely intended shapes rather than exact input paths
• Pattern presets stored as ScriptableObjects for easy editor configuration
• Supports runtime pattern generation and matching
• Works with any input system that produces positional point data (mouse, touch, controllers, etc.)
• Supports both 2D and 3D input (3D patterns included as experimental)
• Example scene included for drawing and testing patterns
• Playable showcase game demonstrating the system as a core mechanic
• Confirmed compatible with Unity 2022 LTS and newer

Directional Pattern Recognition converts a sequence of Vector3 points into a simplified pattern made of directional line segments. These patterns can then be matched against predefined patterns, allowing you to trigger gameplay events when a player draws the intended symbol.

The system is designed to interpret the likely intent of a drawing, tolerating variation in angle, length, and minor directional inconsistencies.

This makes it suitable for gesture systems where players draw shapes using a mouse, touchscreen, controller, or any input that produces point data.

This package includes an example game showcasing the tool. If you wish to test the tool yourself before getting this package, the game has been made publicly available here: https://connor-hasson.itch.io/runic-defence

• UI framework: Unity UI Toolkit (UIElements) — no UXML or USS files required, all layout is code-driven
• Theme-aware: all colours reference EkiooWindowStyle constants that are calibrated for both Editor light and dark themes; no manual theme detection needed
• EkiooWindowStyle: single source of truth for colours (Bg, Accent, ActiveColor, DoneColor, RemoveColor, TextTitle, TextMuted, BorderColor, …), font sizes (FontSizeXS → FontSizeHeading), spacing (SpaceXS → SpaceXXL), and border radii (RadiusSm, RadiusMd, RadiusBadge, RadiusPill)
• EkiooInspectorBuilder: SectionLabel, Separator, ReadOnlyRow, MetaRow, ActionButton, RuntimeContainer — all returning VisualElement and composable without subclassing
• EkiooWindowBuilder: BuildSection, Badge, BuildTogglePill, FlexRow, ItemRow, Divider, ToolbarContainer, StatusBar, AccentDot — all returning VisualElement
• EkiooSparklineElement: custom VisualElement drawn with Painter2D; call SetSamples(float[], Color) to update — supports grid lines, fill gradient, zero line, and terminal dot
• DependencyChecker: static Require(packageId, displayName, url, sentinelTypeName) called from an [InitializeOnLoad] class; shows a one-time informational dialog per Unity session if a dependency is missing
• AssetDatabaseHelper: GetAssets<T>() — finds all ScriptableObject assets of a given type across the entire project without writing GUID queries by hand
• Assembly: Ekioo.Editor.asmdef, autoReferenced: true, includePlatforms: ["Editor"] — zero runtime overhead, does not appear in builds
• Unity: 6000.0 (Unity 6) or later
• Render pipeline: compatible with Built-in, URP, and HDRP (Editor-only, no rendering dependency)
• Sample: "Style Showcase" — importable from Package Manager; includes an EditorWindow, a CustomEditor, a demo MonoBehaviour, and a demonstration scene

Ekioo Editor Core is the shared foundation used by all Ekioo packages to build consistent, polished editor interfaces in Unity. It provides a centralised style system, a library of ready-to-use UI Toolkit components for both EditorWindow and CustomEditor, and a sparkline renderer — all designed to be dropped into any in-house or third-party Unity toolset.

The package ships a Style Showcase sample that demonstrates every visual primitive interactively, inside a live EditorWindow and a CustomEditor, with real-time Play Mode polling.

Who is this for? Any Unity developer or team building their own editor tools, custom inspectors, or Asset Store packages who wants a solid, theme-aware visual foundation without reinventing the wheel. The package has no runtime footprint — it is 100% Editor-only and adds zero overhead to builds.

What is included?

• A complete colour/typography/spacing palette that automatically adapts to Unity's light and dark themes
• Pre-built CustomEditor components: section headers, read-only rows, metadata rows, action buttons, and a Runtime foldout that disables itself outside Play Mode
• Pre-built EditorWindow components: titled sections, badges, toggle pills, item rows, toolbar, status bar
• A custom VisualElement that renders a data sparkline with grid lines, fill area, and a terminal dot
• A dependency-check mechanism for packages that need to declare optional or required dependencies
• A fully documented, interactive sample importable directly from the Package Manager

Requirements

• Extenject Dependency Injection IOC
• DOTween (HOTween v2)

Supported platforms

Multiplayer Card Game Core was designed for creating PC games. All of the systems will work on mobile, though UI would need adjustements.

Third-Party Notices

Asset uses the Ebbe font under a SIL OFL 1.1 license and Sclate font under a free license; see Third-Party Notices.txt file in package for details.

Create, customize, and launch your own Trading Card Game (TCG) or Collectible Card Game (CCG) in Unity - now with 1v1 Multiplayer built-in.

Card Game Core + Multiplayer Module gives you the complete single-player foundation of the original template, expanded with synchronized head-to-head duels for competitive turn-based gameplay.

Easily add your own cards, spells, heroes, effects, and abilities through a structured workflow, then validate balance in both AI matches and player-vs-player duels without rebuilding your core systems.

Powered by Unity Netcode for GameObjects (NGO) - Unity’s official networking solution for a Unity-native multiplayer foundation and smooth integration into modern Unity projects.

HELPFUL LINKS:

📄 DOCUMENTATION | 🌐 WEBSITE | 💬 DISCORD | 🎥 YOUTUBE

🛠 FEATURES OF CARD GAME CORE MULTIPLAYER INCLUDE:

⚔️ 1v1 Multiplayer Duels

Play head-to-head matches using a synchronized turn-based duel flow.

🎴 Synchronized Mulligan

Both players confirm opening hand changes before turn one begins - stable pacing and fair starts.

🔁 Turn Sync & Authority Rules

Clear “Your Turn / Opponent Turn” control, with consistent turn progression on both clients.

✅ Validated Actions

Actions are checked before being applied, keeping matches stable, predictable, and competitive.

🏁 Results & Rematch Flow

Finish matches cleanly, review outcomes, and start the next duel fast.

🎯 Where This Asset Fits Best

Card Game Core + Multiplayer Module is designed for projects where deck building, card collection, turn-based combat flow, and ongoing balance tuning are central - now extended with competitive 1v1 PvP.

Competitive CCG / 1v1 PvP Foundations

Deck builder, collection progression, and polished duel flow suitable for head-to-head play - in the spirit of Hearthstone, Legends of Runeterra, or Shadowverse.

Hero-Based Card Combat Systems

Support for heroes, spells, units, and clear combat feedback in a clean turn-based structure - similar in feel to Gwent or KARDS.

Prototype-to-Production TCG Projects

Ship a playable vertical slice faster with complete core systems plus multiplayer duel support - ideal when you want to validate rulesets, pacing, and balance early.

🔗 Plays Well With These Asset Categories

This asset stack integrates smoothly with the systems commonly used alongside TCG/CCG projects:

Backend, Player Profiles & Cloud Save

Account-based collections, cross-device persistence, secure inventory storage.

Card Pack, Gacha & Loot Systems

Booster packs, rarity pools, pity rules, pack-opening UX.

LiveOps, Events & Remote Config

Balance updates, rotating formats, limited-time events, weekly rule changes.

Quests, Daily Tasks & Battle Pass Systems

Retention loops rewarding matches, wins, and collection milestones.

Ranked Play, Leaderboards & Tournaments

Ladders, seasonal progression, brackets, competitive ranking layers.

Economy, Shops & IAP Frameworks

Currency sinks, bundles, cosmetics, starter packs, store flows.

Analytics & A/B Testing Tools

Track deck meta, win rates, funnels, churn signals for faster iteration.

Content Pipelines (CSV / Sheets-Based Tools)

Scalable card authoring and balancing via spreadsheets and localization tables.

Card Game Core is designed to fit into modern TCG/CCG production pipelines and works smoothly alongside commonly used Unity tools for multiplayer, data management, and scalable workflows.

Possible Integrations:

• Odin Inspector & Serializer
• Easy Save – The Complete Save System
• PlayFab Unity SDK
• Behavior Designer Pro - DOTS Powered Behavior Trees
• Toolkit for Steamworks 2026
• Hot Reload
• vHierarchy 2
• Scriptable Sheets
• Sensor Toolkit 2
• DOTween (HOTween v2)
• I2 Localization
• Master Audio 2024
• Amplify Shader Editor
• Super Text Mesh
• Rewired
• Curvy Splines
• Behavior Designer

Core Component:

• NPC Controller Script – central “brain” managing NPC behavior, movement, interactions, and animations.

Movement & Navigation:

• Integrated with Unity NavMesh for pathfinding
• Smooth animation blending via Animator.CrossFade
• Target-based movement logic for dynamic navigation

Interactions:

• NPC-to-NPC conversations (visual / timed interactions)
• Object-based interactions (pick up, use, activate)
• Interruptible actions with state-safe fallback

Zone Awareness:

• Limit NPC Movable Space.

Animation & Visuals:

• Assign animations to world objects
• NPCs can visually interact or appear to talk to each other
• Supports environment storytelling via actors and animated objects

Customization & Extensibility:

• Adjustable parameters for movement speed, interaction timing, zone behavior
• Modular namespace and clean architecture for easy integration into projects
• Lightweight and optimized for performance

Setup:

1. Add NPC Controller to your NPC prefab
2. Assign Animator and optional NavMeshAgent
3. Configure zones, interactions, and targets

Ideal For:

• RPGs, adventure games, simulations, fantasy worlds, open-world games
• Developers who want quick setup with modular, extensible NPC behavior

Bring your world to life with a powerful and flexible NPC behavior system designed to create believable, dynamic characters with minimal setup.

This asset allows you to create NPCs that move naturally, interact with the environment, talk to each other, and respond to different zones in your world — making your game feel alive instead of static.

• Deterministic snapshot storage for repeatable comparisons
• Baseline vs current diff with increases, decreases, new, and removed entries
• Budget thresholds for total variants, delta variants, percent delta, and per-shader caps
• Ignore rules and allow rules for cleaner signal
• Latest-passing baseline workflow for CI promotion
• Incomplete snapshot detection with fail-fast CI gating
• Batchmode runner with stable exit codes for automation

📜 Docs

Shader Variant Budget & CI Guard helps Unity teams find, understand, and stop shader variant regressions before those regressions turn into bigger build problems. Instead of guessing why variant counts suddenly went up, you can capture snapshots, compare builds, and see exactly what changed. The tool is made for developers who want a clear workflow, not a vague warning after the damage is already done.

The core job of this tool is simple: it tracks shader variant counts over time and tells you when they move in the wrong direction. After a build, it reads the variant data from Editor.log, saves a deterministic snapshot, and lets you compare a baseline build against a current build. You can quickly see total variant changes, per-shader changes, new entries, removed entries, and where the biggest increases came from.

This matters because shader variant growth is easy to miss. A project can look fine for weeks, then slowly collect extra variants through shader changes, keyword changes, package updates, or content changes across teams. By the time someone notices, the project may already have slower build iteration, harder debugging, and a less predictable pipeline. This tool gives you a practical guardrail so shader variants stay visible and controlled.

Inside the Unity Editor, the workflow is built to be direct and easy to use. You open the Shader Variant Guard window, capture or load snapshots, choose a baseline and current result, and run a comparison. The results are shown with summary cards, filtered diff views, search tools, sorting, and diagnostics. That means you do not need to dig through raw logs by hand just to answer basic questions like “what changed?” or “which shader caused this jump?”

The budget system is where this becomes a real production tool, not just a viewer. You can define hard limits and warning limits for total variants, delta variants, percent delta, and per-shader counts. When the current snapshot breaks those rules, the tool reports the problem clearly. You can also add ignore rules and allow rules so the results stay focused on the shader changes that actually matter to your team.

For teams working in CI, this tool is built to gate builds automatically. It includes a batchmode runner with stable exit codes, external JSON budget support, report export options, and a latest-passing baseline workflow. In practice, that means you can run it in automated validation and fail a build when shader variant counts cross the limits you defined. Instead of noticing regressions later, your pipeline can stop them at the point where they are introduced.

Baseline management is handled with real production needs in mind. The tool can compare against the latest snapshot, the latest passing snapshot, or a specific snapshot path. It also supports profile-aware baseline matching, latest-passing index overrides, and optional baseline promotion in CI. This makes it useful for teams that need a repeatable baseline workflow across multiple branches, build targets, or build profiles.

The tool also protects you from low-quality data. If a snapshot is incomplete, the guard can detect that and fail the check instead of silently giving you bad results. This is important because a broken or partial snapshot can hide a real regression. The incomplete-snapshot gating makes the tool more reliable when used in automated environments where confidence in the data matters.

The editor experience is practical, not bloated. Settings are available in Project Settings, with normal and advanced sections, browse buttons for paths, clear controls for storage and retention, and guidance for unusual values. The main window supports snapshot-first comparisons, filtering, search, diff tabs, and diagnostics export. There is also a one-click Generate Example Test Workflow action so you can seed realistic sample data and understand the tool fast.

This asset is a strong fit if your project has grown past the point where manual checking is enough. If you are shipping on multiple targets, working with a team, reviewing build health in CI, or trying to stop shader complexity from creeping up over time, this tool gives you structure and visibility. It is especially useful when you want to turn shader variant control into a repeatable process instead of relying on memory, guesswork, or occasional cleanup passes.

What you are really buying is control. You get a way to measure shader variant changes, compare builds with confidence, define budgets that match your project, and enforce those budgets both in the Editor and in CI. If shader variants have ever felt like a hidden problem in your pipeline, Shader Variant Budget & CI Guard turns them into something visible, trackable, and manageable.

• One-click generation of clean 2D icons from 3D models

• Automatically exports PNG icons with transparent backgrounds

• Automatically imports icons as Sprite (2D and UI)

• Preview camera shows the final icon in Game View before export

• Export directly into the Unity project or to an external location

• Automatic folder creation for icon exports

• Ideal for RPG inventory icons, item icons, and UI thumbnails

IconStudio is a lightweight Unity editor tool that converts 3D models into clean, UI-ready 2D icons with a single click.

Simply place your model under the ItemSpawn object, position it at (0,0,0), adjust rotation as desired, and export. IconStudio automatically renders the object to a transparent PNG and configures the texture import settings for immediate use in Unity UI.

Designed for developers who want their UI icons to perfectly match their 3D models, IconStudio makes it easy to generate consistent, professional-looking icons without needing design experience or spending hours creating custom artwork. It works out of the box in clean Unity projects and supports Built-in, URP, and HDRP pipelines.

Perfect for inventory systems, RPGs, strategy games, mobile UI, or any project requiring fast icon generation.

Stop wiring everything together.

Evently introduces a clean and deterministic event-driven communication layer for Unity. Instead of tightly coupling systems with direct references, singletons, or manager chains, Evently allows components to communicate through a scalable publish/subscribe event architecture. This keeps your codebase modular, maintainable, and significantly easier to extend as your project grows.

No string-based events. 

No hidden dependencies. 

No fragile object graphs.

Evently provides a type-safe event system for Unity that enables systems to react to events without knowing about each other.

Core Capabilities

• Global Event Bus – project-wide messaging system for communication between gameplay systems
• Scoped Event Buses – isolated buses for modular features, UI panels, mini-games, tools, or temporary systems
• Disposable Subscriptions – explicit lifetime control for every event listener
• Auto-Bound MonoBehaviour Listeners – automatic cleanup when Unity objects are destroyed
• Lightweight Debug Window – inspect active events and listener counts directly in the Unity Editor

Event Dispatching, Done Right

• Type-Safe Events – strongly-typed contracts (structs or classes), zero magic strings
• Fluent Listener API – chainable configuratio for expressive and maintainable subscriptions
• Duplicate Subscription Protection – prevent accidental multiple registrations
• Exception-Safe Dispatching – one failing listener won’t break the entire event chain
• Minimal Allocations – optimized for performance-sensitive and mobile projects

Documentation

FEATURES

• Uses Burst compiler and Jobs for optimizing performance.
• Extremely low GC footprint.
• Simple API.

VERIFIED PLATFORMS

Windows, Linux, Android, WebGL.

SUPPORTED PLATFORMS

Windows, Linux, MacOS, Unity WebGL, Android, iOS, PlayStation, Xbox, Switch.

Requires Collections package v2.6.5+

OP Tween

The package contains the Engine dll. The Burst code open sourced. And a demo folder showcasing OP Tween's use.

The package was built with simplicity and performance in mind, allowing for easy and efficient Transform tweening. The engine keeps a low GC footprint with no allocations except on initialization and resizing.

Why OP Tween?

- Best performant tweening engine thus far.

- Has by far the least GC footprint compared to other well established tweening engines.

- Future proof. Using Unity's Burst compiler OP Tween benefits from any improvements done on this worked on module.

Warning!

It is highly recommended to use the open source Burst code as is! Any changes made could easily affect performance.

• 25 FBX models 8 → 10,026 triangles
• 200 PBR Textures (2048x2048)
• 66 Materials (Metallic Workflow) Albedo (BaseMap) Normal MaskMap (Metallic + Smoothness)
• 111 Prefabs Drag-and-drop ready
• Texture Variants Floors: 8 Walls: 4 Doors: 2 Surgical tables: 2

Hospital Horror Props Pack

Create immersive and terrifying hospital environments for horror games, escape rooms, or cinematic scenes.
This pack provides a complete set of modular medical props and building elements, allowing you to quickly build detailed, atmospheric hospital interiors with ease.

Key Features

• Complete modular hospital environment
• Designed for dark, horror-focused scenes
• Easy drag-and-drop workflow
• Optimized for real-time performance
• Compatible with URP and HDRP

Ideal For

• Survival horror games
• Psychological horror experiences
• Escape room projects
• Unity or Unreal cinematic scenes

What’s Included

This pack contains 25 unique 3D models, organized into the following categories:

Medical Props

• Hospital beds (standard and wheeled)
• Empty and fully dressed variants (mattress and sheets)

Surgical Equipment

• Surgical table
• Overhead surgical light

Furniture

• Medical cabinet
• Carts (standard, wheeled, and damaged variants)
• Wheelchair

Modular Building System

• Wall segments (1m, 4m, corner, door cut, window cut)
• Floor tiles
• Ceiling tiles
• Doors (single and double)
• Windows

Lighting

• Ceiling light fixture with emissive material

Technical Details

• Triangle count: 8 – 10,026 per asset
• 25 FBX models
• 111 prefabs (drag-and-drop ready)

Textures & Materials

• 200 PBR textures (2048x2048)
• 66 materials (metallic workflow)
• Includes:Albedo (Base Map)
  Normal maps
  Mask maps (Metallic + Smoothness)
  

Variations

• Surgical tables: 2 texture variants
• Floors: 8 variants
• Walls: 4 variants
• Doors: 2 variants

Render Pipeline Support

Fully compatible with:

• Universal Render Pipeline (URP)
• High Definition Render Pipeline (HDRP)

Includes separate materials and prefabs for each pipeline.
No additional setup required — just import and use.

Performance & Optimization

• Low-poly and performance-friendly
• Clean UV mapping
• Optimized for real-time applications
• Suitable for PC and mid-range hardware

Modular Workflow

• Snap-based modular system
• Easily build rooms, corridors, and full hospital layouts
• Reusable components for fast level design

Why Choose This Pack?

• Complete hospital environment solution
• High-quality PBR assets
• Modular and scalable design
• Production-ready for games

A small monster suitable for 2D top-down view retro pixel-art games.

The Sprouting Seeds are cute, but don't let their innocent looks fool you. They are perfect for sunny meadows, old greenhouses, or overgrown ruin game scenes.

4-Directional Movement: Animated in Top, Down, Left, and Right views.

Dynamic Attack & Death: High-frame-count animations for a smooth, high-quality feel.



Aseprite Source Files: Easily tweak colors or frame rates to fit your game.

Package including：

Idle: 4 frames x 4 directions

Move: 8 frames x 4 directions

Rush Attack: 10 frames x 4 directions

Spinning Attack: Spinning Loop 3 frames (can be uesed in all directions), Spinning Start 15 frames x 4 directions, Spinning End 5 frames x 4 directions, Spinning Dizzy 11 frames x 4 directions.

Hurt: 1 frames x 4 directions

Death: 10 frames (Left&Right)

Easy to use, start your first fight enemy right now!

10 high-quality poison effect for pixelart

Poison_Effect_01 -- 20 frames

Poison_Effect_02 -- 7 frames

Poison_Effect_03 -- 12 frames

Poison_Effect_04 -- 17 frames

Poison_Effect_05 -- 20 frames

Poison_Effect_06 -- 6 frames

Poison_Effect_07 -- 15 frames

Poison_Effect_08 -- 8 frames

Poison_Effect_09 -- 29 frames

Poison_Effect_10 -- 9 frames

Including aseprite files and sprite sheet.

You can edit the sprites freely, but cannot repackage, resell or redistribute them in any way.

Enhance your 2D RPG or Action game with this comprehensive collection of 24 hand-crafted pixel art particle effects. These effects are pre-configured as Unity Prefabs, allowing for immediate integration into your character or environment logic.



Effect List (24 Total)

Burn: Rising orange flames and embers.

Cold: A frozen blue crystalline overlay.

Electric: Sharp purple electrical arcs.

Paralysis: Yellow jolting currents.

Poisoning: Bubbling green toxic gas.

Blood: Splattering red droplets for bleed effects.

Stench: Murky purple haze and bubbles.

Petrifaction: A stony, desaturated statue effect.

Stun: Rotating golden halos.

Confusion: Circling stars above the head.

Blind: Obscuring cloud or "miss" indicators.

Sleep: Classic floating "Z" icons.

Fear: Dark purple skull icons and trembling energy.

Slow: Downward-moving particles indicating heavy weight.

Heal: Vibrant green crosses and sparkles.

Food: Health restoration through nourishment visuals.

Purify: Clean white light for debuff removal.

PowerUp: Golden upward arrows and glowing aura.

Fast: Speed trails and swift movement sparks.

Star: Shimmering celestial energy.

Energy: Concentrated aura for mana or power.

Vampire: Red life-steal absorption effects.

Rage: Intense focused combat energy.

Demon: Dark, ominous supernatural aura.



Easy to use and ready for your project!

You can edit the sprites freely, but cannot repackage, resell or redistribute them in any way.

A set of high-quality fire pixel-art effects.​​Whether you are building a platformer, a top-down ARPG, or a classic rogue-lite,

This pack contains 5 projectiles and 3 impacts:



Package including：

effect_state_blind

FireFX_Set01_02: 6 frames.

FireFX_Set01_03: 6 frames.

FireFX_Set01_04: 6 frames.

FireFX_Set01_05: 9 frame.

FireFX_Set01_06: 7 frames.

FireFX_Set01_07: 14 frames.

FireFX_Set01_08: 5 frame.



All animations have Aseprite file and sprite-sheet file.

Easy to use and ready for your project!



You can edit the sprites freely, but cannot repackage, resell or redistribute them in any way.

A group of cute animated emoticons, to makes your conversation more interesting！

Includes 18 emoticons, 32*32 sized:

*Sigh - 10 frames

*Question - 10 frames

*Sweat - 10 frames

*Idea - 10 frames

*Whisper - 10 frames

*Happy - 10 frames

*Anger - 10 frames

*Sad - 10 frames

*Laugh - 10 frames

*Shock - 10 frames

*Excite - 5 frames

*Fingers - 10 frames

*Tension - 5 frames

*Greedy - frame 10

*Pride - 10 frames

*Heart - 10 frames

*Depression - 10 frames

*Shyness - 10 frames

Including aseprite files, sprite sheet and preview gif.

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

License

- You can use the assets for commercial or personal game projects.( I’m so glad to see if you can make some games using these assets! )

- You can edit the assets freely, but cannot repackage, resell or redistribute them in any way.

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

A small monster suitable for 2D top-down view retro pixel-art games.

Watch out for the shadows! Emerging from the dampest corners of the underground, the Green Spider is a classic foe for any top-down adventure. With its vibrant green shell and glowing red eyes, it stands out perfectly in dark dungeon environments.

4-Directional Movement: Animated in Top, Down, Left, and Right views.

Dynamic Attack & Death: High-frame-count animations for a smooth, high-quality feel.

Aseprite Source Files: Easily tweak colors or frame rates to fit your game.

Package including：

Idle: 8 frames x 4 directions

Move: 6 frames x 4 directions

Attack: 9 frames x 4 directions

Hurt: 1 frames x 4 directions

Death: 18 frames (Only down)

Easy to use, start your first fight enemy right now!

You can edit the sprites freely, but cannot repackage, resell or redistribute them in any way.

=== Content ===

- Number of Unique Meshes: 32.

- Number of Unique Materials: 44.

- Number of polygons: 2 to 2.784.

- Texture sizes used:

  - 2048x2048 (62)

  - 1024x1024 (1)

- Types of texture maps: BaseMap, MaskMap, NormalMap.

=== Statistics ===

The package includes:

  - 13 FBX models.

  - 23 Prefabs.

  - 44 Materials.

  - 63 Textures.

  - 1 Demo Scene(s) with preconfigured Lightmap.

=== Notes ===

- Optimized 3D Models for performance.

- VR-ready assets.

- Baked GI included.

- Post Processing Setup provided.

Lumina Art Gallery – Modern VR Environment Pack is a high-quality 3D environment designed for Unity, crafted to deliver an immersive and realistic virtual exhibition experience.

This environment features a spacious, minimalist gallery with clean white architecture, polished reflective floors, and a soft illuminated grid ceiling that enhances the visual atmosphere. The scene includes multiple framed artworks (abstract, portraits, and modern compositions), structural columns, and a contemporary bench, creating a refined museum-like space.

Fully optimized for VR and real-time applications, this asset ensures smooth performance while maintaining high visual quality. The modular-friendly layout allows easy customization—replace artworks, adjust lighting, or expand the gallery to fit your project.

Whether you're building a virtual museum, an interactive experience, or a cinematic environment, Lumina Art Gallery provides a versatile and elegant foundation.

Key Features:

• High-quality modern art gallery environment
• Fully optimized for VR (smooth performance)
• Minimalist architecture with clean lighting
• Multiple artworks included (easy to replace)
• Reflective polished floor and soft global lighting
• Modular-friendly layout
• Ready for games, VR, and cinematics

Use Cases:

• Virtual reality (VR) exhibitions
• Art gallery / museum scenes
• Architectural visualization
• First-person exploration games
• Cinematic environments