Asset Store newest packages

Number of Audio Wavs: 19

Sample rate / bit rate: 16 Bit, 44,100 Hz

Minutes of audio provided: 22

Pack of Sneaky Music For Games

❮❮❮❮❮ HERE’S EVERYTHING YOU’RE GETTING WITH THIS PACK ❯❯❯❯❯

• 7 Original high-quality music tracks
• 19 WAV Files including Full Tracks, Alt & Short Versions, Loops & Stingers
• 22 Minutes of Audio in 16-bit / 44.1 Khz format
• Commercial Rights & Royalty-Free License

❮❮❮❮❮ TRACK LIST ❯❯❯❯❯

1. Setting A Trap
2. The Ultimate Heist
3. Exciting Quirky Tune
4. The Greatest Detective
5. Creative Soundtrack
6. Inspiring Creativity
7. Sneaky Squirrel

❮❮❮❮❮ YOUTUBE NOTICE ❯❯❯❯❯

Our music is registered with YouTube's Content ID system. If you upload a video featuring our music to YouTube, you may receive this notice: "Copyright-protected content found. The owner allows the content to be used on YouTube." This is not a copyright strike. It is a standard notification that does not harm your channel's status or mute your video's audio. You can learn more about this here: https://composersquad.com/contentid

ONE UI SYSTEM. EVERY DEVICE. ZERO HASSLE.

Stop manually coding different layouts for desktop, mobile, and tablets.

Adaptive UI Layouts automatically detects your player's device and applies

the perfect layout - instantly.

✓ Works with WebGL, standalone, and mobile builds

✓ Compatible with animated and code-controlled UI

✓ Set it up once, works everywhere

✓ No complex scripting required

Create a responsive UI that adapts automatically. Focus on your game, not

device-specific UI code.

Adaptive UI Layouts

Simplified Multi-Platform UI Development

Create one UI system that automatically adapts to different devices and screen configurations.

Adaptive UI Layouts allows you to design your interface once and automatically apply the correct layout for desktop, mobile, and tablet devices.

• Create one UI setup that adapts automatically across platforms

• Avoid writing custom UI positioning code for every resolution

• Reduce development time for multi-platform projects

• Works with WebGL, standalone builds, and mobile devices

Live Demo

Try the WebGL demos to see Adaptive UI Layouts in action:

Responsive UI Demo

https://colpolstudios.itch.io/adaptiveuilayouts-web-and-portrait

Character UI Demo (World Space Canvas)

https://colpolstudios.itch.io/adaptiveuilayouts-character-use-web-and-portrait

Resize the browser window on desktop or open the demo on a mobile device to see the UI automatically adapt to screen size and orientation.

Publisher Website & Support

For documentation, updates, and support:

https://colpolstudios.wixsite.com/studio-design

Automatic Device Detection & Layout Application

The system automatically detects device type and applies the correct layout profile.

• Automatically detects desktop vs mobile devices

• Works with WebGL builds on mobile browsers

• Supports manual orientation controls for Device Simulator testing

• Automatically responds to screen size, aspect ratio, and orientation

Flexible Layout Profiles

Create and manage layout configurations for different devices and orientations.

• Create profiles for Desktop, Mobile Portrait, and Mobile Landscape

• Use only the profiles you need (for example, Desktop + Mobile Portrait)

• Capture the current UI layout with one click

• Update layouts easily by repositioning UI and recapturing

• Modify existing profiles by selecting them before capturing

• Includes Prefab workflow for safe UI iteration

Animation & Code-Friendly

Adaptive UI Layouts is designed to work smoothly alongside animations and scripted UI systems.

• Layout applies once at Start() and does not interfere with animations

• UI elements can be animated freely without layout resets

• Safe to modify UI via scripts or gameplay systems

Performance Optimized

The system is lightweight and designed for runtime efficiency.

• Layout applied only when needed (startup or orientation change)

• Efficient UI element lookup using cached dictionaries

• Minimal runtime overhead

Easy Workflow

A straightforward workflow designed for fast integration.

• Simple setup: Add two components to your Canvas

• Visual workflow: position UI → capture layout → assign profiles

• Works with Unity UI (uGUI) systems

• Easy to modify or expand layouts later

Key Benefits

• Save time when developing multi-platform UI

• Reduce repetitive UI positioning work

• Keep UI systems clean and maintainable

• Support desktop, mobile, and WebGL from a single UI setup

• Render Pipeline: Universal Render Pipeline (URP) ONLY.
• Shader Type: Custom URP Shader.
• Please Note: Currently, this asset only supports URP. Compatibility with other rendering pipelines (like HDRP or Built-in) is planned for future updates.

Welcome to FlexShader, the debut asset release from Winterbite! We are dedicated to create versatil tools for developers and will continuously support this package with new effects and additional shaders in the future.

FEATURES

• 12 Moods — Happy, Emotional, Dark, Fantasy, Epic, SciFi, Horror, Lullaby, Ambient, Mystery, Celtic, Creepy. Each mood sets the scale, chord progressions, rhythm patterns, tempo range, and default instruments.

• 15 Lead Instruments — Flute, Violin, FrenchHorn, Guitar, Choir, SynthLead, Celesta, Chimes, and more. Set to Auto or override manually.

• Deterministic Seeds

Music Weaver generates original, royalty-free music tracks entirely from code — no audio files, no middleware, no external dependencies.

Save to you disk in .Wav and have a bunch of cool background music for your game, with different lenghts and so on

:D

• Hand Tracking Type: Real-time monocular camera-based hand tracking
• Landmark Tracking: 20+ 3D landmarks per hand (wrist, palm, finger joints)
• Hand Detection: Automatic left and right hand identification
• Mesh Animation: Full 3D hand mesh animation with finger joints and wrist rotation
• Movement Tracking: World-space hand position, rotation, and scale tracking
• Gesture Support: Landmark-based data suitable for custom gesture and action detection
• Input Sources: Device camera, video file, static image
• Tracking Models:
  Lite Model (optimized for mobile performance)
  Heavy Model (higher accuracy)
• Rendering Support: Built-in Render Pipeline, URP, HDRP
• Platforms: Android, iOS, Windows, macOS
• Unity Version: 2021 or later
• Dependencies: None (works without AR SDK)
• Setup: Plug-and-play prefabs with demo scenes included

AR Hand Mesh Tracking is a powerful plugin that enables real-time hand tracking, full 3D hand mesh animation, and AR-style hand interaction — without using any AR SDK.

The plugin detects left and right hands, tracks 20+ 3D hand landmarks, animates realistic 3D hand meshes, and follows hand movement in world space, allowing developers to build gesture-based AR interactions using only a camera.

Unlike traditional AR solutions, this system does not rely on AR Foundation, ARCore, or ARKit. It is ideal for lightweight AR experiences, rapid prototyping, and projects that need hand-based interaction before integrating an AR SDK.

Key Highlights

• Real-time hand landmark tracking (20+ points per hand)
• Full 3D hand mesh animation
• Hand movement tracking (position, rotation, scale)
• AR-style hand mesh interaction (no AR SDK required)
• Left & right hand detection
• Gesture & action detection ready
• Interact with AR objects, UI, and physics items
• Supports Camera, Video, and Image input
• Lite & Heavy models for performance control
• Mobile and desktop friendly
• Plug-and-play prefabs with demo scenes

Perfect For

• AR hand interaction systems
• Gesture-based games and applications
• Mobile AR experiences
• AR prototyping and experimentation
• HCI, research, and education projects
• Hybrid AR projects using or preparing for AR SDKs

If you’re looking for a fast, flexible, and SDK-free solution for AR hand tracking, AR Hand Mesh Tracking gives you everything you need to build natural, hand-driven interaction.

Features

• Scene Scanning
• Project Scanning
• Smart Fixes
• Missing Scripts
• Build Safety
• Review Window
• Undo Support
• JSON Export
• Zero Overhead
• Auto Suggestions
• Prefab Safety
• ScriptableObject Scan

Supported Unity Versions

• 2019.4 LTS
• 2020.3 LTS
• 2021.3 LTS
• 2022.3 LTS
• 2023.x / Unity 6 / Above 
• Compatible with all future versions

Supported OS

• Windows
• macOS
• Linux

Documentation -> Online Documentation

⚠️ Stop shipping builds with broken references

Deleting scripts, renaming folders, prefab overrides, branch merges—Unity projects slowly collect missing references and “Missing Script” components. These issues silently grow until they explode as NullReferenceExceptions or failed builds.

Missing Reference Killer is a Unity Editor tool built to find, review, and safely fix these problems before they reach runtime.

This tool is not a passive logger. It actively scans your project and shows you exactly where things are broken—clearly, early, and safely.

🔍 Deep & Accurate Scanning

• Scene Scan
  Detects missing references and broken components in the active scene.
• Project-Wide Scan
  Scans Prefabs and ScriptableObjects across your Assets folder.
• Missing Script Detection
  Finds ghost components left behind after deleted or renamed scripts.

Issues are clearly color-coded so you can instantly see what is critical and what is safe to clean.

🧠 Smart Suggestions & Safe Fixing

• Smart Suggestions
  Analyzes variable names and expected component types to suggest correct fixes.
• Safe Fix Mode
  Apply supported fixes without touching critical data.
• Review Window
  Preview every change with Old Value → New Value before applying.
  Nothing is applied blindly.

🛡️ Build Safety Guard

• Pre-Build Scan
  Automatically checks for broken references when you press Build.
• Build Protection
  Stops the build and alerts you if critical issues are found—saving you from shipping a broken game.

🌟 Why this tool?

This isn't just a scanner; it's a workflow accelerator. We built it to be the "Check Engine Light" for your Unity project. It handles everything from simple null fields to deep complex prefab data corruption.

📊 Professional Workflow Tools

• Clean, structured results view
• Group and filter issues by Scene, Asset type, or severity
• Export scan results as JSON for audits or team use

⚡ Key Benefits

• Editor-only tool (zero runtime overhead)
• Full Undo / Redo support
• Works with large projects and refactors
• Compatible with Addressables and modern Unity workflows

Missing Reference Killer is designed for developers who care about stability, clean projects, and stress-free releases.

Clean project.
Safe builds.

Keep your project clean. Keep your sanity. Get Missing Reference Killer today.

- "by DecNet"

JOIN DISCORD | DOCUMENTATION | OTHER ASSETS

9 prefab

9 model

LowPolyNature-MiniPack

This free low poly pack has 9 prefabs. All models are ready to put in scene.

All models are optimized with approximately 90-100 tris each.

-3 Tress

-3 Bushes

-2 Grasses

-1 Rock

All models use the same texture and material.

Don't forget to ranked the package if you download it.

Thank you!

The package catches up the active ProjectBrowser Editor Windows and edits the Title GUIContents of each Locked Project Tabs according to a selected Titling Mode Settings.

This package modifies the Project tab titles to easily distinguish between multiple Project tabs. Works only with Two Column Layout.

The package includes multiple titling modes:

• Folder Only. Title consist of the lowest level folder name
• Wrap. A fancy path compress mode.
• Shrink. The maximum symbols within the given Limit used.
• RegEx. Setup your desired way of titling.

How to use:

The package activates immediately. The Titling mode Settings can be found on the top menu: Window/Titled Project Tabs Settings

- Unity 2021.3 LTS or newer

- Built-in, URP, and HDRP compatible

- Separate Runtime and Editor assemblies

- Zero runtime allocations

- No third-party dependencies

- IL2CPP and Mono compatible

- Namespace: DawgTools.Smooth

QUICK START

using DawgTools.Smooth;

using UnityEngine;

public class SmoothExample : MonoBehaviour

{

    public float halfLife = 0.12f;

    float _value;

    void Update()

    {

        float target = Mathf.Sin(Time.time) * 10f;

        _value = Smooth.ExpHalfLife(

            _value, target, halfLife, Time.deltaTime);

    }

}

LICENSE

Licensed under Unity Asset Store EULA.

DAWG Tools - Smooth PRO

Most Unity projects have code like this:

current = Mathf.Lerp(current, target, 0.1f);

It runs every frame, applying a fixed percentage step toward the target. At 30 FPS it applies 30 times per second. At 144 FPS it applies 144 times per second. Players on faster machines see faster smoothing.

The fix is one line:

current = Smooth.Exp(current, target, 10f, Time.deltaTime);

Same behavior at every frame rate. The math uses exp(-speed * dt) which naturally compensates for variable frame times.

Use cases: camera systems, UI motion and transitions, gameplay parameter smoothing, audio interpolation, network / multiplayer interpolation.

WHAT'S INCLUDED

Exponential Smoothing (Smooth class)

- Smooth.Exp — frame-rate independent exponential smoothing

- Smooth.ExpHalfLife — parameterized by half-life (designer-friendly: "halfway to target in 0.2 seconds")

- Smooth.ExpAngle — wrap-safe angle smoothing (no snapping at 0/360)

- Overloads for float, Vector2, Vector3, Quaternion, Color

Spring Dampers (Spring class)

- Spring.Critical — fastest convergence, no overshoot

- Spring.Damped — general-purpose, any damping ratio

- Spring.Bouncy — configurable overshoot and oscillation

- Overloads for float, Vector2, Vector3

- Adaptive substepping for frame-rate stable results

Easing Functions (Ease class)

- 30+ standard curves: Quad, Cubic, Quart, Quint, Sine, Expo, Circ, Back, Elastic, Bounce

- In / Out / InOut variants for each

- SmoothStep and SmootherStep (Hermite / Perlin)

- Ease.Lerp helper combining easing + interpolation

Conversion Utilities

- SpeedFromBrokenLerpT — convert existing lerp t values to correct speed

- SpeedFromHalfLife / HalfLifeFromSpeed

- ConvergenceTime — time to reach 90%, 99%, etc.

Editor Window (Window > DAWG Tools > Smooth Inspector)

- Three modes: Exponential, Spring, Ease

- Exponential: side-by-side graph of naive lerp vs Smooth.Exp at different frame rates

- Spring: response curve visualization showing overshoot for bouncy settings

- Ease: curve shape preview for all easing functions

- dt profile stress test (constant FPS, jittered frame times, FixedUpdate simulation, custom tick rates)

- Convergence analysis, migration helper, copy-to-clipboard snippets

EXAMPLES

Camera follow:

// Before (frame-rate dependent)

transform.position = Vector3.Lerp(

transform.position,

target.position,

followSpeed * Time.deltaTime

);

// After (consistent at any FPS)

transform.position = Smooth.ExpHalfLife(

transform.position, target.position,

0.15f, Time.deltaTime);

UI fade (works during frame drops and with timescale = 0):

canvasGroup.alpha = Smooth.ExpHalfLife(

canvasGroup.alpha, targetAlpha,

0.08f, Time.unscaledDeltaTime);

Rotation (no snapping at 0/360 boundary):

currentYaw = Smooth.ExpAngle(

currentYaw, targetYaw,

Smooth.SpeedFromHalfLife(0.12f),

Time.deltaTime);

Spring motion:

position = Spring.Critical(

position, target,

ref velocity, 5f,

Time.deltaTime);

Easing:

float t = elapsed / duration;

float eased = Ease.OutCubic(t);

value = Mathf.LerpUnclamped(start, end, eased);

Technical Details

• Unity 2021.3 LTS or newer
• Built-in, URP, and HDRP compatible
• Editor-focused tool (no runtime dependencies required)
• Clean namespace: DawgTools.OKLab
• Implementation follows Björn Ottosson’s reference specification
• Contrast computed using correct linear RGB luminance

Runtime Integration

At runtime, simply replace:

Color.Lerp(a, b, t);

With:

OKLabColor.Lerp(a, b, t);

Use perceptual interpolation only where it matters — UI transitions, theme blending, animated color states.

Designed For

• UI animation systems
• Theme engines
• Accessibility-conscious projects
• Design-heavy applications
• Production workflows requiring visual consistency

License

Licensed under the Unity Asset Store EULA.

DAWG Tools - OKLab Color Inspector PRO - Perceptual Color Tools for Unity

Unity’s default Color.Lerp interpolates colors in RGB component space.

https://dawgtools.org/unity/

For UI and theme transitions, this often results in:

• Desaturated or “dirty” midpoints
• Perceived brightness dips
• Unintended hue shifts
• Inconsistent animation quality

The OKLab color space is designed so that distance and interpolation better match human perception.

This tool makes the difference visible, measurable, and actionable inside the Unity Editor.

OKLab interpolation produces smoother, visually consistent gradients and transitions because it operates in a perceptual color space rather than raw RGB component space.

Instead of guessing how a transition will look, you can:

• Compare Gamma RGB vs Linear RGB vs OKLab interpolation
• Inspect perceptual midpoints
• Measure ΔE distance between colors
• Validate contrast compliance before shipping

1. Typical Workflow

1. Select two UI colors (e.g., Normal → Hover).
2. Compare Unity RGB interpolation against OKLab interpolation.
3. Inspect midpoint, hue drift, chroma, and contrast.
4. Replace Color.Lerp with OKLabColor.Lerp in runtime code.

2. Who It’s For:

• UI / UX engineers
• Technical artists
• Tools programmers
• Teams implementing dynamic themes
• Developers who care about visual polish and accessibility

3. WHAT'S INCLUDED

Interpolation Comparison

Side-by-side preview of:

• Unity RGB (Gamma)
• Linear RGB
• OKLab interpolation

Instantly see how transitions differ visually and mathematically.

Perceptual Metrics

• ΔE (perceptual distance measurement)
• Live midpoint inspection
• Chroma comparison
• OKLab component breakdown (L, a, b)
• Hue angle visualization

Accessibility & Contrast Tools

• WCAG contrast ratio calculation
• AA / AAA / Large-text thresholds
• Automatic best-text color suggestion
• Contrast validation against background colors

Computed correctly in linear luminance space.

OKLab Utilities

• OKLabColor.Lerp runtime helper
• OKLab decomposition per color
• Copy helpers (Hex, OKLab values)
• Lock Lightness (L)Optional perceptual constraints:
  Lock Chroma (C)
  

ASSET LIST & POLYCOUNTS (TRIANGLES)

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

Tedy Bear ...2,510

Dinosaur ...2,042

Lion ...2,006

Bunny ...2,008

Elephant ...2356

Giraffe ...1,648

Penguin ...1,848

Duck ...1,116

Total assets: 8 

+ simple room props with Demoscene

Textures: None

Texture dimensions: N/A

Texture maps: None

Materials: Unity materials only (URP compatible)

Render Pipelines: Built-in, URP

A charming set of stylized low-poly plush toy animals, perfect for children's room scenes, casual games, and cozy environment props. Each character has a soft, rounded form inspired by classic stuffed toys.

Package Contents:

• 8 plush toy animal prefabs (Teddy Bear, Bunny, Lion, Dinosaur, Elephant, Giraffe, Penguin, Duck)
• Simple demo room with props
• URP compatible materials
• No textures required
• Demo scene included

Low Poly Train 11 Lowpoly 3d model It is best for use in games and other real time applications.

Model is built with great attention to details and realistic proportions with correct geometry. 

4k textures are very detailed so it makes this model good enough for close-up. 

Features:

•     Low Poly Train 11_ polys:13372, Tris:31494, Verts:17748
•     Map size HD ---diffuse,specular,height,Normal,occlusion
•     Model is correctly divided into main part and animation parts
•     Model completely unwrapped.
•     Model is fully textured with all materials applied.
•     Pivot points are correctly placed to suit animation process.
•     All nodes, materials and textures are appropriately named.

Number of textures: 13

Texture dimensions: 4096*4096

Polygon count [Draton]

Verts: 5,867

Faces: 5,668

Tris: 11,326

Rigs: Yes

UV mapping: Yes

Material types and texture maps: PBR

Draton 3d model

Verts : 5,867

Faces : 5,668

Tris : 11,326

• Navigation-first architecture

• Deterministic panel lifecycle management

• LRU-based panel caching and automatic reuse

• Safe panel eviction and recreation

• Screen and Modal panel support

• Navigation Anchors for hub-style navigation

• Runtime-enforced screen exclusivity

• Inspector-driven navigation setup

• Engine-agnostic Core architecture

• Unity uGUI adapter included

• Optional DOTween animation integration

• Automatic setup via editor menu

• Basic and DOTween sample scenes included

• Fully extensible and modular design

Advanced UI Framework is a navigation-first UI system for Unity, designed to provide deterministic behavior, explicit lifecycle control, and clean architectural separation.

Instead of treating UI as loosely connected GameObjects, this framework manages UI as a structured system with defined ownership, navigation history, and lifecycle rules.

Panels are reused automatically through an internal LRU cache, preserving state while allowing safe memory eviction when needed. Navigation Anchors enable predictable hub-style navigation flows, and runtime-enforced rules ensure only one Screen is active at a time.

The Core architecture is engine-agnostic and separated from the Unity adapter, allowing flexibility and long-term scalability. Navigation can be configured entirely through the Inspector using Panel Descriptor and Panel Action components, or controlled directly through code using the Navigator API.

This framework is designed for developers building production-ready projects who need reliable, maintainable, and scalable UI infrastructure.

Included:

• Basic usage sample

• Optional DOTween integration sample

• Automatic setup tools

• Full documentation

• Compatibility: Built-in Render Pipeline and URP
• Number of textures: 1
• Texture dimensions: 2048x2048 (Base Color only)
• Triangles: 432
• Vertices: 222
• Number of meshes/prefabs: 1 mesh, 1 prefab
• Rigging: No
• Animation count: 0
• UV mapping: Yes
• LOD information: No LOD
• Types of materials and texture maps: Unlit, Hand-Painted Diffuse (Albedo)
• Mesh Collider: Yes (1 collision mesh)

Bring rustic storage character to your game world with this stylized hand-painted barrel. Classic wooden stave construction with expressive brushwork and a fully hand-painted texture make this lowpoly prop an instant fit for any environment that needs authentic rural atmosphere.

Key Features:

• Stylized Design: Unique hand-painted look that stands out in any environment.
• Game-Ready: Fully optimized for real-time performance and mobile platforms.
• Ready-to-use: Prefab and Material are pre-configured for instant use.
• Simple Setup: Uses a single material with an Unlit-friendly texture for easy integration.
• Clean Topology: Professional-grade low-poly mesh with no overlapping UVs.

A versatile prop for farm storage areas, tavern interiors, RPG market stalls, or any project that calls for a well-crafted storage container with a handmade visual style.

Compatibility: Built-in Render Pipeline and URP

Number of textures: 1

Texture dimensions: 2048x2048 (Base Color only)

Triangles: 526

Vertices: 271

Number of meshes/prefabs: 1 mesh, 1 prefab

Rigging: No

Animation count: 0

UV mapping: Yes

LOD information: No LOD

Types of materials and texture maps: Unlit, Hand-Painted Diffuse (Albedo)

Mesh Collider: Yes (9 collision meshes)

Add everyday farm character to your game world with this stylized hand-painted bucket. Sturdy lowpoly form, expressive brushwork and a fully hand-painted texture make this prop a natural fit for any rural or village environment built for real-time use.

Key Features:

• Stylized Design: Unique hand-painted look that stands out in any environment.
• Game-Ready: Fully optimized for real-time performance and mobile platforms.
• Ready-to-use: Prefab and Material are pre-configured for instant use.
• Simple Setup: Uses a single material with an Unlit-friendly texture for easy integration.
• Clean Topology: Professional-grade low-poly mesh with no overlapping UVs.

A versatile prop for farm yards, village market scenes, RPG environments, or any project that calls for a well-crafted everyday tool with a handmade visual style.

* Downtown & Interior — Texture: 2048x2048, PNG format

* Armory — Vertex Color only (no texture maps)

* Average polygon count: Building Preset(700–3000 tris), Walls(2–300 tris), Doors(60–500 tris), Furniture(50–150 tris), Props(100–300 tris), Weapons(2K–21K tris per main body)

Cyberpunk Low Poly Bundle — Downtown + Interior + Armory

GYP Studios presents —

🔥 Get all three Cyberpunk Low Poly packs in one bundle and save $60!

Total value: $219.97 → Bundle price: $159.99 (Save 27%)

This bundle includes our most popular Cyberpunk asset packs at a discounted price. Build an entire Cyberpunk world — from the neon-lit streets to detailed interiors to a full modular arsenal.

All assets share a consistent Low Poly art style, making them fully compatible with each other and with other low-poly assets such as Synty Studios.

▶ What's Included ◀

🏮 Cyberpunk Downtown Pack Vol.1 — Low Poly ($89.99)

900+ high-quality prefabs — modular buildings, sidewalks, road props, SkyTrain rails, signs, video ads, signboard videos, and more. Includes 2 AAA demo scenes.

🏮 Cyberpunk Interior — Low Poly ($69.99)

980+ high-quality prefabs — modular walls, floors, furniture, vegetation, neons, blood splatters, and more. Includes 2 AAA demo scenes.

💥 Cyberpunk Armory Pack Vol.1 — Low Poly ($59.99)

180+ high-quality prefabs — pistols, rifles, shotguns, snipers, blades, drones, gadgets, grenades. Fully modular with vertex color–based materials (no textures required).

▶ How to Download ◀

⚠️ Important: This bundle does NOT contain the asset files directly.

After purchasing this bundle, visit each package page listed below, click "Add to My Assets," and you will be able to download them for FREE:

1. Cyberpunk Downtown Pack Vol.1 — Low Poly

2. Cyberpunk Interior — Low Poly

3. Cyberpunk Armory Pack Vol.1 — Low Poly

▶ Why Buy the Bundle? ◀

* Save $60 (27%) compared to buying individually

* Consistent art style across all three packs

* Build complete Cyberpunk environments — exterior, interior, and weapons

* Over 2,060 prefabs in total

* Ideal for FPS, TPS, RPG, top-down shooters, or any stylized sci-fi project

▶ Compatibility ◀

* Built-in Render Pipeline (Install-Package included in each pack)

* URP — Universal Render Pipeline (Install-Package included in each pack)

📢 Follow & Support

🎬 YOUTUBE | 💬 DISCORD | 🎨 ARTSTATION | ✉️ EMAIL

※ Discord is not monitored frequently. For faster support, please contact us via email — we'll respond as soon as possible.

OUR ADVANTAGES

🗃️ Detailed docs • 🛠️ Easy editor tools • 🎨 Reskin guide • ✨ Clean structure & code

Try a demo: .apk(android)

Document

Ignite Chain is a complete Ignis‑style burning puzzle template for Unity, designed to help you ship brain‑teasing minimalist puzzle games fast. Tap once, watch the fire travel along edges, and let the chain reaction burn every shape on screen.

This package includes polished core gameplay, an in‑editor level creator,5+ Themes included and clean, extensible C# code ready for reskinning and monetization.

Core Features:

• Edge‑burning mechanic
• Shapes burn along their outlines (rectangles, hexagons, circles, custom meshes) with glowing fire lines and sparks.
• 5+ Themes included

Smart chain reaction system

When a shape finishes burning, its spark automatically jumps to the nearest unburnt shape to continue the sequence.

One‑tap puzzle gameplay

Players tap a single point to start the fire and must plan how to burn all shapes in one move.

Progressive difficulty

Start with simple one‑shape puzzles and scale up to complex layouts with zigzags, crossings, and timing challenges.

Built‑In Level Editor

• In‑editor level creator to place shapes, scale, rotate, and test instantly.
• Save and load levels as ScriptableObjects or data files.
• Rapid iteration workflow: tweak, test, and balance puzzles directly in the Scene view.
• 30 Levels Built in.

Mobile‑Ready Template

• Optimized for portrait mobile gameplay with tap input.
• Easy hooks for AdMob/Unity Ads and IAP (no SDKs included, just clean integration points).
• Lightweight, optimized effects suitable for low‑end devices.
• Code & Architecture
• Clean, commented C# scripts (fire manager, burnable shapes, input, level loader).
• Data‑driven level system for hundreds of levels.
• Modular design to add new shape types, themes, or mechanics.

Art & VFX

• Minimalist shapes and line‑based burn visuals inspired by modern puzzle aesthetics.
• Configurable colors, gradients, and materials for quick reskins.
• Particle systems for fire, sparks, and completion feedback.

Just import the package, open the sample scene, and start creating your own burning puzzle worlds.

Font Change Notice:

Changed to Lilita One font since v1.2.0 (The font was changed to a more global and refined font)

Free fonts were used in the demo scenes. Please exercise caution before use.

• 343 Audios
• Number of Audio Waves: 343
• Format: 96KHz / 24 bits
• Do Sound FX loop: No
• Win/Mac: Yes
• Minutes of audio provided: 20:00

Universal Explosions is designed to provide a wide variety of explosions of all kinds.

The idea behind this series is to cover a full spectrum, from realistic explosions to more sci-fi and cinematic styles. In this release, we include 25 types of explosions, each with 4–6 variations, resulting in a total of 150 unique sounds.

Additionally, as with most of our sound libraries, almost all explosions include their elements separated (pre-hits, tails, etc.), allowing you to build and adapt each sound exactly to your project’s needs. Including these separated elements, the library offers over 150 sounds in total.

For this release, the sources are not yet included, but they will be available in the coming weeks. They will be offered separately at a different price, so if you only need the designed sounds, you won’t have to pay extra.

The library is built with a modular recombination approach, meaning many elements are provided in separate layers, allowing you to combine them freely like a puzzle.

Highlighted elements:

• Aerial Bomb Drop And Blast
• Big Fire Explosion
• Distant Growing Blast And Shockwave
• Distant Missile Impact And Explosion
• Distant Missile Impact And Fire
• Distant Multiple Successive Explosions
• Double Explosion With Reverberation
• Electric Sci-Fi Grenade Explosion
• Etc.

Technical specifications
Following Khron Studio’s quality standards, the library is delivered in high-resolution audio: 192 kHz / 24-bit.

More about the pack

• Intuitive file naming
• Use the sound effects over and over, in any of your projects or productions, forever without any additional fees or royalties. Use the SFX in your game, in your trailer, in a Kickstarter campaign, wherever you need to, as much as you want to.
• Totally mono compatibility
• All sounds have several variations.
• Use your imagination and feel free to use any sound for a creature other than the one described, remember that the world of sound is totally subjective.
• For any questions or problems: khronstudio@gmail.com

• Features:
• Vivox Voice and Text Chat
• Customizable UI using UIToolkit
• Test scenes setup to:
• Connect players to voice and text, display a roster of players with speaking indicators and mute capabilities, and send text messages.
• Manipulate input and output device selection and volume
• Supported OS: Windows, Mac
• Documentation Link:
• Vivox voice and text chat Building Block

The Vivox Building Block is designed for flexible, modular integration of voice and text communication in your Unity project. It’s customizable to fit your game, but also works out of the box.

This Building Block demonstrates how to do the following:

• Join a voice and/or text channel through the Vivox SDK.
• Create a roster displaying all players in a channel and their speaking status, with the ability to mute individual players.
• Create a text chat UI allowing players to retrieve message history and send messages to a channel.
• Create a device selection UI for adjusting input and output device selection and volume.