DevProjex is a cross-platform desktop application designed to help developers visualize project folders and selectively export their structure or file content in ASCII or JSON format. It serves as a tool for preparing clean, focused context for AI interactions, code reviews, documentation, and more.
Key Features:
TreeView with Checkbox Selection: Easily select specific files or folders to include in your output.
Multiple Export Modes: Supports tree-based structure, file content, or a combination of both in ASCII or JSON format.
Preview Functionality: View the output before exporting to ensure it meets your needs.
Smart Ignore Rules: Automatically excludes common ignored files and directories based on VCS configurations.
Git Integration: Clone repositories by URL and manage branches directly within the application.
Responsive UI: Handles large projects smoothly with asynchronous scanning and live metrics.
Audience & Benefit:
Ideal for developers, DevProjex streamlines the process of sharing project contexts. It is particularly useful for preparing structured input for AI tools like ChatGPT or Copilot, simplifying code reviews, or documenting project architecture without unnecessary noise from raw CLI outputs. By focusing on clarity and control, DevProjex helps users save time while maintaining precision.
DevProjex can be installed via winget: winget install OlimoffDev.DevProjex.
README
DevProjex 📁🌳
🏆 Officially Selected by the Avalonia UI Team for the App Showcase
The fastest way to turn a real codebase into clean, AI-ready context.
DevProjex is a cross-platform app for turning folders and codebases into clean, controlled context for AI chats, reviews, and documentation — with GUI, TUI, and CLI workflows.
Select only what matters, preview the result, copy or export it as tree, content, or both in ASCII, MD, JSON, or XML, or create a separate project copy as a folder or ZIP archive.
It’s built for real projects where terminal output is noisy, IDE integrations are limited, and you still need fast, controlled context for an AI chat or a human reviewer.
DevProjex is not an autonomous coding agent. It gives you a manual, fully controlled way to prepare project context when agents, IDE plugins, or remote indexing cannot be used.
> 🔒 Source-project read-only & without telemetry by design — opening, analyzing, or exporting from a project never modifies that source tree. Explicit file, folder, ZIP, and portable-profile destinations are accepted only outside it; application-owned settings, local profiles, clones, caches, and runtime state are stored outside the source tree.
Preview mode (tree / content / combined) before copy/export
ASCII, MD, JSON, and XML tree formats for AI prompts, documentation, and parsers
Per-project local parameter profiles (saved per local project path)
Export to file from menu (tree / content / tree + content)
Export project copies to a separate folder or ZIP archive, preserving the effective tree, binary files, and included empty folders
Search & name filtering for large projects
Two Git-aware filtering modes: hierarchical .gitignore evaluation or an index-backed tracked-files-only view across nested repositories and worktrees
Scope-aware Smart Ignore for mixed workspaces and monorepos
Extensionless files handling via dedicated ignore option
Git integration (clone by URL, switch branches, get updates in cached copies)
Status bar with live metrics (tree/content lines, chars, ~tokens)
Progress bar + operation cancellation with safe fallback behavior
Modern appearance system
System / Light / Dark
Transparency / blur / Mica where supported
Presets stored locally
Island-based layout and smooth UI animations
Animated toasts for user feedback
Localization (11 languages)
Responsive async scanning (UI stays smooth on big folders)
Unified terminal workflows: use the keyboard-first TUI for interactive project inspection, or the deterministic CLI for AI-ready context, JSON reports, CI-friendly diagnostics, tree/content exports, and project copies — all from the same application executable
How Smart Ignore Works 🧠
Smart Ignore is DevProjex’s deterministic, local, scope-aware filtering algorithm. It is not an AI model and it does not treat an opened folder as one global blacklist. Instead, DevProjex combines project ownership and filesystem evidence in its own Scope + Evidence pipeline.
1. Detect the project scope
DevProjex recognizes project boundaries from markers such as .csproj, package.json, pyproject.toml, pom.xml, go.mod, Cargo.toml, composer.json, and Gemfile.
Stack-specific rules are applied only inside the scope that owns those markers:
.NET: bin, obj
JavaScript/frontend: node_modules, framework caches, build and coverage output
Python: virtual environments, bytecode and tool caches
JVM: Gradle/Maven caches and build output
Go, Rust, PHP, and Ruby: their corresponding dependency and generated-output folders
2. Require evidence for ambiguous folders
A directory name alone is not always enough. Names such as build, dist, vendor, packages, cache, pkg, or Library can contain either generated output or real source code.
Smart Ignore first performs a cheap candidate-name check, then looks for strong local signatures such as package metadata, compiler output, cache tags, generated manifests, or known artifact layouts. If the evidence is missing, the folder stays visible. This conservative two-stage check reduces false positives without turning every project load into an expensive deep content scan.
The signature layer also recognizes common generated layouts from CMake, Dart/Flutter, Swift, Unity, Unreal Engine, Terraform, Serverless, Zig, and package-manager caches.
3. Keep mixed monorepos isolated
Each nested project keeps its own rules. A .NET service does not make bin disappear from an unrelated sibling, and a frontend app does not apply node_modules rules to an ordinary folder elsewhere in the workspace.
repo/
├── apps/web/package.json -> frontend artifacts are filtered in this scope
├── services/api/api.csproj -> .NET artifacts are filtered in this scope
├── tools/data/pyproject.toml -> Python artifacts are filtered in this scope
└── docs/build/ -> remains visible without artifact evidence
Deep projects are not limited to the repository root. When an artifact candidate is encountered during tree traversal, DevProjex validates it against the applicable ancestor project markers. This keeps deeply nested and mixed-language workspaces predictable.
4. Choose the Git view you need
.gitignore answers “which paths should Git ignore?” It does not mean “show only files owned by the repository.” DevProjex supports both workflows as two mutually exclusive modes:
Mode
Result
Use .gitignore
Keeps tracked files and untracked files that are not excluded by reachable .gitignore rules. Each path uses the index of its owning repository/worktree scope; a scope without a readable index safely falls back to pattern-only evaluation.
Tracked Git files only
Uses the installed Git CLI to start from existing working-tree files recorded in each readable Git index. Modified tracked files and staged additions remain included; untracked files are excluded.
In .gitignore mode, every reachable .gitignore is evaluated in its own directory scope, including the ancestor rule chain when a repository subfolder is opened, nested rules, and negations. Pattern case matching follows the effective repository core.ignoreCase value; macOS Unicode comparison also follows Git's core.precomposeUnicode behavior. This keeps the tree, extension list, preview, and exports on the same path semantics as Git.
Only regular working-tree .gitignore files are rule sources. DevProjex does not apply .git/info/exclude, global Git excludes, or a .gitignore symbolic link; this matches Git's own control-file behavior and prevents a link target outside the project from changing the result. If a regular .gitignore cannot be read, its directory scope is excluded fail-closed and the scan reports partial access instead of silently including files without applying all ignore rules.
If no .gitignore exists, the selected mode remains active with an empty pattern set: only the exact Git administration entry .git is protected, while names such as .github remain normal project content.
DevProjex resolves every reachable nested repository and worktree independently, at any reachable nesting level. A child repository never inherits tracked state from its parent or sibling. Tracked-files mode is fail-closed and never silently falls back to .gitignore: direct commands, including devprojex open, return a policy failure before output or Desktop handoff if the Git CLI cannot load any applicable index; an already-open Desktop workspace keeps the explicit selection visible so it can be turned off; TUI startup does not open an unavailable tracked workspace, while an unsuccessful interactive TUI mode change keeps the last usable Git mode. A readable empty index is valid; unreadable nested indexes are excluded with a warning when another applicable index was loaded.
This is a view of the current working tree, not a historical snapshot of HEAD or a promise that the files match a remote Git host. The current bytes of modified tracked files are used.
5. Compose filters predictably
The selected Git mode runs first. Smart Ignore processes the remaining items, followed by the explicit dot-file, hidden-item, empty-item, and extensionless-file rules. Root-folder, file-type, and checkbox selections can narrow the same effective tree further.
The built-in standard profile selects gitignore mode and all eight exclusion groups: smart-ignore, hidden-folders, hidden-files, dot-folders, dot-files, empty-folders, empty-files, and extensionless-files. Explicit CLI options replace the corresponding profile field for that invocation.
Inside a Git repository, the two Git modes remain visible as a stable toggle pair. Smart Ignore and the evidence-based basic options appear only when they can affect the current tree. Smart Ignore may therefore stay hidden while the selected Git mode already excludes all matching artifacts, then appear after that mode is changed.
Control stays with you
Switch between hierarchical .gitignore evaluation and the tracked-files-only Git view.
Combine the selected Git mode with Smart Ignore and the basic ignore switches.
Put project-specific patterns in .gitignore; the curated Smart Ignore rules are intentionally not an arbitrary user-editable pattern list.
Control dot-prefixed and hidden items through their separate switches instead of having Smart Ignore hide them implicitly.
Narrow the result by top-level folders and file types.
Narrow the final export through tree checkboxes and verify it in preview.
Applied choices are remembered in local project profiles.
Ignored means excluded from the current tree, copy, and export result — never deleted from the source project. The implementation is open source: see the stack rules and the evidence-based signature matcher.
Typical use cases 🎯
Prepare clean input for AI assistants (ChatGPT, Claude, DeepSeek, Qwen, etc.)
Work in policy-restricted environments where AI agents, remote indexing, or IDE plugins are not allowed
Share project structure in code reviews or chats
Extract only relevant modules from large codebases
Teach or explain project architecture
Inspect large folders without noisy CLI scripts
DevProjex works with any language, repository, or project structure.
Project Copy Export 📦
Use File → Export Project → To Folder… or To ZIP Archive… to create a separate copy of the current effective tree.
Project copies respect the selected root folders, file types, ignore rules, and checked items. If nothing is checked, the entire current tree is exported. Directory structure, binary files, and included empty folders are preserved.
The source project is not modified, and the result cannot be written inside it. The same workflow is available through devprojex export project.
Command Line ⚙️
DevProjex is not only a desktop context builder. The same app can run from the terminal for repeatable, script-friendly project analysis and AI-context export.
