Codebase Exporter & Asset Replacer Pro
Veridian Systems
$8.25
$16.50
50%OFF
(no ratings)
Jump AssetStore
Export codebase scripts and scene hierarchies into minified text payloads optimized for AI context limits. Locate reverse dependencies and safely batch-replace project GUIDs without opening scenes.Codebase Exporter & Asset Replacer Pro is a dual-utility Editor suite designed to streamline data extraction and project-wide dependency management.Extracting readable data from Unity, or safely tracking down and replacing old architecture, often requires tedious manual file management. This suite saves an incredible amount of time by automating these workflows directly within the Editor.Core Capabilities at a Glance:Rapid Batch Copying: Instantly aggregate dozens of C# scripts, JSON files, or compute shaders into a single, cleanly formatted text payload for external documentation, peer review, or web chat interfaces.Preserved Spatial Context: Standard copy-pasting loses Unity-specific data. Extract exactly how scripts are attached to GameObjects, what values are serialized in the Inspector, and what Assembly Definitions govern them.Reverse-Dependency Tracking: Quickly locate exactly what scenes or prefabs in your massive project rely on a specific placeholder material or deprecated script.Project-Wide Replacements: Execute multithreaded YAML modifications to structurally swap out broken dependencies or obsolete GUIDs across your entire project without needing to open a single scene.AI & LLM Optimized: Built-in Regex safely minifies whitespace and standard comments to maximize token efficiency when pasting architecture into AI chat windows.While the extracted text payloads are highly valuable for standard documentation or review, they are also heavily optimized to serve as token-efficient context for Large Language Models (LLMs) and AI workflows.Try the Free Lite Versions FirstIf you have any doubts about purchasing this asset, please consider trying the free, standalone lite versions of these tools on the Asset Store first to see if the workflow is right for you: Clean Script Exporter and Asset Replacer.While those free tools are fully functional and highly usable for basic tasks, this Pro suite is strictly superior. The paid upgrade introduces massive feature expansions—most notably the Exporter's ability to extract Scene Hierarchies and Inspector Variables, automated text payload chunking, and volatile RAM script backups—as well as deeply integrated cross-tool connectivity that allows the Exporter and Replacer to pass data seamlessly back and forth.Core Module 1: Codebase Exporter (Data Staging & Formatting)The Codebase Exporter acts as a centralized staging ground. It rapidly aggregates batches of files, filters out noise, explicitly defines your architectural boundaries, and outputs a cohesive plain-text payload for external review, documentation, or AI analysis.Frictionless Staging & Batch Copying: Rapidly aggregate scripts, compute shaders, and GameObjects into dual staging queues. Drag and drop single files or master folders directly into the interface. The ingestion engine relies on strict automated filtration, explicitly enforcing global extension whitelists (e.g., .cs, .compute, .json) and actively rejecting directories that match your custom ignore patterns (e.g., *.meta, Plugins/).Independent Workspaces & Preambles: Manage extraction tasks across six independent workspace tabs. Each workspace maintains its own staging queues and a dedicated Custom Preamble scratchpad. You can draft specific instructions or prompts, save them to a version-controlled Instruction Library, and seamlessly append them to the top of your exported text.Whitespace & Comment Minification: When pasting code into chat windows or external tools with strict length limits, dead space is restrictive. The engine features smart whitespace minification that strips completely empty lines while preserving structural horizontal indentation. Additionally, a Regex engine safely identifies and strips standard developer comments, while allowing you to explicitly preserve /// XML summaries to ensure formal API documentation remains intact.Deep Hierarchy & Variable Extraction: Scripts do not execute in a vacuum. The Hierarchy Extractor parses your queued Prefabs and Scene Objects, generating lightweight ASCII structural maps. Using Unity's native SerializedObject API, it safely extracts surface-level properties (integers, strings, object references) configured on the attached components. To reduce payload size, you can instruct the engine to ignore variables from default Unity namespaces (like Transform or CanvasRenderer) and focus strictly on your custom logic.Architecture & Assembly Mapping: The engine can parse the relative physical paths of all staged scripts to generate an ASCII directory tree at the top of your payload. It also traces parent Assembly Definitions (.asmdef), building a one-way dependency map so external readers explicitly understand your project's access rules.Payload Formatting & Chunking Protocol: Output your final payload as standard text, Markdown blocks with syntax highlighting, or strict XML tags (). If your staged codebase is massive, enable the Chunking Protocol. By defining a maximum limit, the engine mathematically evaluates your assets and safely severs the payload into sequential text files.Volatile RAM Snapshots & Text Backups: Before modifying your source files based on external feedback, take an instant memory snapshot of the active queue. The engine caches the raw text of your scripts into volatile Editor RAM, allowing you to seamlessly revert experimental changes in seconds without breaking Unity's internal GUID meta files. For persistent safety, you can generate timestamped .txt clones directly to your local disk.Core Module 2: Asset Replacer Pro (Dependency Management)While the Exporter extracts your architecture into readable formats, the Asset Replacer is built to destructively reorganize and optimize the raw files left behind in your project. It is engineered to track down scattered assets and structurally replace references at scale without requiring you to manually open a single scene.Reverse-Dependency Tracking (Asset Locator): Assign a source asset (Material, Texture, Script, or Prefab) to execute a project-wide background scan. Quickly locate every Scene, Prefab, or Material that actively relies on your target.Project-Wide Rewiring (Batch Replacer): Instead of manually opening hundreds of materials to swap a placeholder texture for a final asset, the Batch Replacer handles it globally. Drag your "Old" assets into the source column and your "New" assets into the target column to rewire the underlying structural GUIDs. The tool features an auto-pairing algorithm that evaluates filenames, automatically matching incoming targets and stripping common iteration tags (like _v2 or _new).Asset Consolidation: If a scan reveals a prefab relying on dependencies scattered across multiple disorganized folders, select them and click consolidate. The engine will physically move the selected assets and all of their underlying dependencies into a unified target directory—automatically structuring them into subdirectories without breaking internal links.Package Extraction: Cleanly extract a working subset of assets from a massive project. Bundle your initial source asset, all found dependent assets, and all of their internal requirements into a localized, ready-to-share .unitypackage.Simulation Mode (Dry Run): Because Batch Replacement modifies raw file data, the tool defaults to a "Simulate Only" mode. This executes the scan and generates a detailed checklist of affected files, allowing you to review and explicitly exclude specific targets before committing any destructive changes to your hard drive.Cross-Tool ConnectivityWhile the Exporter and Replacer operate as independent utilities, this Pro suite features an internal coordination script that allows the two Editor windows to function as a connected pipeline.Integrated Context Menus: You do not need to keep the Editor windows open to use the suite. Mass-select any combination of scripts, folders, or GameObjects in your Project or Hierarchy windows, right-click, and navigate to the Veridian menu to instantly route them into the Exporter's staging queues or the Replacer's batch sandbox.The Research Bridge (Locator ➔ Exporter): Execute a reverse-dependency scan to find obsolete prefabs relying on a deprecated script. From the Locator's bulk actions, click Send to Bundler. The suite bridges all found dependencies directly into the Exporter queue, allowing you to immediately extract their localized hierarchy configurations for external review.The Refactor Bridge (Exporter ➔ Replacer): Stage your obsolete scripts in the Exporter. Once you have rewritten them externally, click Stage for Batch Replacer. The coordinator automatically grabs all actively included scripts and injects them into the left side of the Batch Replacer sandbox, preparing the outdated assets for a project-wide swap without requiring you to manually locate them again.The Diagnostics Bridge (Replacer ➔ Exporter): If a Batch Replacement fails due to a corrupted serialized file or an OS-level file lock, the suite generates a critical error log. Clicking Export Errors instantly identifies the specific physical files that failed and adds them to the Exporter’s queue. It simultaneously injects the technical error log into the scratchpad, allowing you to easily copy the exact payload required to diagnose why the structural modification failed.Expand Your PipelineConsider exploring the rest of the Veridian ecosystem on the Unity Asset Store:Noise Texture Generator: Procedural PBR BakerA procedural texture baker powered by the Burst Compiler. Blend Voronoi, FBM, and SDF math to algorithmically generate and bake seamlessly tiling PBR materials without leaving the Unity Editor.Scene Object Replacer (Free)Swap thousands of assets without freezing the Editor. A high-performance tool for replacing Scene Objects, Materials, and Terrain details. Includes weighted randomization and advanced filtering.Requirements & CompatibilityMinimum Unity Version: Unity 2021 LTS or newer.Execution Scope: 100% Editor-only. All scripts are encapsulated within isolated Editor Assembly Definitions. The suite creates zero runtime overhead and is automatically stripped from compiled builds.Render Pipelines: Fully pipeline-agnostic (Built-In, URP, HDRP). The Asset Replacer operates on raw text files directly on your hard drive, operating completely independent of rendering logic.Native Dependencies: Built strictly using native .NET and C# libraries (System.Threading.Tasks, System.Text.RegularExpressions, System.Collections.Concurrent). Contains zero compiled third-party DLLs.Core Processing Architecture (Asset Replacer Pro)Asynchronous YAML Injection: Loading massive Scenes into active memory via standard AssetDatabase APIs simply to replace a reference causes extreme RAM spikes. The worker engine bypasses these APIs entirely. It utilizes asynchronous background threads to read raw serialized YAML text, using highly specific Regex patterns to physically inject optimized 32-character GUID references.Parallel Processing & Tail Latency: File reading and Regex evaluation are distributed via Parallel.ForEach loops, dynamically scaling to your hardware's available CPU cores. To drastically speed up total disk I/O execution, the worker sorts targeted files by byte size (OrderByDescending), assigning the heaviest files to processor cores immediately to prevent multithreading "tail-latency".Large File Memory Safety (OOM Prevention): Uncompressed text streams consume system RAM rapidly. If the worker attempts to read multiple 500MB+ files (e.g., baked Lightmap data assets or dense Terrain scenes) simultaneously, it can trigger an Out-Of-Memory (OOM) crash. The engine pre-evaluates byte sizes; any file exceeding a user-defined threshold (default 250MB) is intercepted and processed sequentially on a synchronous thread with explicit GC.Collect() forced between reads.Regex Sub-Asset Handling: Replacing specific sub-assets (like nested meshes or sliced sprites) requires rewriting multiple lines simultaneously. The engine uses compiled, group-based Regex to identify and evaluate both fileID and guid dependencies concurrently without destroying surrounding structural YAML formatting.Data Extraction Mechanics (Codebase Exporter)Safe Hierarchy Parsing: The Scene/Prefab extractor relies entirely on Unity's SerializedObject API. To prevent infinite recursion loops and Editor memory bloat, it is strictly limited to surface-level property reading, mathematically truncating deeply nested custom classes and massive arrays.Thread Protection Limits: To protect the main Editor thread from completely locking up during aggressive string parsing and comment-stripping operations, the Exporter enforces a strict 5MB hard limit per file during staging.Mathematical Token Estimation: Token counts displayed in the UI are mathematical proxies (Total Characters ÷ Ratio), not true 1:1 tokenizations, ensuring instant Editor UI responsiveness without needing to bundle heavy machine-learning libraries.Project Protections & ArchitectureVCS Lock Protection: Before executing a destructive write operation, the engine evaluates OS file attributes (FileAttributes.ReadOnly). Files locked by a Version Control System (Perforce, Git, PlasticSCM) are gracefully skipped and logged, preventing hardware write-exceptions from failing the entire batch.Non-Indexing Backups: When generating local script backups or YAML file clones, files are copied to a specialized Backups~ directory. The tilde (~) suffix is a low-level command instructing Unity's AssetDatabase to completely ignore the folder, preventing it from wasting time generating .meta files and preventing catastrophic duplicate GUID clashes.Headless Execution & API ReferenceDecoupled Architecture: The Editor windows are strictly UI wrappers. All underlying logic is housed within the Veridian.ContextSuite namespaces.Pipeline Automation: Pipeline engineers can bypass the GUI entirely. You can programmatically trigger a RAM snapshot, format a codebase payload, or execute an asynchronous background reverse-dependency scan (FindMultipleReferencesAsync) directly from your own automated custom pre-build scripts.Hard Limits (Critical Constraints)Force Text Serialization Requirement: The Batch Replacer modifies raw text. Your project MUST be set to Force Text serialization (Edit > Project Settings > Editor > Asset Serialization > Mode). If your project uses Binary or Mixed serialization, the tool will physically lock execution to prevent irreversible file corruption.Prefab Stage Cache Blocks: Modifying physical .prefab text files on disk while that specific Prefab is actively open in Edit Mode causes Unity to write its outdated memory cache to the disk upon exit, permanently reverting your changes. The tool actively detects the Prefab Stage and locks execution to protect your data.Immutable Unity Packages: Assets residing within standard Unity Packages (the Packages/ directory) are treated as read-only by the engine and will be safely skipped during modifications.
