Asset Store newest packages

• Number of assets : 1
• Texture Dimensions: 2048/2048
• Color and normal map
• Compatible with Built-in & URP
• Tris: 35.6k 
• Verts: 71.0k

Romanian Folk Wooden Gazebo is a 3D asset inspired by traditional Romanian rural architecture and Carpathian folk aesthetics.

Built entirely from wood, the gazebo features a steep pitched roof, carved structural elements, and subtle geometric folk details commonly found in traditional Romanian craftsmanship.

This asset works perfectly as a:

• village centerpiece
• garden or park structure
• resting or meeting spot
• decorative prop for medieval, folk, or fantasy settings

URP and Built-In

Number of assets : 1

• Asset Type: 3D Modular Environment Pack
• Style: Low Poly / Stylized Fantasy
• Number of Assets: 150+
• Number of Meshes/Prefabs: 150+
• Polygon Count:Minimum: ~15 tris (small props)
  Maximum: ~3,000 tris (largest structures)
• Textures:Number of Textures: 4
  Texture Dimensions: 512x512
  Texture Type: Texture Atlas (optimized)
• Materials:Non-PBR stylized materials
  Uses texture atlas for performance optimization
• Rigging: Yes (characters only)
• Animation Count: 0
• Animations: Not included
• Character Note:
  Characters do not include fingers or finger bones (optimized low poly design)
• LOD Information:
  No LODs included
• Compatibility:Built-in Render Pipeline: Yes
  URP: Compatible (material upgrade may be required)
  HDRP: Compatible (material upgrade may be required)
• File Formats Included:
  FBX (Unity-ready)

📦 Low Poly Elf Village – Modular Fantasy Environment Pack

Create rich stylized fantasy environments with this complete low poly elf village asset pack. Designed as an all-in-one solution, it includes everything you need to build mystical forests, elven settlements, hidden outposts, and magical marketplaces.

Perfect for RPGs, strategy games, adventure games, and stylized projects, this pack features a flexible modular system that allows you to quickly design unique structures and immersive worlds.

🌟 Key Features

• Fully Modular Building System
  Mix and match walls, roofs, doors, pillars, and platforms to create unique elven architecture.
• Complete Environment Kit
  Build full scenes with terrain pieces, trees, rocks, foliage, and ground variations.
• Props & Decorations
  Includes a wide range of props such as barrels, lanterns, crates, fences, and magical elements.
• Rigged Characters Included
  Male and female elf characters ready for use (no animations included).
• Optimized Performance
  Uses texture atlas workflow for efficient rendering, suitable for mobile, VR, and PC.
• Stylized Low Poly Art Style
  Clean, consistent visuals ideal for fantasy and stylized games.

🎮 Use Cases

• Fantasy RPGs
• Strategy and simulation games
• Adventure and exploration games
• Stylized environments
• Level design and prototyping

📊 Package Content

• 150+ assets total
• Modular buildings (walls, roofs, doors, platforms, bridges)
• Environment assets (trees, rocks, terrain, foliage)
• Props (barrels, lanterns, crates, furniture, tools)
• Decorations (fences, banners, magical objects)
• 2 rigged elf characters
• Multiple texture atlases for optimized performance

⚙️ Technical Details

• Style: Low Poly / Stylized Fantasy
• Formats: FBX (Unity-ready)
• Textures: Optimized atlas workflow
• Rigging: Characters are rigged (no animations included)

⚠️ Character Note

• Characters do not include fingers or finger bones (simplified hand geometry for performance and stylized design)

🧩 Customization

All assets are modular and easy to customize:

• Combine building parts to create unique structures
• Reuse assets to design varied environments
• Easily integrate into existing Unity projects

🖥️ Compatibility

• Built for Unity (Built-in Render Pipeline)
• Compatible with URP and HDRP (material upgrade may be required)

💡 Ideal For

Developers who want a complete, ready-to-use fantasy environment pack with modular flexibility and optimized performance.

📊 Content Overview

• Total Monsters: 53
• Total Sprites: 150+
• Variations per Monster: ~3

🖼 Graphics

• Resolution: 512x512 px
• Format: PNG (transparent background)
• Style: Clean 2D / stylized fantasy
• Pivot: Centered (ready for placement & animation)

📁 Project Structure

• Organized as:
  Assets/Monsters/<MonsterName>/
• Clean naming conventions
• Easy navigation and scalability

🎮 Included Extras

• ✅ Demo Scene – quick preview of assets in action
• ✅ UI Preview System – browse monsters inside Unity
• ✅ Basic Script – simple interaction / showcase logic

🔧 Compatibility

• Unity Built-in Render Pipeline
• Universal Render Pipeline (URP)
• Compatible with PC & Mobile

⚡ Performance

• Lightweight textures
• Optimized for mobile games
• Fast import and setup

Bring your game world to life with a rich collection of fantasy monsters, designed for clarity, consistency, and fast integration.

This pack includes 53 unique monster categories, each with multiple variations (typically 3 per monster), resulting in 150+ high-quality sprites.

Perfect for:
🎮 RPGs
🕹 Platformers
⚔ Roguelikes
📱 Mobile games

👾 Full Monster List

All monsters are neatly organized into individual folders:

👾 Monster Categories

Amphibian, Angler, Bat, Bear, Beetle, Bones, Brawler, Brute, Chick, Cloud, Cyclops, Demon, Dragon, Dragonflare, Droplet, Dummy, Egg, Feline, Flowerman, Ghoul, Gnome, Griffin, Haunt, Hellhound, Hen, Hog, Jellyfish, Knight, Mimic, Minion, Mouse, Pumpkin, Pup, Ram, Reaper, Scorpion, Serpent, Shadow-Keeper, Shroom, Skeleton, Spectre, Spider, Summoner, Swampman, The-Overseer, Treeman, Troll, Undead, Void, Wall, Wisp, Wyrm, Wyrven

🔥 What Makes This Pack Stand Out

✔ 150+ sprites (≈3 variations per monster)
✔ 53 unique enemy types
✔ Clean and consistent visual style
✔ Ready for immediate use in Unity
✔ Easy to expand and customize

🧩 Use Cases

• Enemy systems for RPG & adventure games
• Platformer hazards and AI characters
• Roguelike enemy pools
• Rapid prototyping
• Mobile-ready projects

• Dedicated custom Editor Window for enhanced log management
• Advanced multi-level log filtering (Errors, Warnings, Logs)
• Real-time log search with instant results
• Clean, structured, and readable log layout
• Organized log grouping for improved clarity
• Efficient handling of large log volumes
• Streamlined debugging workflow inside the Editor
• Lightweight implementation with minimal performance impact
• Simple integration into any existing project
• No runtime components – Editor-only architecture
• No external dependencies or additional packages required
• Built-in code viewer with customizable color

Debug Console Studio is a powerful logging and debugging solution designed exclusively for the Editor. Built to improve clarity, organization, and efficiency, it enhances the way developers view and manage logs during development.

Unlike the default Console, Debug Console Studio provides a dedicated custom Editor Window with advanced filtering, real-time search, and structured log organization to help you identify and resolve issues faster.

A built-in code viewer with customizable color improves readability and makes stack traces easier to analyze. Adjust color settings to match your workflow and reduce visual fatigue during long debugging sessions.

Whether you're working on small prototypes or large-scale projects, Debug Console Studio helps streamline your debugging process and maintain better control over your development environment.

Number of Materials:6

Number of Material Instances:11

Number of Textures:67

Texture Resolutions: 2048x2048, 4096x4096

Extra bones:

Jaw

eye_l

eye_r

Eyelashes_l

Eyelashes_r

It has a compatible humanoid rig and its own custom animations.

In the model it is desirable to use a shader with a two-sided display of polygons.

Number of Animations:27

Animation Types:

Attack(x3)

Death(x4)

GetHit(x4)

Idle(x6)

Walk(x4)

Run(x2)

Strafe l/r(x4)

faces 51795

verts 54274

tris 98894

• Unique Meshes: 140

• Materials: 1 shared material (color)

• Textures: 1 universal texture (256px)

• Vertices per mesh: 12 - 4,360

• Total vertices: 76,766

• Colliders: Auto-generated

• No rigging or animation

• URP + Built-in compatible

Start building your industrial world today!

🏭 LOW POLY INDUSTRIAL LOCATIONS 🏭

• 10 Unique Industrial Locations

• 181 Ready-to-Use Prefabs

• URP Materials (Default)

• Built-in Materials (Included)

• 1 Universal Texture (256px) shared across all models

• Demo Scene Included

💡 Note: This package is optimized for URP by default (recommended

for best performance). Built-in materials are included for legacy

project compatibility.

📋 PREFAB BREAKDOWN (181 Total):

🏭Locations (x10)

10 Unique Industrial-Style Locations

🚞Environment (x58)

Containers, Dumpsters, Fences, Road Barriers, Ventilation Systems,

Water Treatment Facilities, Box, Atom Sculpture, Concrete Pier,

Cooling Tower, Crane, Mooring, Oil Storage, Oil Tank, Plant Border,

Rail, Road Post, Safety Railing, Solar Battery, Station Pipe,

Technical Berth, Tire, Traffic Cone, Tunnel, Vertical Tank,

Wind Station, Wooden Pallet

🏠Buildings (x16)

Checkpoints, Power Plants, Recycling Plants, Water Treatment Buildings,

Boiler Room, Hydro Power Station, Industrial Plant, Oil Building,

Warehouse

🌏Terrain (x10)

Different Ground Patches for Industrial Locations

🌳Trees (x18)

Trees, Fir Trees, Flat Trees

🗿Stones (x12)

Various low-poly stones

🌊Waters (x7)

Water Surfaces for Multiple Locations

🌿Plants (x14)

Flowers, Bushes, Grass

🚗Vehicles (x46)

Hatchbacks, Minivans, Pickups, Sedans, Trucks, Garbage Truck, Wagons, Loader, Cargo Ship, Oil Tanker

🎮 PERFECT FOR:

• City builder games

• Industrial simulations

• Educational projects

• Rapid prototyping

• Learning Unity

💬 Enjoying Low Poly Industrial Locations?

If this pack helped your project, please consider leaving an

honest review on the Asset Store. Your feedback helps me create

better assets for the community!

📧 Questions or Ideas?

Have a question about this pack? Want to suggest an asset for

future updates? I'd love to hear from you!

✉️ Contact: yury.vladyka@gmail.com

Thank you for your support!🙏

• Wheel Picker Core – reusable scrolling wheel selection system

• Date Picker – day / month / year selection

• Time Picker – hour / minute / AM-PM format

• Custom Picker – configurable list of selectable values

• Example Scene demonstrating setup and usage

• Prefabs for quick integration

A smooth and customizable Wheel Picker UI component for games/apps that allows users to select values using a scrolling wheel interface.

This asset makes it easy to implement date pickers, time picker, and custom value pickers commonly used in mobile apps and modern game interfaces.

Designed to be lightweight, flexible, and easy to integrate with UI systems.

✨ Features

• Smooth scrolling wheel selection

• Built-in Date Picker (day / month / year) (Month Formate)

• Built-in Time Picker (hour / minute / AM-PM)

• Fully customizable Custom Picker (Supported Text , Image etc..)

• Supported your custom theme ui

• Snap-to-center value selection

• Simple inspector-based configuration

• Lightweight and optimized performance

• Clean and easy-to-understand scripts

• 115 line-style icons
• Each icons is of size 512x512 px
• Ready for use in game development, app design, or UI/UX projects
• Every icon is in flat white color, customizable to any color.

This icon pack includes a collection of high-quality 2D casual-style icons that cover a variety of in-game elements. The icons are designed in a simple yet effective style, making them versatile for many projects, including mobile games, apps, and websites. The pack contains elements like achievement badges, alert notifications, and armor, providing all the necessary components for your game's interface. These icons are customizable and ready to integrate into your project, ensuring both clarity and visual appeal.

• 114 flat-style icons
• Each icons is of size 512x512 px
• Ready for use in game development, app design, or UI/UX projects
• Every icon is in flat white color, customizable to any color.

The "Icons Pack - Flat Style" features a collection of 114 high-quality icons in a sleek, flat design, ideal for developers looking to enhance their UI/UX design. These icons are fully customizable, suitable for a wide range of genres including mobile, desktop, and web applications.

Number of textures: 108

Texture dimensions: 256 x 256, 512 x 512

Polygon count:

Bike 1: 23.1k

Bike 2: 29.8k

Bike 3: 15.8k

Bike 4: 17.8k

Bike 5: 8.9k

Bike 6: 15.7k

Bike 7: 17.9k

Bike 8: 23.3k

Bike 9: 21.1k

Bike 10: 15.9k

Bike 11: 29.8k

Bike 12: 30.4k

Bike 13: 34.4k

Bike 14: 19.7k

Bike 15: 29.3k

Bike 16: 18.6k

Bike 17: 25.3k

Bike 18: 27.3k

Bike 19: 20.2k

Bike 20: 19k

Bike 21: 20.1k

Bike 22: 16.6k

Bike 23: 17.6k

Bike 24: 16.9k

Bike 25: 20k

Bike 26: 23.2k

Bike 27: 19.9k

Bike 28: 15.3k

Bike 29: 22.3k

Bike 30: 18k

Bike 31: 27.3k

Bike 32: 25.2k

Bike 33: 23.1k

Bike 34: 27.4k

Bike 35: 22.4k

Bike 36: 22.7k

Bike 37: 29.8k

Minimum polygon count: 8.9k

Maximum polygon count : 34.4k

Number of Prefabs: 37

Rigging: Yes

UV mapping: Yes

Turbocharge your next bike or motorcycle racing game, bike stunt game, open-world adventure game, or urban simulation with the Ultimate Motorcycle Pack. This massive collection features 37 highly detailed, completely unique motorcycle models, offering an unmatched variety of styles to populate your game world.

Whether you need high speed street racing, off road dirt tracking, or casual city commuting, this one insane collection has you covered. Based on the diverse roster, this pack includes models spanning every major motorcycle discipline

Key Features:

• Massive Variety (37 Unique Models): No simple palette swaps here. Every single bike features a unique chassis, bodywork, and design.
• Game-Ready & Optimized: Carefully modeled to balance high visual fidelity with optimal performance, making them perfect for both PC/Console and Mobile platforms.
• Fully Rigged for Animation: Wheels, handlebars, and chassis are rigged and properly pivoted, ensuring a smooth ride when hooked up to your custom vehicle controller.
• PBR Materials: Built with Physically Based Rendering in mind to ensure realistic metal, plastic, rubber, and paint reactions to your game's lighting.
• Vibrant Color Palettes: Eye-catching, bright finishes that pop on screen right out of the box.

Included Vehicle Categories:

• Sportbikes & Superbikes: Sleek, aerodynamic, and fully faired for high speed racing.
• Cruisers & Choppers: Classic, laid back designs with exposed engines and custom exhausts.
• Adventure & Touring Bikes: Heavy duty frames equipped with hard case luggage panniers and tall windshields for the long haul.
• Dirt Bikes & Dual-Sports: High clearance suspensions and rugged frames built for off-road tracks
• Streetfighters & Naked Bikes: Aggressive, stripped-down urban street machines
• Scooters & Mopeds: Perfect for populating city traffic or casual delivery missions

• 19 looping tracks in WAV and OGG format (24-bit / 44.1kHz)
• Unlimited royalty-free license - safe to use for your game and YouTube.
• 38 minutes of music
• No AI.

All tracks were made WITHOUT AI and are safe for YouTube.

Inspired by the terrifying, grungy textures of Silent Hill and Resident Evil.

19 high-quality dynamic layers organised into 5 'songs'.

Designed to be faded in and out of as the situation requires - see overview video for more details.

Seamless looping.

TRACKLIST:

Reflections

• Exploration Layer
• Cinematic / Dialogue Layer
• Tension Layer
• Combat Layer

Pit of Despair

• Exploration Layer
• Cinematic / Dialogue Layer
• Tension Layer
• Combat Layer

Once Familiar Now Forgotten

• Exploration Layer
• Cinematic / Dialogue Layer
• Tension Layer
• Combat Layer

In Limbo

• Exploration Layer
• Cinematic / Dialogue Layer
• Tension Layer
• Combat Layer

Dreamstate / Safe Room

• Exploration Layer
• Melodic Layer
• Subtle Unsettling Layer

Intended Use

These tracks were created to create a dark, gritty, unsettling atmosphere for your horror game. Start with the 'Exploration Layer' and fade in more layers as the player encounters new locations, NPCs, and enemies. While these tracks were originally written as 5 distinct songs, feel free to mix and match from different tracks to create interesting and potentially discordant soundscapes.

If you're interested in hearing some of my other work or contacting me for a custom soundtrack, check out https://sites.google.com/view/jamesfox-sound/

Album Artwork by Terri Krippner

Core System

• Built as a Unity Editor extension using EditorWindow
• Direct PostgreSQL connection (host, port, database, user, password)
• Supports PostgreSQL 10+ (local or remote servers)
• Automatic connection persistence and reconnection

Code Generation:

• Generates APIManager, data models, and API test script
• Schema-based C# class generation with type mapping

API Support:

• GET, POST, PATCH, DELETE
• JSON-based request/response handling

Editor Features:

• Table and schema management
• CRUD operations on table data
• Built-in API testing tool

Compatibility:

• Unity 2021.3+
• .NET Standard 2.1
• Supports all Unity target platforms (Windows, macOS, Android, iOS, WebGL, etc.)

Build, manage, and integrate databases directly inside Unity — with zero manual API integration required.

Database Manager For Unity is a powerful editor extension designed to streamline backend development for Unity projects. It eliminates the need to switch between Unity and external database tools by bringing database management, API testing, and automatic code generation into a single workflow.

Whether you're building a game backend, admin tool, or a data-driven application, this plugin helps you move faster with significantly less manual work.

Key Features

Direct PostgreSQL Connection

Connect your Unity project directly to a PostgreSQL database using secure credentials. Connection settings are saved and automatically restored.

Full Database Management Inside Unity

Create and manage your database without leaving the editor:

• View, create, and delete tables
• Modify schemas and column types
• Add or remove columns
• Configure primary keys

Built-in Data Editor (CRUD)

Manage table data visually:

• Insert, update, and delete rows
• Browse table records
• Edit gameplay or test data instantly

API Testing Toolkit

Test your APIs directly inside Unity:

• Supports GET, POST, PATCH, DELETE
• Payload builder and query filters
• Formatted response preview

No need for external tools like Postman.

Automatic API Code Generation

Generate production-ready Unity scripts with one click:

• APIManager runtime class
• Table-specific API methods
• Strongly typed C# data model classes

No manual networking or JSON parsing required.

Auto-Generated Test Script

Includes a ready-to-use APIManagerTest script:

• Runtime UI for API testing
• Example usage of generated code
• Quick validation in Play Mode

Why Use This Tool?

• Faster development workflow
• No backend expertise required
• Reduced repetitive coding
• All-in-one database and API solution inside Unity

Use Cases

• Game backends (player data, inventory, leaderboards)
• Data-driven gameplay systems
• Internal tools and dashboards
• Rapid prototyping and testing

Unity Version: 6000.x (Unity 6) and later

Render Pipeline: Compatible with URP, HDRP, and Built-in

Editor Only: Code Scaffold is an editor tool. No runtime scripts or assemblies are included in builds.

UI Framework: Built entirely with UI Toolkit (UIElements). No IMGUI.

Dependencies: None. Uses only built-in Unity APIs.

Generated Code: Pure C# with no dependencies on Code Scaffold or any third-party library.

Template Engine: Custom parser supporting placeholder replacement (`{{Key}}`), conditional blocks (`{{IF}}...{{ENDIF}}`), nested conditionals, and naming transforms (PascalCase, camelCase, snake_case, UPPER_CASE, lower).

Templates: 17 built-in templates stored as .txt files. Organized into 7 categories.

Folder Styles: Per-folder color and icon data stored as a ScriptableObject database asset. Renders via EditorApplication callbacks — zero performance impact in play mode.

Script Count: ~25 editor scripts, 0 runtime scripts.

Platforms: Works on Windows, macOS, and Linux editors.

C# Code Generator | Templates, Mass SO Creation & Folder Styles is a pattern-aware C# code generator built for Unity developers who want to write less boilerplate and start building faster.

Pick a template, fill in your parameters, and generate clean, production-ready C# scripts — all from a polished three-panel wizard or a simple right-click in the Project window.

What You Get

Ace Code Scaffold ships with 17 built-in templates covering the most common Unity scripting patterns:

• MonoBehaviour — Basic and Singleton (with DontDestroyOnLoad, thread-safety options)
• Networking — Netcode for GameObjects: NetworkBehaviour, Player Controller, Object Spawner (with NetworkVariables, ServerRpc, ClientRpc)
• ScriptableObject — Basic SO, Data Container (with mass asset creation), Event Channel
• Editor — Custom Editor, Custom Inspector (UI Toolkit), EditorWindow, Documentation Window, About Window, Property Drawer
• Patterns — Command, Object Pool, State Machine State
• Testing — Edit Mode and Play Mode test fixtures

Every template is fully parameterized. Toggle optional sections on or off, set class names, namespaces, method signatures, accent colors — the generated code adapts to your choices.

### Live Previews

The code preview panel shows your generated C# script updating character-by-character as you adjust parameters. For Editor Window templates, open the companion Live Visual Preview window to see a pixel-accurate rendering of the window you're creating — complete with toolbars, sidebars, status bars, and accent colors — all updating in real-time.

### Quick Create

Right-click any folder in the Project window and navigate to Create > Ace > Code Scaffold to generate any template directly into that folder. A compact Quick Create popup lets you fill in parameters and generate without opening the full wizard.

### Mass ScriptableObject Creation

The Data Container SO template lets you define a ScriptableObject class and batch-create named asset instances in one step. Define your fields, add your asset names, click Generate — the script and all SO assets are created together.

### Folder Styles (Bonus)

Right-click any Project folder to assign a color and icon badge. Visually organize your project at a glance — no configuration files, no setup.

### Zero Dependency

Generated code is clean, standalone C#. There is no runtime reference, no base class, no using directive pointing back to Code Scaffold. You can safely remove the tool at any time without affecting your project.

### Built for Unity 6

Designed for Unity 6 (6000.x) with UI Toolkit throughout. The editor UI is dark-themed, responsive, and follows Unity's design conventions.

AAA Rpg Choices

Wizard broomstick flight system

Advanced Dialogs

Multiple endings

Time control for cutscenes

Built to call methods between choices and dialogs

Fully controlled save & load flow

Explicit write / read order (no hidden serialization)

Key-based data registration system

Supports multiple independent data blocks

Safe loading (no crashes if save file is corrupt or missing)

Built-in versioning support

Designed for large-scale and long-term projects

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 Complete AAA System is a powerful, all-in-one solution crafted for building immersive wizarding and fantasy experiences at a professional level. Designed with scalability and performance in mind, it delivers a complete gameplay foundation that blends cinematic magic combat, advanced AI, and deep RPG systems into a seamless workflow.

At its core, the system features dynamic magical combat with fluid attacks, defensive mechanics, and cinematic spellcasting that brings every encounter to life. Targeting logic allows enemies and players to prioritize by distance or vulnerability, creating more strategic and engaging battles. This is reinforced by an advanced wizard combat AI capable of reacting intelligently, making encounters feel alive and unpredictable.

Character control is built around a fully realized third-person movement system, including smooth transitions for sliding, crouching, and navigating environments such as stairs. Complementing this is an advanced broomstick flight system that enables fast, responsive aerial traversal and combat, expanding gameplay beyond the ground.

The package is designed for ease of use without sacrificing depth. A simple drag-and-drop setup allows rapid integration into projects, while full support for Xbox, Nintendo Switch, and PlayStation controllers ensures a polished experience across platforms. Built on Unity’s new Input System, player input is streamlined, flexible, and ready for modern development standards.

On the narrative side, the system includes a robust RPG dialogue and choice framework. It supports complex branching conversations, direct method calls between choices and dialogue events, and the creation of multiple endings based on player decisions. This allows developers to craft meaningful stories where every choice can shape the outcome of the game.

Cinematic tools such as time control for cutscenes provide greater control over storytelling and presentation, enabling dramatic sequences and polished in-game moments.

The save and load system is built with reliability and transparency in mind. It offers full control over the data flow with explicit write and read order, avoiding hidden serialization pitfalls. A key-based registration system allows modular data management, supporting multiple independent data blocks for complex projects. Safe loading ensures stability even if files are missing or corrupted, while built-in versioning makes it ideal for long-term development and updates.

This package requires the Unity Input System, AI Navigation, and Post Processing for the Built-In Render Pipeline to be installed.

Wizard School Complete AAA System is more than a toolkit. It is a complete foundation for building rich, reactive, and cinematic wizarding worlds with the depth and quality expected from modern AAA experiences.

• Unity 2022.3 or newer
• Supported Methods: GET, POST, PUT, DELETE, PATCH
• Supported Body Types: Raw (JSON/Text), Form-Data, x-www-form-urlencoded
• Dependencies: Native Unity components only (UnityEngine.Networking). No extra DLLs or massive third-party libraries required.
• Compatibility: Works across all platforms supported by UnityWebRequest (Windows, Mac, iOS, Android, WebGL, consoles).
• Source Code Included: Full C# source code provided so you can extend or modify the tool to fit your specific pipeline needs.

RESTKit allows you to import Postman collections and cURL commands directly into Unity, instantly converting them into ready-to-use API requests.

RESTKit is a powerful, yet easy-to-use Unity Editor tool and runtime client designed to streamline the process of integrating, testing, and managing REST APIs within your Unity projects.

Whether you are integrating cloud services, or connecting to external databases, RESTKit saves you hours of boilerplate coding by allowing you to instantly import API definitions and use them in your code.

Key Features

• cURL Import: Directly paste cURL commands to instantly generate Unity-ready API requests.
• Postman Integration: Import your existing Postman collections directly into Unity.
• ScriptableObject Architecture: Imported APIs are saved as APICollection and APIRequestDefinition ScriptableObjects, making them easy to manage, reference, and version control.
• In-Editor API Tester: Test your endpoints right inside the Unity Editor with a custom interface. Configure headers, body (JSON, raw), and form-data (including file uploads) without leaving Unity.
• Runtime API Client: A robust, built-in APIClient that handles the heavy lifting of UnityWebRequest.
• Clean & Modern UI: Reimagined with a premium, responsive Editor UI featuring smooth hover transitions and a sleek Dark/Light theme palette.
• Smart Redirect Handling: Intelligently handles 301/302 HTTP redirects under the hood, seamlessly converting methods to prevent dropped payloads and infinite loops.

Benefits

• No More Boilerplate: Stop writing repetitive UnityWebRequest code. Import your API once, and call it anywhere in your project with a single line of code.
• Stay in Unity: Test your APIs directly within the Editor ecosystem instead of constantly switching between Unity and external tools like Postman.
• Designer Friendly: By storing requests as ScriptableObjects, non-programmers can easily assign API calls to UI buttons or events via the Inspector.
• Type-Safe & Organized: Group your endpoints logically into Collections, ensuring your project stays clean even as your backend scales.

COMING SOON FOR SWAGGER!!!

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