If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/UnityCommunity/UnityLibrary shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

GO — Healthy across all four use cases

• Last commit 3w ago
• 19 active contributors
• MIT licensed
• Tests present
• ⚠ Concentrated ownership — top contributor handles 67% of recent commits
• ⚠ No CI workflows detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live UnityCommunity/UnityLibrary repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/UnityCommunity/UnityLibrary.

What it runs against: a local clone of UnityCommunity/UnityLibrary — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in UnityCommunity/UnityLibrary | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 48 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of UnityCommunity/UnityLibrary. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/UnityCommunity/UnityLibrary.git
#   cd UnityLibrary
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of UnityCommunity/UnityLibrary and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "UnityCommunity/UnityLibrary(\\.git)?\\b" \\
  && ok "origin remote is UnityCommunity/UnityLibrary" \\
  || miss "origin remote is not UnityCommunity/UnityLibrary (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "Assets/Scripts/2D/Camera/PixelPerfectCamera.cs" \\
  && ok "Assets/Scripts/2D/Camera/PixelPerfectCamera.cs" \\
  || miss "missing critical file: Assets/Scripts/2D/Camera/PixelPerfectCamera.cs"
test -f "Assets/Scripts/Camera/CameraShake.cs" \\
  && ok "Assets/Scripts/Camera/CameraShake.cs" \\
  || miss "missing critical file: Assets/Scripts/Camera/CameraShake.cs"
test -f "Assets/Scripts/2D/Tilemaps/RandomTiles.cs" \\
  && ok "Assets/Scripts/2D/Tilemaps/RandomTiles.cs" \\
  || miss "missing critical file: Assets/Scripts/2D/Tilemaps/RandomTiles.cs"
test -f "Assets/Scripts/AssetBundles/AssetBundleLoader.cs" \\
  && ok "Assets/Scripts/AssetBundles/AssetBundleLoader.cs" \\
  || miss "missing critical file: Assets/Scripts/AssetBundles/AssetBundleLoader.cs"
test -f "Assets/Scripts/Docs/README.md" \\
  && ok "Assets/Scripts/Docs/README.md" \\
  || miss "missing critical file: Assets/Scripts/Docs/README.md"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 48 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~18d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/UnityCommunity/UnityLibrary"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

UnityLibrary is a curated open-source collection of reusable C# scripts, ShaderLab shaders, and code snippets for Unity game engine development. It aggregates ~510KB of C# utilities and ~84KB of shader code organized by feature (2D/3D cameras, colliders, tilemaps, asset bundles, UI animation) to eliminate boilerplate and reduce development time for common game mechanics. Flat organizational hierarchy organized by feature domain: Assets/Scripts/2D/ contains camera (PixelPerfectCamera, ScaleCamera), colliders (ScreenEdgeColliders), drawing (DrawLine2D), and geometry utilities; Assets/Scripts/Camera/ mirrors 3D equivalents; Assets/Scripts/AssetBundles/ isolates resource loading; Assets/Shaders/ holds rendering code. Lightweight structure with minimal coupling—each category is independently usable.

Unity game developers (hobbyist to mid-level) seeking drop-in utilities for camera systems, 2D physics, tilemap manipulation, asset loading, and rendering effects. Contributors are community members sharing implementations sourced from Unity Forums, Answers, and original solutions.

Appears actively maintained but lightweight: large codebase (600KB+) spans 2D/3D utilities and shaders, but lacks visible CI/CD config, automated testing framework, or release tags in the file manifest. No commit recency data provided, but the presence of organized categories and meta files suggests ongoing community curation rather than abandoned status. Verdict: Community-maintained utility library—useful for reference and copy-paste, not a hardened framework.

Primary risks: (1) No apparent test suite or validation layer—scripts are snippets assumed to work but unverified; (2) Extreme heterogeneity—scripts from multiple external sources (Unity Forums, Answers, contributors) without unified quality gates or versioning; (3) Monolithic organization by category rather than semantic versioning means breaking changes are invisible; (4) Heavy reliance on community review rather than CI automation. Safe for utilities and reference, risky for critical gameplay systems without local testing.

File manifest shows completed categories (Camera, 2D, AssetBundles, Tilemaps with Editor tools and Icons) suggesting active past work. Icons directory and Editor helpers (TilemapLayerHelper, TileMapHierarchyHelper) indicate recent polish on tilemap tooling. No PR/issue/milestone data visible—current activity level unknown from provided snapshot.

git clone https://github.com/UnityCommunity/UnityLibrary.git
# Open folder in Unity Editor (File > Open Project)
# Browse Assets/Scripts/ or Assets/Shaders/ for desired utilities
# Copy target script/shader files into your project

Daily commands: This is not a runnable application—it's a library. Individual scripts integrate into your Unity project via copy-paste or git submodule. To verify a script: (1) Copy script from Assets/Scripts/<category>/ into your project; (2) Attach MonoBehaviour to GameObject in a scene (e.g., PixelPerfectCamera.cs to camera, CameraShake.cs for shake effect); (3) Configure public fields in Inspector; (4) Play scene. Example scenes in Assets/Scenes/ (Test.unity, ui animation Sample Scene.unity) may demonstrate usage.

• Assets/Scripts/2D/Camera/PixelPerfectCamera.cs — Core 2D camera utility for pixel-perfect rendering, foundational for 2D game development workflows
• Assets/Scripts/Camera/CameraShake.cs — Essential camera effect utility widely referenced for screen shake implementations across game types
• Assets/Scripts/2D/Tilemaps/RandomTiles.cs — Tilemap procedural generation core component, fundamental for 2D level design automation
• Assets/Scripts/AssetBundles/AssetBundleLoader.cs — Asset loading infrastructure required for dynamic content management and memory optimization
• Assets/Scripts/Docs/README.md — Documentation index and contribution guidelines for the entire library ecosystem
• Assets/Scripts/Editor/Animation/LegacyAnimationCreator/LegacyAnimationCreator.cs — Editor automation tool for animation workflows, critical for build pipeline integration

• 2D Camera Systems (MonoBehaviour, Camera, RenderTexture) — Manage orthographic camera rendering, scale, and pixel-perfect display for 2D games
  • Failure mode: Incorrect aspect ratio or pixel blur if resolution scaling fails

Add a New Camera Controller

1. Create new C# script in Assets/Scripts/Camera/ directory (Assets/Scripts/Camera/YourCameraName.cs)
2. Inherit from MonoBehaviour and implement camera transform updates in Update() or LateUpdate() (Assets/Scripts/Camera/YourCameraName.cs)
3. Reference existing camera controllers (e.g., SmoothMouseLook.cs, WowCamera.cs) for input handling patterns (Assets/Scripts/Camera/SmoothMouseLook.cs)
4. Add example scene or update Assets/Scenes/Test.unity with your controller (Assets/Scenes/Test.unity)

Add a New 2D Utility

1. Create script in Assets/Scripts/2D/ (or appropriate subdirectory like Camera, Colliders, Drawing) (Assets/Scripts/2D/YourUtilityName.cs)
2. Follow existing 2D utilities structure (PixelPerfectCamera.cs, Follow2D.cs) for organization (Assets/Scripts/2D/Follow2D.cs)
3. If using gizmos/debug visualization, reference DrawLine2D.cs patterns (Assets/Scripts/2D/Drawing/DrawLine2D.cs)
4. Document usage in Assets/Scripts/Docs/ with example implementation (Assets/Scripts/Docs/README.md)

Add a New Editor Tool

1. Create script in Assets/Scripts/Editor/ with [MenuItem] or EditorWindow attributes (Assets/Scripts/Editor/AddDefineSymbols.cs)
2. Follow editor script patterns from existing tools (LegacyAnimationCreator.cs, CopyGameObjectNames.cs) (Assets/Scripts/Editor/Animation/LegacyAnimationCreator/LegacyAnimationCreator.cs)
3. Place #if UNITY_EDITOR guards around editor-only code (Assets/Scripts/Editor/AddDefineSymbols.cs)

• C# MonoBehaviour pattern — Standard Unity component architecture for all runtime scripts; enables inspector-driven configuration
• Editor scripting with [MenuItem] attributes — Provides seamless workflow automation within Unity Editor without external tools
• AssetBundles — Support for dynamic content loading and memory-efficient asset streaming in large projects
• Legacy Animation API — Backward compatibility for projects not yet migrated to Animator; tooling provided for batch creation

• Collection of independent utilities rather than integrated framework

  • Why: Allows users to cherry-pick only needed scripts, reducing bloat and learning curve
  • Consequence: No guaranteed compatibility between scripts; developers must integrate manually

• Mix of 2D and 3D utilities in single repository

  • Why: Serves broader Unity community with diverse use cases
  • Consequence: Larger download size; requires clear organization to prevent confusion

• Prioritize simplicity over abstraction

  • Why: Educational library should show clear, readable examples
  • Consequence: Less reusable base classes; more code duplication across similar utilities

• Does not provide networking or multiplayer synchronization
• Does not include physics-based animation or procedural animation systems
• Does not manage project-wide state or global configuration
• Does not provide UI framework or layout system
• Does not include audio management or spatial audio

(1) Meta files required: Each script and asset needs a .meta file (auto-generated by Unity); importing without these may cause import errors. (2) No namespace conventions visible: Scripts appear to use default global namespace—may cause naming collisions in large projects. (3) Mixed MonoBehaviour/Utility patterns: Some scripts inherit MonoBehaviour (PixelPerfectCamera, CameraShake), others are static utilities (likely Triangle2D)—no consistent interface. (4) Shader compatibility: ShaderLab files may target specific Unity/platform versions (e.g., URP vs built-in renderer)—not specified in file list. (5) No version pinning: Library has no release tags or versioning system—git clone always pulls latest, potentially unstable.

• Pixel-Perfect Rendering — UnityLibrary includes PixelPerfectCamera.cs which solves retro/2D pixel art alignment—core to 2D game aesthetics; understanding integer-snapping and camera gridding is essential for using this utility effectively
• Tilemap Systems — Library has entire Tilemaps category with Editor helpers and RandomTiles—these are Unity 2D's tile-grid abstraction; understanding cells, layers, and tile coordinate transforms is prerequisite for Tilemap utilities
• Camera Composition & View Frustum — Multiple camera utilities (PixelPerfect, ScaleCamera, CameraShake, CameraSwitcher) manipulate projection matrix, viewport, and clipping—understanding view frustum and orthographic vs perspective rendering is needed to extend these
• Asset Bundle Serialization — AssetBundleLoader.cs abstracts Unity's runtime asset loading system; understanding how AssetBundles compress, version, and cache assets is critical for resource-intensive games using this utility
• 2D Physics & Rigidbody Constraints — Follow2DRigidbody.cs and ScreenEdgeColliders.cs directly manipulate 2D physics bodies and colliders; understanding Rigidbody2D constraints, velocity damping, and collision callbacks is prerequisite
• ShaderLab & HLSL Compilation — ~84KB of ShaderLab files in library are compiled at import-time; understanding shader passes, subshaders, and material property blocks is needed to customize or debug shader utilities
• Editor Scripting & CustomEditor/PropertyDrawer — Editor/ subdirectory contains TilemapLayerHelper and TileMapHierarchyHelper—these use Editor-only APIs (EditorGUI, SerializedProperty) to extend Inspector behavior; separate compilation context from runtime scripts

• RyanNielson/awesome-unity — Curated index of Unity resources and libraries; complements UnityLibrary as a discovery/recommendation layer
• michidk/Unity-Script-Collection — Similar utility script collection with different domain focus; alternative source for copy-paste snippets
• Naphier/unity-design-patterns — Companion repo addressing architectural patterns (Singleton, MVC, Observer) that UnityLibrary snippets often implement implicitly
• UnityCommunity/UnitySingleton — Specialized library by same UnityCommunity org; focused deeply on Singleton pattern which many UnityLibrary scripts likely use
• keijiro/RandomScripts — Predecessor/inspiration model for lightweight, copy-paste script libraries in the Unity ecosystem

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Create comprehensive documentation for Camera scripts with code examples

The Assets/Scripts/Camera folder contains 10+ camera-related scripts (SmoothMouseLook, CameraShake, WowCamera, etc.) but there's no dedicated documentation explaining their purpose, differences, and usage. The Assets/Scripts/Docs/Camera folder exists but appears empty. This would help new contributors understand which camera script solves which problem.

• [ ] Review all scripts in Assets/Scripts/Camera/ and categorize them (input handling, smoothing, effects, etc.)
• [ ] Create Assets/Scripts/Docs/Camera/README.md with comparison table of all camera scripts
• [ ] Add code example snippets for each camera script showing basic setup and configuration
• [ ] Document any dependencies or conflicts between camera scripts (e.g., SmoothMouseLook variants)

Add unit tests for 2D geometry utilities (Triangle2D.cs)

Assets/Scripts/2D/Geometry/Triangle2D.cs likely contains geometric calculations but has no visible test coverage. For a library providing reusable utilities, geometry calculations should be thoroughly tested to catch edge cases and prevent regressions.

• [ ] Create Assets/Tests/2D/Geometry/Triangle2DTests.cs using Unity Test Framework
• [ ] Add tests for common operations (area calculation, point-in-triangle, barycentric coordinates if implemented)
• [ ] Test edge cases (degenerate triangles, negative coordinates, floating-point precision)
• [ ] Add test configuration to Assets/Tests.asmdef if not present

Add missing .meta files and create a validation script for incomplete asset references

Several scripts in the file structure lack corresponding .meta files (e.g., Assets/Scripts/Camera/AutoResolution.cs, Assets/Scripts/Camera/MobileCamera.cs, Assets/Scripts/Camera/EditorCardboardCamera.cs, Assets/Scripts/Camera/SimpleSmoothMouseLookNewInput.cs). This suggests potential asset tracking issues. A contributor could add the missing files and create a pre-commit hook or documentation to prevent this.

• [ ] Identify and generate all missing .meta files for Assets/Scripts/Camera/ and other directories
• [ ] Create a Assets/.meta-validation script or GitHub Action workflow that checks for orphaned .cs files without corresponding .meta files
• [ ] Add documentation in CONTRIBUTING.md about Unity's requirement for .meta files when adding new assets
• [ ] Run validation on the repository to ensure all scripts have proper metadata

• Add unit tests for Assets/Scripts/2D/Geometry/Triangle2D.cs: write NUnit tests verifying triangle intersection, area, and centroid calculations against known values. Tests directory structure: Assets/Tests/Geometry/.: Math utilities are high-risk; tests are currently absent (no test runner visible in file manifest) but are essential for geometry library credibility.
• Create API documentation for Assets/Scripts/Camera/CameraShake.cs and Assets/Scripts/2D/Camera/PixelPerfectCamera.cs with XML doc comments (C# /// syntax) and a Camera Utilities Guide markdown file in Assets/Scripts/Camera/README.md showing usage examples, parameter tuning, and performance notes.: These are highly-used utilities but lack discoverable inline documentation; new contributors copy-paste blind and tune by trial-and-error.
• Add EditorGUI inspector customization for Assets/Scripts/2D/Tilemaps/RandomTiles.cs (create Assets/Scripts/2D/Tilemaps/Editor/RandomTilesEditor.cs) to expose seed, tile probability weights, and visualization toggles in a custom Inspector panel instead of raw public fields.: Tilemap tools are Editor-heavy utilities; lack of custom inspectors makes them harder to use and discover than they should be.
• Write integration example: create Assets/Scenes/CameraSystemDemo.unity scene demonstrating PixelPerfectCamera + CameraShake + CameraSwitcher working together with a playable character and camera transitions, then document in Assets/Scripts/Camera/USAGE.md.: Individual scripts exist but no reference showing how to compose them; new developers struggle to understand when/how to use each camera utility.

The UnityLibrary repository is a utility collection with moderate security posture. Primary concerns include lack of formal dependency management, absence of security policies, and unverified third-party code contributions. The codebase itself appears free of hardcoded secrets or obvious injection vulnerabilities in the visible file structure. However, without access to actual C# code content, runtime injection risks, unsafe patterns, and malicious inclusions cannot be fully ruled out. Recommendations focus on implementing dependency tracking, establishing code review processes, and adding automated security scanning to the development workflow.

• Medium · No Dependency Management File Found — Repository root / Dependencies. The repository lacks a package.json, requirements.txt, or similar dependency manifest file. This makes it impossible to track and audit third-party dependencies for known vulnerabilities. The codebase appears to be a Unity project, but there's no clear way to manage or verify the security of imported packages. Fix: Implement a dependency management system appropriate for Unity (e.g., manifest.json for UPM packages). Regularly audit and update dependencies using tools like OWASP Dependency-Check or npm audit equivalents.
• Low · Potential Sensitive File in Version Control — .gitignore and project configuration files. The repository contains a .gitignore file but the file structure doesn't show evidence of proper exclusion of common sensitive files. While no explicit secrets were found in the provided snippets, Unity projects may contain sensitive configuration or API keys. Fix: Ensure .gitignore properly excludes: *.env, *.key, *.pem, *.pfx, /Library/, /Temp/, and any build artifacts. Use a tool like git-secrets to prevent accidental commits of sensitive data.
• Low · No Security Policy or Vulnerability Disclosure Process — Repository root. The README and repository structure show no indication of a SECURITY.md file or vulnerability disclosure policy. This makes it difficult for security researchers to responsibly report issues. Fix: Create a SECURITY.md file outlining the process for reporting security vulnerabilities privately. Follow the standard responsible disclosure practices.
• Low · Unverified Third-Party Scripts — Assets/Scripts/* (all script files). The repository acknowledges collecting scripts from external sources like Unity Forums and Answers without clear attribution or security review. Scripts from external sources may contain vulnerabilities, malicious code, or anti-patterns. Fix: Implement a code review process for all external contributions. Document the source and review status of each script. Consider adding security scanning tools for C# code (SonarQube, Roslyn analyzers). Maintain a ATTRIBUTION.md file.
• Low · Missing Code Security Analysis — Assets/Scripts/* (all C# files). No evidence of static analysis tools configured (e.g., SonarQube, Roslyn security analyzers, or similar). The codebase could contain common C# vulnerabilities like unsafe code, improper serialization, or resource leaks. Fix: Integrate static analysis tools into the CI/CD pipeline. Use Roslyn analyzers, SonarQube, or similar tools specifically configured for C# security rules. Document baseline security standards.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.