Asset Store newest packages

Number of Shaders/VFX: 2 Advanced Custom Shaders 

Texture Sizes: 2048x2048

Custom Shaders: Yes (Written in HLSL) 

Render Pipeline: Universal Render Pipeline (URP) ONLY. 

Supported Platforms: PC, Mac, Consoles, Mobile (Android & iOS), and VR (Meta Quest, PCVR, etc.).

Enhance your game's atmosphere with this advanced Environment Shader Pack, built exclusively for Unity's Universal Render Pipeline (URP). Highly optimized for cross-platform development, this package provides customizable shaders to bring your rainy weather environments to life seamlessly across PC, Mobile, and VR platforms.

What's inside?The package includes two distinct, highly detailed shaders:

1. Dynamic Rainy GroundTransform any standard surface into a realistic wet environment. Features procedural water puddles based on height maps, animated raindrop ripples, wetness level controls, and full PBR lighting support (Metallic, Smoothness, and Normals).

2. Procedural Rainy WindowA screen-space distortion shader that simulates raindrops streaming down a glass surface or camera lens. It features mathematically generated, randomized droplet paths, water trails, and an adjustable frosted glass blur effect without relying on static flipbook animations.

Whether you are building a moody racing game, an open-world adventure, or an immersive VR experience, both shaders are fully customizable via the Material Inspector to fit your specific art style and performance needs.

• 1x URP PBR Rainy Ground Shader (Procedural ripples, puddles, and refraction).
• 1x URP Screen-Space Rainy Window Shader (Procedural drops, trails, and Gaussian blur).
• Fully exposed material properties for extreme customizability.
• No flipbooks used; rain effects are procedurally generated via math and code.
• Highly optimized for cross-platform performance (PC, Mobile, and VR ready).

Render Pipeline Compatibility:

• Strictly for the Built-in Render Pipeline. (Not compatible with URP/HDRP).

List of Included Post-Processing VFX:

• Bloom (Mobile Optimized): High-performance 4-tap box filter with soft-knee thresholding.
• Bloom (Standard): Classic Gaussian blur bloom for PC/Console.
• Blur: Highly optimized Box Blur and Gaussian Blur (using pre-calculated weights).
• Radial Blur: Directional motion blur for speed and tunnel vision effects.
• Glitch Art (Bad TV): Includes scanline jitter, vertical jump, horizontal shake, and RGB color drift.
• Water Wave / Ripple: Interactive, click-driven shockwave distortion.
• Interactive Mask: SDF-based screen masking (Includes shapes like Circle, Gear, Petal, Windmill, Drop).
• Zoom / Magnifying Glass: Interactive screen magnification with edge distortion.
• Occlusion & Cover Dissolve: World-space shaders to dissolve objects blocking the camera view.

Asset Details:

• Number of Custom Shaders: 11 highly optimized .shader files.
• Number of Controllers: 10 clean, fully commented C# controller scripts.
• Texture Sizes: Includes ultra-high resolution 4368x2912 textures for crisp noise, masks, and base overlays.
• Platform Support: PC, Console, Mobile (Android/iOS)

Screen Effects (Built-in) is a comprehensive, highly optimized suite of post-processing and camera effects tailored specifically for Unity's classic Built-in Render Pipeline.

Whether you are developing a high-speed racing game, a tense horror experience, or a stylized indie title, this package provides the cinematic polish you need without sacrificing frame rates.

Highly Optimized for Mobile & VR:We know performance is critical. Instead of heavy, unoptimized loops, our shaders utilize industry-standard mobile optimization techniques:

• Downsample/Upsample Pyramids: The Mobile Bloom effect uses a robust downsampling architecture to provide beautiful, wide glows at a fraction of the GPU cost.
• Fast Math & Smoothsteps: Heavy if/else branching has been replaced with GPU-friendly step/smoothstep functions and SDF (Signed Distance Field) mathematics.

Perfect for Any Genre:

• Racing / Action: Use Radial Blur tied to your car's speed for an incredible sense of momentum.
• Horror / Sci-Fi: Use Glitch Art (Bad TV) to create tension, chromatic aberration, and screen tearing.
• Puzzle / UI: Interactive Water Wave shockwaves on mouse click, or Zoom magnifying glass effects for investigating clues.

Key Benefits:

• Plug & Play: Just attach the C# script to your Camera, tweak the sliders in the Inspector, and you're done.
• Editor Preview: All effects run in the Scene View ([ExecuteAlways]), allowing you to tweak visuals without entering Play Mode.
• Safe & Clean: Built with fallback mechanisms to ensure your screen never goes black if a material fails to load.

• Render Pipeline: URP (Universal Render Pipeline)
• Number of VFXs: 5
• List of VFXs included: 5 Portal
• Texture sizes: 1024x1024, 2048x2048
• Custom Shaders: 1 (Includes a custom Unlit shader for screen distortion/refraction and noise blending)
• Dependencies: Universal RP package is required.

Enhance your game's visuals with the Portal Effect. This package provides 5 unique, ready-to-use portal visual effects perfectly suited for sci-fi, fantasy, or magic-themed projects.

Built exclusively for the Universal Render Pipeline (URP), these portals utilize a custom shader that includes real-time background distortion and refraction, giving your portals a highly realistic, spatial-tear appearance.

Key Highlights:

• Optimized for URP.
• Drag-and-drop ready prefabs.
• Includes a custom shader with adjustable distortion, noise, and glow parameters.
• Easily customizable colors and speeds via material properties.

• Supported Render Pipeline: Built-in Render Pipeline ONLY
• Target Platforms: Mobile (Android/iOS), VR, PC, Mac, Consoles
• Supported Unity Version: [Buraya minimum Unity sürümünü yaz, örn: 2021.3 or higher]
• Texture Dimensions: 1024x1024
• Custom Shaders Included: 10 (CG/HLSL)
  OutlinePostProcess, PureColor, OutlineFresnel, OutlineFresnelShield, XRay, OutlineNormalExpansion, OutlineNormalExpansion2, OutlineNormalExpansionShield, DepthOutline, EdgeDetection, EdgeDetectionAdd
• Control Scripts Included: 4 C# Scripts (OutLine, OutLine_c, DepthShieldOutline, EdgeDetection)
• Demo Content: [Buraya sahne sayısını yaz, örn: 1 Demo Scene and 15 Pre-configured Materials included.]
• Supported Techniques:
  Inverted Hull (Normal Expansion)
  Image Effects / Post-Processing (Blur and Outline)
  Sobel Filter Edge Detection
  Stencil Buffer & Depth Test (X-Ray / See-through walls)
  View-Angle / Fresnel Silhouette

Outlines Built-in is a versatile shader package that allows you to quickly integrate professional-grade outlines and silhouette effects into your projects.

Designed for any genre—from action and puzzle games to RPGs or stylized experiences. It is highly optimized for performance-critical platforms like Mobile and standalone VR devices like the Meta Quest, stripped of unnecessary calculations to ensure stable framerates.

Key Features:

• Wide Range of Effects: Includes Normal Expansion (Inverted Hull), camera-based Post-Processing, Fresnel-based glows, and Sobel-based Edge Detection.
• X-Ray & Shield Effects: Utilize Stencil Buffer and Depth-based shaders to render character or object silhouettes even when they are hidden behind walls or obstacles.
• Ease of Use: Adding post-processing effects to your camera takes only seconds with the included custom C# control scripts. All shader properties are easily customizable via the Inspector.
• Performance Focused: Built entirely with lightweight CG/HLSL shader structures, ensuring high-quality visuals without compromising your FPS.

• Render Pipeline: URP
• Platform Compatibility: PC, Mobile & VR Ready
• Custom Shaders: 2 (Ground Crack URP/Crack, Ground Crack URP/ShowFloor_Stencil)
• Scripts: 1 (CrackCorrectionAnimator with customizable bounds, speed, and random offsets)
• List of VFXs included: Stencil-based Ground Crack Reveal Effect
• Texture sizes: None
• Number of VFXs: 1 Prefab, 4 Ready-to-use Materials

Ground Crack URP is a highly optimized, completely texture-less shader package designed to create dynamic, stencil-based ground crack effects in the Universal Render Pipeline (URP).

Built strictly with performance in mind, it relies entirely on procedural math and stencil buffers rather than heavy textures, making it exceptionally lightweight and fully compatible with Mobile and VR projects. The package includes customizable materials and a dedicated animation script that allows for smooth, randomized crack reveals, ensuring that multiple instances in your scene feel natural and unsynchronized.

Key Features:

• Stencil-based rendering for seamless floor reveals.
• Procedural animation script with randomized starting offsets.
• Easily customizable properties (Color, HDR, Depth Correction).
• Ready to use out of the box with an included prefab and multiple material variations.

Technical details

Render Pipeline: Built-in Render Pipeline only.
Shader Types: 2D Atlas Mapping & CubeMap Mapping.
Textures: 3 High-Resolution textures included (5321x2544 pixels).
Optimization: Mobile-friendly, PC-ready, and VR-compatible (Multi-pass and Single Pass).
Content: 2 Stand-alone Shaders, 3 Textures, 1 Demo Scene, and pre-configured Materials.
Workflow: Supports easy "drag-and-drop" onto any quad or window mesh.

Enhance your urban environments with this optimized Fake Interior Mapping package. This technique allows you to simulate detailed 3D rooms behind windows using only a single plane, significantly reducing draw calls and polygon count compared to traditional 3D interiors.

Key Features:

• Two Specialized Shaders: Includes both 2D Atlas and CubeMap versions to fit your workflow.
• Stand-alone Code: Shaders are self-contained with no external dependencies or include files, making them easy to integrate into any project.
• Extreme Performance: Highly optimized for Mobile and VR (Meta Quest) development where geometry budgets are tight.
• Customizable: Easily adjust room depth, tiling, and rotation to create variety across your building facades.

What's Inside?

• 2D Atlas Shader: Best for performance, allowing multiple room variations in a single texture sheet.
• CubeMap Shader: Best for high-fidelity reflections and 360-degree interior views.
• High-Quality Assets: Includes 3 ultra-high-resolution textures (5321x2544) to get you started immediately.
• Ready-to-use Demo Scene: A pre-configured scene showcasing both shader types in action.

• Rotation functions (X, Y, Z, XYZ axis)
• Taper functions (X, Y, Z axis)
• Twist functions (X, Y, Z, XYZ axis)
• Skew functions (X, Y, Z axis)
• Squash & Stretch functions (X, Y, Z axis)
• Bend functions (X; Y, Z, XYZ axis)
• Blend and FBX file as example pipeline to port 3D package animation using deforms to Unity
• Simple C# Script to communicate animation to shader
• 2 Scenes with examples setups and different use cases: 3D assets, 3D animation.
• Two PDF-documents containing relevant information to support your first steps, understand how to apply subgraphs and which ones are available.
• Examples_URP.unitypackage where you will have examples created using URP

Multiple Deformation Functions to add to your own Amplify Shader setups. You can play with them like in any 3D or 2D package happens, limits are yours. You will find:

• Rotate
• Taper
• Twist
• Skew
• Squash & Stretch
• Bend

All of them prepared for one axis to three axis. You will find some examples to demostrate some ways to setup them and the results you can achieve.

All you can find here is really straight forward, without any tricky setup and it's prepared to support your project without creating any new layer in your configurations. They are only Functions you can apply the way you want.

You will be able to animate via shader instead of using a SkinnedMesh and take profit to the SRP batching for Meshes. You will find a Blender example with a simple script to show you a possible pipeline between packages.

• Scale and Offset subgraph
• Rotation subgraphs/functions (X, Y, Z, XYZ axis)
• Taper subgraphs/functions (X, Y, Z axis)
• Twist subgraphs/functions (X, Y, Z, XYZ axis)
• Skew subgraphs/functions (X, Y, Z axis)
• Squash & Stretch subgraphs/functions (X, Y, Z axis)
• Bend subgraphs/functions (X; Y, Z, XYZ axis)
• Blend and FBX file as example pipeline to port 3D package animation using deforms to Unity
• Simple C# Script to communicate animation to shader
• 4 Scenes with examples setups and different use cases: 3D assets, 3D animation.
• Three PDF-documents containing relevant information to support your first steps, understand how to apply subgraphs and which ones are available.
• Examples_URP.unitypackage where you will have examples created using URP

Multiple Deformation SubGraphs & Amplify Functions to add to your own ShaderGraph & Amplify setups. You can play with them like in any 3D or 2D package happens, limits are yours. You will find:

• Rotate
• Taper
• Twist
• Skew
• Squash & Stretch
• Bend

And an extra Scale & Offset subgraph really useful on a daily basis. All of them prepared for one axis to three axis. You will find some examples to demostrate some ways to setup them and the results you can achieve.

All you can find here is really straight forward, without any tricky setup and it's prepared to support your project without creating any new layer in your configurations. They are only SubGraphs and Functions you can apply the way you want.

You will be able to animate via shader instead of using a SkinnedMesh and take profit to the SRP batching for Meshes. You will find a Blender example with a simple script to show you a possible pipeline between packages.

Core Architecture & Tech Stack:

• Script Analysis: Powered by Microsoft Roslyn (Microsoft.CodeAnalysis) for deep Abstract Syntax Tree (AST) parsing and semantic logic inspection.
• Asset Analysis: Direct integration with Unity's AssetImporter, SerializedProperty, and ModelImporter/TextureImporter APIs for low-level metadata validation.
• Caching System: Uses binary caching and hashed metadata tracking (AnalysisResultCache, AssetMetadataCache) to bypass redundant calculations on unchanged files.
• Dependencies: Requires precompiled references (included): Microsoft.CodeAnalysis, System.Collections.Immutable, Newtonsoft.Json.

Key Features & Modules:

• 34 Dedicated Analyzers: 15 C# script analyzers, 19 asset, scene, and project management analyzers.
• 12 Autofix Engines: Automated resolution systems for Textures, Audio, Models, Animations, Missing References, C# Usings, Banned APIs, Tags/Layers, Physics Matrices, Asset Naming, Empty Folders, and Orphaned Metas.
• Diff Preview System: Generates side-by-side code and property diffs before applying any automated fixes.
• Local Snapshot Manager: Built-in BackupManager creates local, restorable snapshots of project files before executing autofixes.
• Custom GraphViews: Interactive node-based visualizers (BaseGraphView) for Scene Flow, Script Dependencies, and Asset Dependencies featuring Heatmaps, Pathfinding, and Cycle Detection.
• Ignore Rules Engine: Granular exception system supporting specific issue overrides, file-scoped patterns, and global Regex ignore rules.
• Smart Code Duplication: Uses AST node hashing to detect logical code duplicates regardless of formatting or variable naming.
• Report Exporting: Full project health reports can be exported to JSON, CSV, or Markdown (ReportExporter).
• IDE Integration: Native hooks to open IDEs directly to the specific line and column of offending C# code.
• Supported Platforms: Editor-only tool. Does not include runtime overhead or compiled build code.

As development goes on, almost every Unity project turns into a bit of a junkyard.

Archon rips your project open like a tin can and shows you the brutal reality of what’s destroying your framerate, bloating your build size, and tangling your architecture.

But unlike standard analyzers that just spit out a list of 500 errors and leave you to deal with it, Archon actually cleans up the mess.

It’s an automated Technical Director that finds the trash and gives you a "Fix" button.

Top Features

• 35+ Ruthless Analyzers: An unmatched army of 15 C# and 19 Asset/Scene analyzers. Interrogate everything: hidden GC allocations, unoptimized textures, bloated Canvases, and dead code.
• One-Click Autofix Engine: Automatically fix audio/texture compression, missing references, unused usings, and physics matrices. Includes a side-by-side Diff Preview so you know exactly what is changing.
• Roslyn-Powered C# Interrogation: Understands actual logic, not just text. Hunts down GC leaks, GetComponent in loops, bad physics raycasts, and monolithic "God Scripts".
• Smart Code Duplication Hunter: Uses AST hashing to find copy-pasted logic across your codebase—even if variables are renamed or formatting is changed.
• Interactive Dependency Graphs: Visualize Asset Dependencies, Script Coupling, and Scene Flow. Features Heatmaps, Cycle Detection, and A-to-B pathfinding to visually untangle your architecture.
• Blazing Fast Caching: Heavy caching of ASTs and asset metadata turns 20-minute scans into seconds.
• Gamified Health Dashboard: Track exact Health Scores and metrics over time to see if your project is healing or actively degrading.
• Interactive Tutorials: Learn the tool via step-by-step in-editor overlays—no 40-page wiki required.
• One-Click IDE Integration: Click an issue to instantly ping the GameObject in your scene or open your IDE at the exact line of offending code.

🛠️ TAILORED TO YOUR PROJECT, NOT AGAINST IT

Worried about getting drowned in false positives because your project has a "unique" architecture? Don't be. Archon is relentlessly customizable.

• Granular Control: Tweak complexity thresholds, memory budgets, and severities for every single analyzer. You can ignore specific folders, scripts, prefabs, or even single lines of code using an advanced Ignore Rules system. There are a lot of fine-tuning options, including specific issue overrides, file-scoped patterns, and global regex ignore rules.
• Built-in Knowledge Base: You don't need to be a Senior Optimization Engineer to use this. Archon includes built-in, detailed documentation for every issue it finds. It tells you exactly why it's bad, how to fix it manually, and what the performance benefits are—right inside the editor.

THE ANALYZER ARSENAL

Archon packs dozens of highly aggressive analyzers to audit every corner of your project:

C# Script Analyzers

• Performance Killers: Garbage Collection allocations, GetComponent in loops, Static Reference Leaks, Inefficient Physics Calls, and Coroutine Smells.
• Code Rot: Dead Code, Code Duplication (Smart Fuzzy Match), Unused Usings, Magic Literals, and Banned/Obsolete APIs.
• Architecture Warnings: God Scripts (bloated classes), Script Dependencies (spaghetti code), Cyclomatic Complexity, and Script Execution Order conflicts.

Asset & Scene Analyzers

• The Classics: Missing References (Nulls, Missing Scripts) and Cross-Scene Dependencies.
• Heavy Assets: Unoptimized Textures (NPOT, wrong compression), Audio (wrong load types), Model Complexity (polycount, R/W issues), and Animation Curves.
• Scene Bloat: Scene Heaviness (verts/lights/particles overload), UI Canvas Overdraw, and Component Overloads.

Project Sweepers

• Find Duplicate Assets: Locate exact file clones wasting your disk space.
• Find Unused Assets: Safely identify assets not referenced anywhere.
• Configuration Audits: Physics Matrix cleanup and Tags & Layers validation.
• Housekeeping: Sweep up Empty Folders and Orphaned Meta Files.

THE ARSENAL: Every Single Analyzer Archon Runs

If you want to know exactly what Archon is tearing apart and inspecting in your project, here is the raw, unfiltered list. No fluff, just the tools that will save your framerate and your sanity.

C# SCRIPT ANALYZERS (ROSLYN-POWERED)

Deep code inspection that understands your logic, not just text search.

Performance Analyzers:

• Garbage Collection Analyzer: Hunts down boxing, hidden allocations, and LINQ inside your hot paths (Update, FixedUpdate, etc.).
• GetComponent in Loop Analyzer: Flags expensive GetComponent calls hiding inside loops.
• Inefficient Physics Call Analyzer: Catches raycasts without layer masks, infinite distances, and allocating physics variants.
• Static Reference Leak Analyzer: Finds static fields holding onto GameObjects or Unity Events that will inevitably cause memory leaks.
• Coroutine Smell Analyzer: Spots missing yield return, string-based invocations, and nested coroutine overhead.
• Cyclomatic Complexity Analyzer: Identifies unmaintainable, overly complex methods that desperately need refactoring.

Code Quality Analyzers:

• Banned & Obsolete API Analyzer: Automatically detects (and can autofix!) deprecated or custom-banned method calls.
• Dead Code Analyzer: Finds unused methods, events, and properties that are just taking up space.
• Code Duplicate Analyzer: Uses Smart Fuzzy Match to find copy-pasted logic across your entire codebase.
• Unused Using Analyzer: Spots unnecessary namespace imports and strips them out automatically.
• Magic Literal Analyzer: Catches hardcoded magic numbers and strings that should be constants.
• Events & Messaging Analyzer: Warns about static UnityEvent forwarders and unassigned events.

Architecture Analyzers:

• God Script Analyzer: Flags massive monolithic classes based on line count, dependencies, complexity, and method counts.
• Script Dependency Analyzer: Visualizes and measures tight coupling and spaghetti code between your scripts.
• Script Execution Order Analyzer: Checks for conflicts and enforces required execution order rules.
• Duplicate Script Name Analyzer: Prevents critical architecture clashes from identically named scripts in different namespaces.

ASSET & SCENE ANALYZERS

Stop bloated assets and broken scenes from ruining your build.

Optimization Analyzers:

• Texture Analyzer: Audits max resolution, NPOT, Read/Write status, missing MipMaps, and unoptimized compression formats.
• Audio Analyzer: Checks for "Decompress on Load" bloat, force-to-mono for short clips, and unoptimized sample rates.
• Model Analyzer: Flags models with high polygon counts, missing LODs, Read/Write enabled, and unnecessary imported cameras/lights.
• Animation Analyzer: Detects unoptimized compression, constant curves, and scale curves that eat performance.
• Scene Heaviness Analyzer: Profiles your scenes for absurd vertex counts, excessive lights, particle systems, and reflection probes.
• Shader Analyzer: Catches missing fallbacks and variant bloat that will destroy your build times.
• UI Canvas Analyzer: Identifies overdraw risks, missing Event Systems, and excessive raycasters/hierarchy depth.
• Component Overload Analyzer: Flags GameObjects staggering under the weight of too many components.

Integrity Analyzers:

• Missing Reference Analyzer: The classic lifesaver. Finds null references, missing scripts, and missing UnityEvent listeners.
• Asset Dependency Analyzer: Maps out exactly which assets rely on which, preventing accidental inclusion of massive files.
• Cross-Scene Dependency Analyzer: Warns you when objects reference things in scenes that aren't loaded or aren't in the build.
• Scene Flow Analyzer: Maps how your scenes transition into one another.

Project Management Analyzers:

• Duplicate Asset Analyzer: Finds exact file clones across your project that are eating disk space.
• Unused Assets Analyzer: Confidently identify assets that are never referenced.
• Physics Matrix Analyzer: Recommends disabling collision layers that don't need to interact.
• Tags & Layers Health Analyzer: Finds unused tags/layers and enforces naming rules.
• Naming Convention Analyzer: Enforces strict naming rules for your assets and prefabs via regex or required suffixes.

UTILITY ANALYZERS

The final sweep for a clean repository.

• Empty Folder Analyzer: Safely finds and deletes empty directories.
• Orphaned Meta Analyzer: Cleans up .meta files left behind by external Git/OS deletions.

THE AUTOFIX ENGINE

Finding issues is only half the battle.

Archon includes one-click Autofixers for: Animations, Asset Naming, Audio Import Settings, Banned APIs, Missing References, Models, Physics Matrix, Tags & Layers, Textures, Unused C# Usings, UI Canvas Optimization (stripping useless raycast targets), Empty Folders, Orphaned Meta Files, and more in the future.

Roadmap & Future Updates

Major upcoming features include:

• More autofixers.
• More utilities.
• Translation.
• More whatever you want - welcome to my discord suggestions channel.

Support & Contact

If you have any questions, found a bug, or have a feature request, please use one of the following channels:

• Email: [ankonoanko00@gmail.com]
• Discord: [https://discord.gg/vCVh7BD9Ps] - help, bug reports, suggestions and more.

• Zero runtime overhead in release builds (#if DEVELOPMENT_BUILD || UNITY_EDITOR)
• Real-time .uss and .uxml file modification and direct saving
• TCP-based remote debugging (Editor ↔ Standalone build) with seamless ADB support for Android
• Automatic network discovery (UDP) for Editor-to-Build connection
• Runtime UI tree navigation via built-in Hierarchy View
• Interactive element picker and multi-element highlighter (Editor + Runtime)
• Live style resolution with full rule hierarchy, specificity calculation, pseudo-class, and inline style support
• Real-time USS variable resolution, overriding, and source tracking
• Advanced editing tools: property value scrubbing, and auto-suggestions
• Change tracker with batch save, individual revert, and modification overview
• Automated asset detection and registration (Zero setup)
• Integrated runtime dev panel with activity logger and variable inspector
• Tested on Unity 2021.3, 2022.3, 6.0, and 6.3

Real-time style inspector, hierarchy viewer, and live editor for Unity UI Toolkit (USS & UXML).

Select any UI element directly in Play Mode or in a running standalone build, edit its styles and attributes live, and save changes straight to your project files - no restart required.

Key Features

• Live Style & UXML Editing: Instantly modify USS styles and UXML attributes, then save them back to your project .uss and .uxml files with a single click. Batch save or revert any changes on the fly.
• Remote Debugging & ADB Support: Connect from the Unity Editor to running standalone builds (PC, mobile, console) via TCP and edit UI on the target device in real time. Includes seamless ADB support for Android device debugging.
• Runtime Hierarchy View: Navigate and inspect your entire UI tree directly in Play Mode or inside a built player.
• Interactive Element Picker: Precise element picking with multi-element highlighting that works flawlessly both in the Editor and on target devices.
• Advanced Editor Tools: Iterate faster with built-in property value scrubbing (drag to adjust values), and auto-suggestions for style properties.
• Full Style Resolution: See the complete rule hierarchy, specificity, matching USS rules, inline styles, pseudo-classes, and code insights.
• USS Variable Support: Real-time variable tracking, value overriding, and direct source navigation.
• Change Tracker: A comprehensive overview of all modifications with easy "save-all", reset functionalities, and individual property management.
• Zero Setup: Automatically detects stylesheets and panels. Works out of the box.

Details

• Exclusively built for Unity UI Toolkit (.uxml / .uss).
• Comprehensive runtime dev panel featuring Hierarchy, Style Inspector, Variables View, activity logs, and a changes list.
• Lightweight TCP + UDP discovery for seamless Editor ↔ Build connections.
• Tested on Unity 2021.3, 2022.3, Unity 6.0, and 6.3.
• Includes an interactive in-editor tutorial, text documentation, and a sample scene to get you started quickly.

Support & Contact

If you have any questions, found a bug, or have a feature request, please use one of the following channels:

• Email: [ankonoanko00@gmail.com]
• Discord: [https://discord.gg/vCVh7BD9Ps] - help, bug reports, suggestions and more.

Core Architecture & Scanning

• Universal Reflection Scanning: Automatically detects and hooks into Built-in, URP, HDRP, and custom 3rd-party VolumeComponent types without hardcoding.
• Smart Parameter Classification: Automatically categorizes properties, analyzes their visual impact, and isolates "dangerous" parameters (to prevent rendering crashes).
• Feedback-Driven Probability: Includes a Like/Dislike feedback loop that adjusts parameter ProbabilityWeight under the hood to align with your preferences.

Variation Engine & Algorithms

• Deterministic Generation: Fully seed-based randomization controlled by a global Chaos Level guarantees reproducible results.
• 13+ Mood Profiles: Purpose-built algorithms (Cinematic, Cyberpunk, Glitch, Noir, Ethereal, etc.) that intelligently constrain specific parameters rather than guessing.
• 16 Color Harmony Modes: Mathematically enforces strict color theory (Triadic, Split-Complementary, Golden Hour, Scene-Based) across all color properties.
• Custom Palette Forcing: Map your post-processing colors strictly to a custom Gradient with adjustable blending strength.

Workflow & Iteration Tools

• Batch Visual Gallery: Renders multi-candidate previews using temporary RenderTextures. Supports two generation modes: "Diverse" (broad exploration) and "Refining" (micro-iterations).
• Nudge & Shift Math: Dedicated algorithms to mathematically offset values by a tiny fraction, allowing you to fine-tune without losing the core aesthetic.
• Non-Destructive History: Auto-captures VolumeSnapshot states. Supports instant baseline restoration, history limits, and safe experimentation.
• Granular Locking & Comparison: Lock specific overrides or entire components. Compare changes via an interactive A/B split-screen window (PostProcessingCompareWindow).

Export, Storage & Integration

• Preset System: Save your favorite generated logic as a reusable RandomizerPreset (ScriptableObject) with embedded preview PNGs.
• Animation Generator: Automatically builds an AnimationClip (with perfectly mapped AnimationCurves) transitioning smoothly between any two Volume Snapshots.
• Asset Baking: Export your active Volume Profile into a clean, new asset, leaving your original templates untouched.
• Editor-Only: 100% Editor script logic. Zero runtime overhead and completely clean builds.

Setting up post-processing volumes takes time. If you are a programmer or solo developer, you probably just want your game to look decent — so you can get back to coding.

Anko Post-Processing Generator automates your visual style. It is not a chaotic randomizer. It is a smart workflow tool that builds professional visual profiles in seconds.

Whether you are a programmer who just wants the game to look good, or an artist looking for a smart tool to break a creative block — this generator handles the heavy lifting.

Top Features:

• 1-Click Visual Gallery: Pick a mood (Cyberpunk, Horror, Cinematic) and click Generate. The tool creates a grid of unique visual variations. Pick the best one and apply it instantly.
• Adaptive Feedback — The Tool Learns Your Taste: Hit Like or Dislike on any result. The generator adjusts its internal weights and gets smarter with every click — nudging future results closer to what you actually want.
• Reproducible Results with Seeds: Every generated look is tied to a numeric Seed. Share one number with your teammate — they paste it in and get the exact same result. Perfect for collaborative workflows.
• Smart Math, Not Pure Chaos: The algorithm uses color theory (Triadic, Complementary, Analogous) and per-mood stylistic rules. You get real art direction, not a broken neon result. Need something wilder? Turn the Chaos slider up.
• Nudge & Lock: Found a result you almost like? Lock the perfect parameters and gently Nudge the rest to find happy accidents — without ruining what's already working.
• 100% Safe to Experiment: Compare changes with a built-in A/B Split-View slider. Broke something? Restore your original setup in one click using Snapshot History.
• Save & Share Presets: Found a perfect look? Save it as a reusable Preset with a preview thumbnail — easy to reapply to any scene or share across a team.
• Color Palette Lock: Force the generator to sample colors exclusively from a gradient you provide. Essential for branded projects or scenes with a strict color language.
• 15 Genre Profile Templates: Never start from a blank profile again. Built-in templates (Cinematic, Cyberpunk, Arctic, Horror, Noir and more) add the right components automatically — correctly tuned for URP or HDRP.
• Bake to Animation: Need a "Low Health" screen effect? Bake the transition between two visual states directly into a standard Unity AnimationClip — no scripting required.
• Zero Runtime Overhead: Editor-only. Nothing ships to your players — no performance cost, no build bloat.

Save hours of manual tweaking. Get a professional look in seconds.

Render Pipeline Compatibility

✅ URP (Universal Render Pipeline) — Fully supported. All features available.

✅ HDRP (High Definition Render Pipeline) — Fully supported. All features available.

⚠️ Custom RP — Partially supported. Scanning, randomization and mood system work if your Custom Render Pipeline uses Unity's Volume system (VolumeProfile/VolumeComponent). Profile templates will fall back to URP-style components.

🚫 Built-in (Legacy) Render Pipeline — Not supported. The tool relies on Unity's Volume API (VolumeProfile/VolumeComponent), which is not used by the Built-in pipeline. Profile creation templates are available, but scanning and randomization will find no components to work with. Consider upgrading to URP — Unity's recommended pipeline for new projects.

A quick start guide is included inside the package.

The tool is intuitive out of the box — no lengthy documentation needed. Questions? You're welcome in my Discord!

Roadmap & Future Updates

Major upcoming features include:

• AI Integration: Smart text-to-profile generation.
• Global Lighting Control: Expanding the engine to manage Scene Lights, Ambient settings, and Skyboxes.

Support & Contact

If you have any questions, found a bug, or have a feature request, please use one of the following channels:

• Email: [ankonoanko00@gmail.com]
• Discord: [https://discord.gg/vCVh7BD9Ps] - help, bug reports, suggestions and more.

Technical Details

• UI Framework: Strictly UI Toolkit (Editor-only).
• Supported Versions: 2021.3, 2022.3, 6.0, and 6.3.
• Data Storage: Lightweight JSON files (no ScriptableObjects).
• Architecture: Split into Internal_Builder (authoring tool) and Distributable_Core (lightweight runtime for embedding).
• Dependency Management: Built-in exporter with automatic namespace relocation (zero dependencies, zero conflicts).
• Styling: Native UXML and USS files.

Key Features

• Zero-code Editor: Visual interface for creating and editing steps.
• Smart Element Picker: Interactive element selection directly in your custom window (automatically grabs element name, class, and bounds).
• 1-Click Auto-Injection: Automatically hooks into and starts the flow when the target window opens.
• Event-Based Auto-Advance: Proceeds to the next step exactly when the user clicks the highlighted target element.
• One-Line API: Control playback via a simple static class (InteractiveTutorial.Play("TutorialId");).
• Visual Customization: Full control over colors, arrow directions, anchors, and offsets.
• State Management: Built-in progress tracking (saves completed tutorials and last active step).

Yes, this is a tutorial creator for assets. For asset developers, not for games.

Users don't read manuals. Build interactive UI Toolkit onboarding flows that point exactly where to click. Export the lightweight core, auto-change the namespace, and ship it directly inside your asset with zero dependencies or conflicts.

⚠️ Important: Compatibility Note

Please note that this asset works only with UI Toolkit (Editor-only) and does not support IMGUI. It requires a Unity version with UITK support and has been tested on Unity 2021.3, 2022.3, 6.0, and 6.3.

Key Features:

• Zero Hardcoding: Create steps without writing a single line of code. The entire flow is saved into lightweight, easily readable JSON data files. No bloated ScriptableObjects, just clean data that runs seamlessly.
• Event-Based Auto-Advance: Set a step to wait for a specific user action. The tutorial automatically moves forward the exact moment the user clicks the highlighted target button.
• One-Line API: Trigger any specific tutorial flow using a single line of code InteractiveTutorial.Play("MyTutorial");.
• 1-Click Auto-Injection: Skip the boilerplate initialization code. Toggle the auto-inject feature, and the tutorial automatically hooks into your target window as soon as it opens.
• Smart Element Picker: Click directly on elements in your custom window to select them. The picker grabs the element by name or class, calculates its bounds, and snaps the tooltip perfectly in place.
• Full Visual Customization: Your tutorial should look like your tool. Tweak colors, arrow directions, anchors, and offsets so everything feels native to your design.

💎 Clean & Lightweight Export: Rest assured, exporting your tutorial copies only the minimal logic needed for the tutorial to function. Zero heavy builder code, zero bloat, and zero third-party dependencies in your shipped asset.

Includes an interactive "Meta-Tutorial" - an onboarding flow built with TutorCreator to teach you how to use TutorCreator itself. Classic text documentation is also included just in case.

Support & Contact

If you have any questions, found a bug, or have a feature request, please use one of the following channels:

• Email: [ankonoanko00@gmail.com]
• Discord: [https://discord.gg/vCVh7BD9Ps] - help, bug reports, suggestions and more.

Features:

Total 200 themes of FULL ARRANGED tracks in the Pack

Number of Audio Wavs: 200

Number of Audio Cues: 200

Sample rate / bit rate: 44.1kHz / 16bit Stereo WAVs

Does music loop: NO

Minutes of audio provided: 8:31:32

Supported Development Platforms: ANY

Supported Target Build Platforms: ANY

Documentation: N/A

Important/Additional Notes: N/A

Dark Ambient Music Pack Vol2

Step into an endless void with eerie children's whispers and slow-tempo cinematic horror.

#DarkAmbient #CreepyVibes #HorrorSoundtrack

[ Previews ]

This Music Pack includes 200 tracks with a total length of 8:31:32 and is divided into multiple previews as shown below.

Aeterna

Step into an endless void with eerie children's whispers and slow-tempo cinematic horror.

#DarkAmbient #CreepyVibes #HorrorSoundtrack

https://youtu.be/HhQ8hmF2sMA

Vex

Unsettling whispers and haunting echoes designed to provoke deep psychological dread.

#DarkAmbient #EerieMusic #PsychologicalHorror

https://youtu.be/Z6YV-xLANHo

Polycount (No LOD system included)

Morthessa

Faces 26864 – Tris 53307 – Verts 30566

Morthessa – Full Set (Full Outfit)

Faces 45687 – Tris 90795 – Verts 51304

Weapon (separate mesh)

Faces 1428 – Tris 2734 – Verts 1357

Rig & Animation Compatibility

• Rigged to Epic Skeleton with preserved main hierarchy
• Compatible with standard Unreal Engine animations
• Facial animation supported via morph targets

Additional bones are included for extended control and optional physics setups.

Full list of additional bones is available in the documentation.

Facial Blendshapes

• 52 Apple ARKit blendshapes
• Calibrated for facial animation and expression control
• Tested with Live Link Face in Unreal Engine
• Compatible with facial capture and streaming workflows

⭐ Social & Project Links

YouTube | Instagram | Unity | ArtStation | LinkedIn

━━━━━━━━━━━━━━━━━━━━━━━━━

▶ Video Preview (Unreal Engine & Unity):

https://youtu.be/r9lTdzFgOXM?si=bSmFfj4l0xowxEk1

Production-friendly character built for seamless integration into real-time projects.

Morthessa is a dark cleric with a strong visual identity, suitable for both hero and secondary roles.

Designed for gameplay, cinematics, and interactive environments, she works smoothly within Unreal Engine and Unity pipelines.

Key Features

• Fully game-ready female character
• Modular body and outfit parts
• Epic Skeleton compatible (UE5 proportions)
• Apple ARKit facial blendshapes
• Advanced material setup with easy color control
• Adjustable character parts via materials and meshes
• Clean and production-friendly asset structure

Polycount (No LOD system included)

Morthessa

Faces 26864 – Tris 53307 – Verts 30566

Morthessa – Full Set (Full Outfit)

Faces 45687 – Tris 90795 – Verts 51304

Weapon (separate mesh)

Faces 1428 – Tris 2734 – Verts 1357

Rig & Animation Compatibility

• Rigged to Epic Skeleton with preserved main hierarchy
• Compatible with standard Unreal Engine animations
• Facial animation supported via morph targets

Additional bones are included for extended control and optional physics setups.

Full list of additional bones is available in the documentation.

Facial Blendshapes

• 52 Apple ARKit blendshapes
• Calibrated for facial animation and expression control
• Tested with Live Link Face in Unreal Engine
• Compatible with facial capture and streaming workflows

Modularity & Customization

• Fully modular character structure
• Individual body and outfit parts can be enabled or disabled
• Hidden geometry under clothing for improved performance
• Easy color customization using material instances
• Designed to support multiple variations from a single base character

Materials & Textures

• Advanced real-time materials included
• Custom Shader Graph materials for color and detail customization (Unity)
• MatID masks for fast and intuitive color changes
• Designed for efficient iteration and customization

Engine Compatibility & Projects

Unreal Engine

• Supported versions: 4.24+
• Epic Skeleton compatible with additional bones
• Facial animation supported via morph targets
• Advanced material instances with MatID color masks
• Demo scene included for preview and testing
• Basic third-person demo animations included
• Hair wind simulation setup included

Unity

• Compatible with Built-in, URP, and HDRP render pipelines
• Humanoid rig with eye and jaw bones
• Facial animation driven by BlendShapes
• FullSet.fbx included for customization
• Works with standard Humanoid animations from the Asset Store

Important Notes

• Advanced gameplay systems, controllers, and custom animation systems are not included
• Environments shown in preview images or videos are used for presentation purposes only

• Rigged: Yes
• Animated: Yes(1 Idle)
• Number of characters: 1
• Vertex counts of character: 14483
• Number of Materials: 14
• Number of Textures: 36
• Texture Resolutions: 2048x2048, 4096x4096
• Supported Render Pipelines: URP
• Rigging: Yes
• Prefabs: 4

Bring your fantasy world to life with this high-quality, stylized Pig Butcher character! Perfectly suited for RPGs, dungeon crawlers, or fantasy adventure games, this model serves excellently as a formidable enemy mob, a menacing boss, or an immersive NPC.

The model is thoroughly optimized for game engines with clean topology, high-quality PBR textures, and a professional rig ready for your custom animations.

Number of Unique Meshes: 24

Number of Prefabs: 27

Collision: Yes, automatically generated

LODs: No

Number of Materials: 5

Number of Textures: 21

Texture Resolutions: 4096x4096px, 2048x2048px

(AlbedoTransparency, AO, Normal, MetallicSmoothness, Emissive)

Textures format: TGA

UVs: channel 0: overlapping; channel 1: non-overlapping

Polycount:

• Bookcase without Books - 10116 tris
• Bookcase with Books - 94644 tris
• Bookcase Ladder - 136 tris
• Books (10 meshes) - 304/320/248/248/248/320/248/248/248/248 tris
• Stacks of Books (5 meshes) 4048/4656/816/1368/1120 tris
• Papers (4 meshes) - 2/40/8/2 tris

Universal Render Pipeline (URP)

Vintage Bookcase with Books and Papers includes 24 different meshes:

• Bookcase with Books
• Bookcase without Books
• Bookcase Ladder
• Books (10 meshes)
• Stacks of Books (5 meshes)
• Papers (4 meshes)

BONUS! Textures for HDRP (MaskMap, Normal, BaseColor, Emissive)

Package includes:

• 22 Grassland - Stamp - Brush Texture

Technical specifications:

• Resolution: 4096 x 4096

• Texture format: PNG

• Texture type: Heightmap

Compatibility:

• Unity 2021+

• Built-in / URP / HDRP compatible

Grassland Heightmap Pack

This package contains 22 high quality grassland heightmaps designed for terrain creation and landscape generation.

These heightmaps can be used to quickly create natural grassland environments, hills and terrain formations. Suitable for open world environments and environment design workflows.

Package includes:

• 102 Mountain Stamp - Brush Texture

Technical specifications:

• Resolution: 4096 x 4096

• Texture format: PNG

• Texture type: Stamp/ Heightmap textures

• Can be used as terrain stamps or heightmaps

Compatibility:

• Unity 2021 and newer

• Built-in Render Pipeline

• URP compatible

• HDRP compatible

The brushes are optimized for terrain sculpting and can also be used as heightmaps in terrain generation tools and environment creation workflows.

Mountains Stamp Pack

This package contains 102 high quality mountain stamp textures designed for terrain creation, environment design and landscape sculpting.

The stamps can be used both as terrain stamps and as heightmap textures, allowing developers and environment artists to quickly create natural looking mountains, cliffs and rocky landscapes.

These textures are suitable for terrain sculpting tools, procedural terrain generators and heightmap based workflows. The pack is ideal for creating realistic outdoor environments in open world games, RPG environments and natural scenes.

Ideal for:

• Terrain sculpting

• Mountain and cliff creation

• Landscape generation

• Heightmap based terrain workflows

• Environment art pipelines

Package includes:

• 85 Island Stamp - Brush Texture

Technical specifications:

• Resolution: 4096 x 4096

• Texture format: PNG

• Texture type: Heightmap / Stamp

Compatibility:

• Unity 2021+

• Built-in / URP / HDRP compatible

Island Stamps / Heightmaps Pack

This package contains 85 high quality island stamps that can be used both as terrain brushes and stamp textures.

The pack is designed for fast terrain creation and is ideal for building islands, coastlines and natural landscapes. Perfect for open world environments, survival games and environment design workflows.

Package includes:

• 25 Rocky Stamp - Brush Texture

Technical specifications:

• Resolution: 8192 x 8192

• Texture format: EXR

• Texture type: Heightmap / Stamp

Compatibility:

• Unity 2021+

• Built-in / URP / HDRP compatible

This package contains 25 high-quality rocky terrain heightmaps designed for terrain creation and landscape generation.

These heightmaps can be used to quickly create natural rocky environments, canyon surfaces, rugged hills, and detailed terrain formations. 

Perfect for desert, canyon, and rocky biome environments, making them ideal for open-world scenes and environment design workflows.