Local-first Python IDE and developer toolkit for Windows, Linux, and macOS. DevCenter combines a PySide6 code editor, AST static analyzer, PyInstaller build helper, icon converter, license collector, full-text SQLite file index, and optional Claude/Anthropic AI assistant in one cohesive desktop suite.

English · Deutsch · Español · 简体中文 · 日本語 · Русский

Not Azure DevCenter, Microsoft Dev Box, Moderne DevCenter or Devbox. This is dev-bricks/DevCenter — an open-source Python desktop suite.

• 1. Key Features & Highlights
• 2. System Architecture & PySide6 Design
• 3. Target Personas & Discoverability
• 4. Comparative Matrix vs. Alternatives
• 5. Dual Mermaid Diagrams & Data Flow
• 6. Governance & Runtime Invariants
• 7. Editor & Code Ergonomics
• 8. Static Analysis & AST Metrics
• 9. PyInstaller Build Pipeline & Packaging
• 10. Full-Text Search & File Indexing
• 11. Optional AI Assistant & Keyring Security
• 12. Redacted Workspace Export & Interop
• 13. Keyboard Shortcuts & User Controls
• 14. Repository Layout & Architecture
• 15. Quick Start & Batch Launchers
• 16. Testing & Quality Verification
• 17. Third-Party Licenses & Level 1 SBOM
• 18. Security Policy, § 521 BGB & Sibling Ecosystem

The PySide6 desktop application is the only shipped product and the authoritative runtime. devcenter-workspace-v1.json is a redacted local export for storage or explicit handoff; the repository contains no Web/PWA companion or hosted importer. See DOCUMENTATION_STATUS.md for documentation hierarchy.

DevCenter is architected around a modular, event-driven PySide6 desktop engine. Core components maintain strict layer separation between user interface presentation, static code analysis, local file management, and optional AI services:

• UI Presentation Layer (src/gui/): Houses MainWindow, tabbed editor panels, dockable tools, settings dialogs, and accessible keyboard shortcut controllers.
• Static AST Engine (src/modules/analyzer/): Parses Python abstract syntax trees inertly without executing user code. Computes cyclomatic complexity, discovers classes and methods, and checks for unused imports.
• Build & Packaging Engine (src/modules/builder/): Automates PyInstaller invocation, multi-resolution Windows ICO generation (Pillow), and automated third-party license extraction (pip-licenses).
• File Management & Search (src/modules/filemanager/): Employs an embedded SQLite database with Full-Text Search (FTS5) and cryptographic file hashing for zero-latency project navigation and duplicate cleanup.
• Security & Secret Vault (src/core/ai_service.py): Interacts with the native operating system keyring via keyring and pywin32-ctypes, ensuring API keys are never written to disk.

DevCenter addresses four distinct developer profiles with specialized workflows and guarantees:

• Profile: Python developers building Qt, PySide6, PyQt, or Tkinter desktop software for Windows.
• Pain Points: Complex PyInstaller command-line flags, manual multi-resolution ICO creation, scattered license files, and encoding corruption (mojibake).
• DevCenter Solution: One-click PyInstaller GUI wizard, built-in image-to-ICO converter, automated license notice collector, and automatic ftfy UTF-8 repair.
• High-Intent Queries: "pyside6 python code editor desktop", "pyinstaller exe packaging gui tool".

• Profile: Open-source maintainers and indie engineers building modular desktop and CLI utilities.
• Pain Points: Heavy IDE startup lag (Electron/JVM), opaque background daemons, and constant cloud account friction.
• DevCenter Solution: Instant native PySide6 desktop launch, lightning-fast SQLite FTS5 file indexing, and standalone project switching.
• High-Intent Queries: "local-first python ide windows", "lightweight python ide for windows 11".

• Profile: Developers operating in regulated, isolated, or corporate air-gapped environments.
• Pain Points: Mandatory cloud logins, background telemetry leaks, unvetted dependencies, and elevated privilege requirements.
• DevCenter Solution: Strict zero-egress default, non-elevated RunAsInvoker user space execution, vulnerability floors, and Level 1 SBOM transparency.
• High-Intent Queries: "offline python ide without cloud login", "zero-egress developer toolkit".

• Profile: Engineers collaborating with LLM coding assistants (Claude, GPT, Gemini) for rapid software prototyping.
• Pain Points: Accidental leakage of API keys, cumbersome copy-pasting of whole project trees, and noisy prompt contexts.
• DevCenter Solution: Redacted workspace exports (devcenter-workspace-v1.json), OS-native keyring credential vault, and machine-readable llms.txt.
• High-Intent Queries: "redacted workspace export python ide", "dev-bricks devcenter python development suite".

The following 10-dimension comparative matrix contrasts DevCenter against standard Python development environments, directly mapped to our Governance & Runtime Invariants (INV-LOCAL-01 to INV-SLA-10):

graph TB
    subgraph UI ["PySide6 Desktop Application (Main Window)"]
        TOP["Menu Bar & Toolbars<br/>• File • Edit • View • Analyze • Build • Tools • Help"]
        STATUS["Status Bar & Diagnostics"]
    end

    subgraph MODULES ["Core Engine Modules"]
        EDITOR["Editor Module<br/>• PythonSyntaxHighlighter<br/>• Indent Folding & Auto-Indent<br/>• Non-modal Search & Replace"]
        ANALYZER["Static Analyzer<br/>• AST Class & Method Parser<br/>• Cyclomatic Complexity<br/>• Unused Import Checker<br/>• EncodingFixer"]
        BUILDER["Builder Module<br/>• PyInstaller Pipeline<br/>• IconConverter (PNG/JPG to ICO)<br/>• License Collector"]
        FILEMGR["FileManager Module<br/>• SQLite FTS5 File Index<br/>• Hash Duplicate Finder<br/>• ProSync Backup Engine"]
        AI["AI Assistant (Opt-in)<br/>• Claude / Anthropic API<br/>• Windows Keyring Vault<br/>• Code Explainer & Reviewer"]
    end

    subgraph STORAGE ["Local Storage & Artifacts"]
        FS[("Local File System<br/>• Project Trees & Python Files")]
        DB[("Local SQLite Database<br/>• %APPDATA%/DevCenter/index.db")]
        KEYRING[("Windows Credential Manager<br/>• System Keyring Secret Store")]
        DIST[("Build Artifacts<br/>• dist/DevCenter.exe<br/>• devcenter-workspace-v1.json")]
    end

    UI --> MODULES
    EDITOR --> FS
    ANALYZER --> FS
    BUILDER --> FS
    BUILDER --> DIST
    FILEMGR --> FS
    FILEMGR --> DB
    AI --> KEYRING
    STATUS --> MODULES

sequenceDiagram
    autonumber
    actor Dev as Developer / User
    participant App as DevCenter UI (PySide6)
    participant Core as AST & Analysis Engine
    participant Sec as Keyring Security Guard
    participant Disk as Local File System / SQLite
    participant Dist as Build & Export Pipeline
    participant Ext as Anthropic API (Opt-in)

    Dev->>App: Open Python Project / Code File
    App->>Disk: Read local files into memory
    Disk-->>App: Source buffer (UTF-8)

    Dev->>App: Trigger Static Analysis & AST Metrics
    App->>Core: Analyze classes, methods, imports, complexity
    Core-->>App: In-memory diagnostics (0 network calls)

    opt One-Click Build & Package
        Dev->>App: Compile Project to EXE
        App->>Dist: Invoke local PyInstaller with validated local paths
        Dist->>Disk: Generate dist/Executable & license notices
    end

    opt Redacted Workspace Export
        Dev->>App: Export Workspace Snapshot
        App->>Dist: Sanitize paths, strip tokens & format devcenter-workspace-v1.json
        Dist->>Disk: Save redacted JSON (0 network egress)
    end

    opt Optional AI Assistance (Claude)
        Dev->>App: Submit Prompt / Request Code Review
        App->>Sec: Request API Key from Windows Keyring
        Sec-->>App: In-memory decrypted key (never written to JSON)
        App->>Ext: Secure HTTPS API Call (User explicit opt-in only)
        Ext-->>App: Code suggestion / Refactoring response
    end

    App-->>Dev: Display results, metrics & executable ready

DevCenter strictly enforces 10 architectural, security, and supply chain invariants across its entire lifecycle:

The DevCenter editor provides a responsive, native coding experience built on PySide6:

• Syntax Highlighting & Visual Styling: Python syntax highlighter with custom color schemes for keywords, docstrings, decorators, and built-in functions.
• Code Folding: Indent-level folding for functions, classes, and nested blocks (Ctrl+Alt+[ / Ctrl+Alt+] / Ctrl+Alt+0).
• Non-Modal Search & Replace: In-editor search bar supporting case matching, whole words, and regular expressions without blocking the editor view (Ctrl+F).
• Encoding Diagnostics & Repair: Real-time detection of UTF-8 BOM, ISO-8859-1, and mojibake with automatic one-click normalization via ftfy.

DevCenter inspects code inertly using Python's standard library ast module:

• Class & Method Detection: Discovers all class structures, inheritance graphs, functions, and method signatures without importing the module.
• Cyclomatic Complexity: Evaluates decision points (if, for, while, try, boolean operators) to assign complexity ratings per function.
• Unused Import & Variable Detection: Tracks symbol references and aliased imports, flagging redundant dependencies.
• TODO/FIXME Aggregator: Collects and categorizes actionable developer annotations across the entire project tree.

Turn any Python script into a standalone Windows executable with zero manual CLI scripting:

• One-File vs. One-Directory Packaging: Toggle between monolithic single-file executables and directory distributions.
• Automated Windows ICO Generation: Built-in converter transforms PNG or JPG images into multi-resolution Windows icons (16x16, 32x32, 48x48, 64x64, 128x128, 256x256) using high-quality Lanczos resampling.
• Third-Party License Bundling: Uses pip-licenses to aggregate licenses of all installed dependencies into a compliance notice file automatically included in the build distribution.

Embedded SQLite indexing ensures instant retrieval and storage hygiene:

• Full-Text Search (FTS5): Fast content searching across all source files, documentation, and notes in your project folder.
• Duplicate File Detection: Cryptographic hash matching identifies redundant files, temp snapshots, and abandoned copies.
• ProSync Backup Engine: Lightweight, SQLite-aware backup synchronization keeping local development snapshots safe.

DevCenter provides an optional Claude/Anthropic AI companion designed with strict zero-leakage principles:

• OS Keyring Secret Isolation: API keys are securely stored in the native Windows Credential Manager via keyring and pywin32-ctypes. Keys are never written to settings JSON files, logs, or workspace exports.
• Explicit Action Boundary: The AI assistant never scans or transmits code in the background. Network requests occur solely when the developer explicitly triggers a prompt or code review action.
• Prompt Engineering Context: Quick tools for code explanation, refactoring suggestions, docstring generation, and bug diagnosis.

Export project state safely for cross-agent collaboration and team handoffs:

• Redacted Schema (devcenter-workspace-v1.json): Generates a standardized JSON metadata snapshot detailing project structure, detected frameworks, open tasks, and dependencies.
• Automatic Privacy Scrubbing: Strips all absolute personal file paths, API tokens, passwords, and sensitive environment keys.
• Interop Standard: Facilitates handoffs to agent tools (Codex, Claude Desktop, Antigravity) without whole-repository egress. See EXPORTFORMAT.md.

DevCenter/
├── assets/                     # Visual assets (banner, logos, graphics)
├── locales/                    # Tier-2 translations (DE, EN, ES, ZH, JA, RU)
├── resources/                  # Windows Store packager and templates
├── src/                        # Authoritative application source tree
│   ├── core/                   # ProjectManager, SettingsManager, EventBus, CLI, Logging
│   ├── gui/                    # MainWindow, Editor, DockPanels, Dialogs
│   └── modules/                # Analyzer, Builder, FileManager, EncodingFixer
├── tests/                      # Automated unit, accessibility, and metadata contract tests
├── .gitignore                  # Multi-host lock and cloud-sync defense rules
├── CHANGELOG.md                # Release history and unreleased change ledger
├── DOCUMENTATION_STATUS.md     # Documentation hierarchy and boundary specifications
├── EXPORTFORMAT.md             # Specification of devcenter-workspace-v1.json
├── LICENSE                     # GNU General Public License v3.0 (GPLv3)
├── llms.txt                    # Machine-readable LLM context specification
├── main.py                     # Primary desktop entry point & CLI dispatcher
├── MARKETING-LOG.txt           # Local marketing intelligence and persona ledger
├── NOTICE                      # Canonical open-source attribution notice
├── pyproject.toml              # PEP 621 package metadata, 20 keywords, pytest config
├── README.md                   # English project documentation & architecture guide
├── README_de.md                # German project documentation & architecture guide
├── requirements.txt            # Pinned runtime dependencies
├── SECURITY.md                 # Bilingual security policy & 48h response SLA
├── THIRD_PARTY_LICENSES.md     # Level 1 SBOM and Invariant Cross-Reference Matrix
└── translator.py               # Tier-2 multi-language translation engine

git clone https://github.com/dev-bricks/DevCenter.git
cd DevCenter
pip install -r requirements.txt
python main.py

# Quick GUI Launcher
START_DevCenter.bat

# Diagnostic & Debug Launcher (with console output and UTF-8 code page)
debug.bat

# Automated PyInstaller Compilation Script
build_exe.bat

# Verify system dependencies, PySide6, AST analyzer, and storage paths
python main.py --check

# Run headless AST analysis on a file or folder with JSON output
python main.py --analyze src/modules/analyzer/method_analyzer.py --output report.json

# Generate a sanitized workspace export headless
python main.py --export-workspace

DevCenter maintains a rigorous test suite covering core logic, accessibility, encoding repair, and metadata parity:

# Run complete test suite with standardized options
python -m pytest

# Run Ruff linter and static verification
ruff check .

# Validate bytecode compilation
python -m compileall -q .

CI verification (2026-10-04): python -m pytest -q passed 250 tests (100% green) on Python 3.11 and 3.12. Continuous Integration validates the test matrix across Python 3.11 and 3.12 on Windows, Linux, and macOS.

DevCenter maintains a comprehensive Level 1 Software Bill of Materials (SBOM) and license transparency audit:

• Detailed breakdown of all 20 direct, transitive, build, and test packages: THIRD_PARTY_LICENSES.md.
• Canonical attribution notice: NOTICE.
• Machine-readable license mapping: THIRD_PARTY_LICENSES.txt.
• All packages are audited under permissive open-source licenses (MIT, Apache-2.0, BSD-3-Clause, BSD-2-Clause, HPND-sell-variant) or standard copyleft with linking/bootloader exceptions (LGPL-3.0, LGPL-2.1, GPL-2.0 with Bootloader exception).

DevCenter operates strictly local-first and unprivileged (RunAsInvoker). Network access occurs solely upon explicit user initiation.

• Vulnerability Disclosure: 48-hour response acknowledgement and 5-business-day triage commitment.
• Reporting Contacts: [email protected], [email protected], [email protected].
• Statutory Liability Disclaimer (§ 521 BGB): DevCenter is provided free of charge as open-source software under the GNU General Public License v3.0. In accordance with statutory German gratuitous contract law (§ 521 BGB / Gefälligkeitsrecht), liability of the author is limited to intent and gross negligence. Use at your own risk.

DevCenter is the flagship Python IDE and packaging center within the dev-bricks ecosystem under the open-bricks umbrella: