Feed aggregator

- Unity 2021.3 or later (including Unity 6)

- All platforms — editor-only tool, generated output has no platform-specific code

- ~160 C# scripts (~34 Runtime, ~65 Editor, ~60 Generated)

- 2 assembly definitions: SimpleIdleForge.Runtime, SimpleIdleForge.Editor

- 5 demo scenes (Hub + 4 demos)

- 14 HTML documentation pages + 1 CSS stylesheet

- No third-party dependencies

- Optional: Simple Attribute Forge (detected via reflection)

- Optional: Simple Item Forge (detected via reflection)

- Optional: Simple Enemy Forge (detected via reflection)

- Optional: Simple Quest Forge (detected via reflection)

- Optional: Simple Skill Forge (detected via reflection)

- 9 runtime components, 5 static utilities, 3 API hook interfaces

- 6 genre templates: Classic Incremental, RPG Idle, Factory Tycoon, Prestige Heavy, Survival Idle, Gacha Collection

Still building idle game systems by hand?

Seriously. Stop it.

Simple Idle Forge gives you 5 interconnected wizard tools that generate production-ready idle game databases — resources, generators with cost scaling, upgrades, prestige layers, and achievements — complete with type-safe enums, custom inspector editors, and full JSON content generation support!

OFFLINE DOCUMENTATION HERE!

THE FIVE FORGES

Resource Forge

- Define currencies, materials, energy, and prestige points

- Starting amounts and optional caps with 5 cap modes (None, Hard, Flat, Curve, Step)

- Display formatting: K/M/B/T suffixes, scientific notation, engineering notation

- Display colors per resource

- Custom dynamic properties (Categories, Flags, Numerics, Texts)

- 6 genre templates: Classic Incremental, RPG Idle, Factory Tycoon, Prestige Heavy, Survival Idle, Gacha Collection

Generator Forge

- Define buildings, workers, and producers that generate resources over time

- Multi-resource production (one generator can produce multiple resources)

- Multi-resource costs with 5 scaling formulas and interactive preview sliders

- Two production modes: Continuous (Cookie Clicker style) and Timer (Adventure Capitalist style)

- Timer mode shows visible progress bars, Speed bonuses make timers tick faster

- Prerequisites to gate unlocking (resource amount, generator level, upgrade purchased)

- Milestone bonuses at level thresholds (x2 at level 25, +50% at level 50, etc.)

- TWO-LEVEL dynamic properties — generator-level AND milestone-level independently

Upgrade Forge

- Define boosts, automation triggers, and unlocks

- Multi-resource costs with scaling

- 6 effect types: Multiply, Add Flat, Add Percent, Unlock, Automate, Resource Grant

- One-time or repeatable purchases

- Prerequisite chains (requires generator level, resource amount, or another upgrade)

- Automate-type upgrades wire directly into the auto-purchase system

- Quick presets: Double Production, +50%, Automate, Unlock, Grant Resource

Prestige Forge

- Define entire rebirth cycles

- Configure prestige currency and source resource

- 4 formula types: Sqrt (Cookie Clicker standard), Linear, Log, Polynomial

- Reset rules control exactly what gets wiped and what survives

- Target specific resources, generators, or upgrades — or reset ALL

- Permanent bonuses that scale with total prestige currency earned

- Stack unlimited prestige layers

- Included demos ship with 1, 2, 3, and 4 layers

Achievement Forge

- Define global milestones, challenges, and goals

- Conditions: resource amount, generator level, upgrade purchased, prestige count, total production

- Multiple rewards per achievement (grant resources, add multipliers, unlock features)

- Hidden achievements (secret, revealed on completion)

- Repeatable achievements (daily challenges that can be earned multiple times)

OFFLINE PROGRESS CALCULATOR

When your player closes the app and comes back hours later, the offline progress calculator figures out exactly what they earned while away:

- Configurable efficiency: flat percentage, smooth curve, or step-based diminishing returns

- Optional max offline time cap (e.g., 24 hours max)

- Detailed report of every resource earned

- Pre-formatted summary string for your "Welcome Back" popup

- Time-to-afford queries for UI countdown timers — "You can afford this in 2m 34s"

Your players come back to meaningful rewards, not a blank screen.

NOTE: Only testable on deployed games or apps and not in the unity editor.

DOUBLE PRECISION — NUMBERS TO INFINITY

- Every game value uses double precision (1.7×10^308 range)

- Far beyond the 3.4×10^38 limit that breaks most projects

- Built-in number formatter: K/M/B/T/Qa/Qi suffixes (51+ tiers)

- Scientific notation, engineering notation

- Time formatting ("4h 23m") and rate formatting ("1.5M/s")

TWO PRODUCTION MODES

- Continuous — resources flow every frame, smooth and constant (Cookie Clicker style)

- Timer — resources arrive in batches after a countdown with a visible progress bar (Adventure Capitalist style)

- Speed bonuses from upgrades make timers tick faster

- Mix both modes in the same game

- Factory Tycoon demo uses Continuous for extractors and Timer for refineries

COST SCALING WITH LIVE PREVIEW

5 scaling formulas for generator and upgrade costs:

- None — cost stays constant forever

- Linear — cost increases by a flat amount each level

- Exponential — the industry standard (Cookie Clicker uses 1.15×)

- Polynomial — quadratic, cubic, or custom power curves

- Logarithmic — gentle late-game scaling that flattens out

- Exponential presets: Gentle 1.07, Standard 1.15, Steep 1.30, Aggressive 1.50

- Interactive slider: drag from level 1 to 200, see exact cost before generating

BONUS STACKING PIPELINE

- Transparent formula: (base + flat bonuses) × (1 + percentage bonuses) × multipliers

- Upgrades, prestige, achievements, and buffs all feed into the same pipeline

- No hidden interactions, no order-of-operations bugs

- You always know exactly how bonuses combine

DYNAMIC PROPERTY SYSTEM

- No hardcoded fields — you define your own Categories, Flags, Numerics, and Texts

- Generator Forge supports TWO levels — generator-level AND milestone-level properties

- Your game, your properties — works for any genre

JSON CONTENT PIPELINE

- Export your schema as Full JSON, Light JSON, or Markdown

- Generate entries by hand or with any external tool that outputs JSON

- Import directly — validates every entry, checks codes against linked databases

- All 4 included demo games were built this way

- JSON source data for every demo is included

FOUR COMPLETE PLAYABLE DEMO GAMES

Not tech demos. Complete idle games with polished UI, multiple progression systems, and hours of content.

Simple Kingdom — Classic Idle Clicker

- 7 resources, 8 generators, 20 upgrades, 1 prestige layer, 20 achievements

- Medieval fantasy theme, centered column layout

- Teaches: core idle loop, prestige basics, achievement design

Factory Tycoon — Industrial Supply Chain

- 12 resources, 10 generators, 24 upgrades, 2 prestige layers, 25 achievements

- 3 Continuous extractors + 7 Timer processors with progress bars

- Royal maroon and gold theme, centered column layout

- Teaches: timer production, multi-resource economies, stacked prestige

Survival Idle — Resource Decay Challenge

- 16 resources, 12 generators, 24 upgrades, 3 prestige layers, 30 achievements

- Food, water, and warmth drain constantly with color-coded vital bars

- 5 Continuous gatherers + 7 Timer crafters

- Neumorphic B&W theme, full Melvor-style sidebar layout

- Teaches: resource decay, vital management, three-layer prestige

RPG Idle — Dark Soulslike + Cross-Forge Showcase

- 19 resources, 14 generators, 27 upgrades, 4 prestige layers, 35 achievements

- Combat zones drain health and endurance while producing souls

- 10 Timer generators (combat rounds, crafting cycles) + 4 Continuous

- Dark neumorphic crimson theme, sidebar layout

- Detects companion forge packages at runtime

- Teaches: cross-forge ecosystem, deep prestige, combat drain

Every demo includes its JSON source data.

RUNTIME COMPONENTS

9 pure C# runtime trackers:

- IdleResourcePool — resource amounts, caps, fill ratios, events

- IdleGeneratorManager — levels, production, timer mode, milestones, auto-collect

- IdleUpgradeTracker — purchases, prerequisites, effects, bonus collection

- IdlePrestigeManager — prestige cycles, reset rules, permanent bonuses

- IdleMilestoneTracker — achievement completion, conditions, reward granting

- IdleBuffManager — temporary boosts with duration tracking

- IdleProgressCalculator — offline progress, production snapshots, time-to-afford

- IdleAutoPurchaser — 4 strategies: Cheapest, Most Expensive, Round Robin, Disabled

- IdleStatisticsTracker — lifetime stats with auto-subscription to all events

- Full snapshot serialization on every tracker for save/load

GENERATED CUSTOM EDITORS

- Every wizard generates a professional Inspector editor alongside the database

- Split-panel layout with search, sort, filter by category

- Multi-select with bulk operations

- Pagination for large databases

EDITOR UTILITIES

- Batch Icon Assignment — scan a sprite folder, auto-match to entries by filename

- Database Export — export any generated database as clean JSON

CROSS-FORGE INTEGRATION

Automatically detects companion forge packages and enriches your wizards:

- Simple Attribute Forge — attribute names for stat-based scaling

- Simple Item Forge — item codes for loot rewards and crafting

- Simple Enemy Forge — enemy and faction codes for combat zones

- Simple Quest Forge — quest codes for milestone conditions

- Simple Skill Forge — skill codes for ability references

- Zero hard dependencies — install a companion, codes appear in dropdowns

- Remove it — zero errors, data preserved

INCLUDES

- 14-page HTML documentation (multi-page + single-page, neumorphic theme)

- 4 demo scenes with Hub scene

- 6 genre templates per forge (30 total)

- Zero runtime dependencies

- API hook interfaces for save/load, ad rewards, and notifications

• 11-page HTML documentation (multi-page + single-page format, light/dark mode)
•     Cookbook with 15 copy-paste recipes (mana costs, elemental weakness, status timers, buff stacking, critical hits, drain, instant kill, damage formulas, and more)
•     5 interactive demo scenes (Classic, ATB, Timeline, Press Turn, Action Point) + Demo Hub
•     Template Generator — generates a ready-to-run battle controller for any turn system
•     Pure C# — zero engine dependencies, zero third-party dependencies
•     Works on all platforms — no platform-specific code
•     Unity 2021.3+ compatible
•     5 turn system implementations
•     1 interface to implement on your character class
•     20 events, 11 actions, 4 query helpers

Still writing JRPG battle systems from scratch?

Seriously. Stop it.

Simple JRPG handles the battle flow so you can focus on what makes your game unique — your damage formulas, your status effects, your UI.

Set up your characters, pick a turn system, and start calling actions.

Simple JRPG manages turn order, tracks battle state, and notifies you whenever something happens so you can react however you want.

OFFLINE DOCUMENTATION HERE! 

HOW IT WORKS

• Create a battle, add your characters, pick a turn system — your choice.
• Call actions like DealDamage, Heal, Revive, or Flee. You calculate the numbers, Simple JRPG applies them and tells your game what happened.
• Every action triggers an event — damage dealt, character knocked out, status applied, battle ended.
• Hook into any of these to update your UI, play animations, trigger sound effects, or run custom logic.
• Simple JRPG doesn't care what your stats look like, what "Fire" means in your game, or how you calculate damage. That's all yours.

5 TURN SYSTEMS INCLUDED

• Classic — Characters act in speed order, one round at a time. The standard JRPG turn system.

• ATB (Active Time Battle) — Each character has a gauge that fills based on their speed. When it's full, they can act. Faster characters act more often.

• Timeline / CTB — Every action has a cost. Heavy attacks push your next turn further away. Light actions let you act again sooner. A visible timeline shows who acts when.

• Press Turn — Teams take turns in phases. Each phase starts with a pool of action points. Smart plays conserve points; mistakes waste them.

• Action Point — Characters can save points by skipping their turn, then spend those saved points later for multiple actions in a row.

• Want something different? Implement the turn system interface and build your own. You can just do that if you want.

ACTIONS

• DealDamage — hit one target or a whole group
• Heal — restore HP to one target or a whole group
• Kill — instantly knock out a character
• Revive — bring a knocked-out character back
• ApplyStatus — apply any status effect (poison, stun, whatever you define)
• RemoveStatus — remove a status effect from a character
• ApplyBuff — apply any buff or debuff (attack up, defense down, your call)
• RemoveBuff — remove a buff or debuff from a character
• Flee — escape from battle
• RemoveCombatant — pull a character out of battle entirely
• EndBattle — manually end the battle with a specific outcome
• You could add more events if you want.

20 EVENTS

• Battle started, battle ended
• Turn started, turn ended
• Before damage, before heal (intercept and modify or cancel)
• Damage dealt, healed
• Character knocked out, character revived
• Status applied, status removed
• Buff applied, buff removed
• Fled, character removed
• Group damage dealt, group healed, group status applied, group buff applied

Every action fires an event.

There's no built-in UI or animation system — you listen for the events you care about and handle them your way.

INTERCEPT ACTIONS BEFORE THEY HAPPEN

• The "before damage" and "before heal" events fire before the action goes through.
• Change the damage amount, boost healing, or cancel the action entirely.
• Use these to build dodge mechanics, shields, damage reduction, healing amplification — anything.

BUILT-IN HELPERS

• Get all enemies, allies, alive characters, or dead characters with one call
• Full battle history — every action recorded with turn number and sequence
• Battle result summary — outcome, total turns, survivors
• Automatic win/loss detection

TEMPLATE GENERATOR

• Window > Simple JRPG > Generate Battle Controller
• Pick a turn system, name your script, hit Generate.
• Get a complete, ready-to-run script with placeholder logic and clear TODO comments showing you exactly what to customize.
• Attach it to a GameObject, hit Play, and you have a working battle.

YOUR CHARACTERS, YOUR RULES

• Your character class just needs to provide: a name, whether they're alive, which team they're on, their speed, and methods to take damage and heal.
• Beyond that, add whatever you want — MP, defense, elemental resistances, equipment, level, anything.
• Simple JRPG never touches your custom stats. It only uses what it needs to run the battle.

CLEAN, PORTABLE CODE

• No singletons, no global state, no MonoBehaviours, no ScriptableObjects.
• Create a battle, use it, done. Run multiple battles at the same time if you need to.

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.