Windows dependency analysis and packaging tool for desktop applications.

Highlights • Frontends • Build • Layout • Dependencies • Open Source • Diagrams

简体中文 • English

LibDeploy scans an EXE/DLL, classifies its runtime dependencies, collects related resource folders, and produces a deployable directory, ZIP package, or NSIS installer.

wxWidgets Frontend	Qt Frontend

• Dependency analysis — Parses PE import tables and builds a full dependency tree via BFS.
• DLL classification — Separates OS core DLLs, network DLLs, third-party DLLs, redistributables, and ApiSet DLLs.
• Resource packaging — Keeps folders such as assets/, images/, scripts/, docs/, plugins/, packages/, webview2_runtime/.
• Smart directory skip — Ignores exact-case build-output directories (bin/, release/, debug/, x64/, _deploy/, etc.) to avoid polluting the output.
• Deployment — Copies required files into a clean deployment directory.
• ZIP packaging — Creates ZIP archives with real-time per-file compression progress (0 → 100 %).
• NSIS installer — Generates NSIS installers with Start Menu and desktop shortcuts.
• Async operations — All long-running tasks (analyze, deploy, ZIP, installer) run in background threads with a live progress dialog.
• Recent files — File menu remembers the last 10 opened executables; click to re-open instantly.
• Session log & history — Every analysis session is auto-saved to logs/YYYY-MM-DD_HH-MM-SS_App.log; browse and export from the app.
• Compatibility checks — Warns about WebView2 Runtime versions incompatible with Windows 7 / 8.1.
• UI — Supports Chinese/English language switching from the in-app Language menu, plus light/dark/system themes.

LibDeploy ships with two desktop frontends that share the same core engine.

Shared core:

engine/     PE parsing, DLL classification, dependency resolution, deployment
config/     JSON configuration

Detailed build instructions are in docs/BUILD.md.

Required tools:

• CMake 3.20+
• MinGW-w64 GCC 13+

All wxWidgets build dependencies are bundled:

third_party/wxwidgets/   # wxWidgets UI library
third_party/zlib/        # Compression support
third_party/minizip/     # ZIP packaging
third_party/nlohmann/    # JSON parsing
runtime/                 # MinGW runtime DLLs
tools/nsis/              # NSIS installer generator (fully bundled)

✅ No vcpkg, network access, NSIS installation, or additional third-party libraries required.

cmake -B build -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Release
cmake --build build -j4

Output: build/bin/LibDeploy.exe

The Qt frontend reuses the same bundled core dependencies, but building the Qt UI requires a local Qt SDK.

Required Qt components:

• Qt Widgets
• Qt Concurrent
• Qt LinguistTools
• windeployqt

Validated local kit: Qt 5.12.12 msvc2017_64

cmake -S .\qt_frontend -B .\build_qt ^
  -DCMAKE_PREFIX_PATH=C:\Qt\Qt5.12.12\5.12.12\msvc2017_64
cmake --build .\build_qt --config Release -j4

Output: build_qt/bin/Release/LibDeployQt.exe

💡 After build, Qt DLLs, plugins, MSVC runtime DLLs, NSIS tools, config files, and translations are copied into the release folder. End users do not need to install Qt separately.

1. Open — click Browse or use File → Open Executable to select an .exe or .dll.
2. Analyze — click Analyze. A background thread resolves the full dependency tree; a progress dialog shows live status.
3. Review — inspect the dependency tree (found / missing / system / redist categories) and the detail panel on the right.
4. Deploy — click Deploy to copy all required files into a deployment directory of your choice.
5. Package — use Pack ZIP or Generate Installer to create a distributable archive or NSIS installer.

Tips:

• Add extra search paths under Search Paths if your DLLs are not next to the executable.
• System PATH search — Follow System PATH is enabled by default, which automatically searches Windows system directories and the PATH variable for DLLs (e.g., system libraries in System32). Toggle this via the follow_system_path field in libdeploy_config.json:

  {
    "follow_system_path": true,   // Enable system PATH search (recommended: true)
    ...
  }

• NSIS tool configuration — NSIS is fully bundled in tools/nsis/ and is automatically copied to the release folder during build. When generating an installer, the application automatically uses the bundled version first, with no system NSIS installation required. Different development environments require no configuration changes and work out-of-the-box. To use a system-installed NSIS or custom path, specify it in libdeploy_config.json:

  {
    "nsis": {
      "makensis_path": ""  // Empty string = use bundled version (recommended)
      // Or specify system path:
      // "makensis_path": "C:/Program Files (x86)/NSIS/makensis.exe"
    }
  }

• Resource folders are copied only when they look like real application assets; built-in skips such as bin/, build/, debug/, release/, x64/, and x86/ are matched case-sensitively.
• You can add custom resource-scan exclusions via classifier.extra_excluded_dirs (case-sensitive directory names), useful for excluding Conda/Python runtime folders.
• In both frontends, Excluded Directories supports bulk input using comma-separated names (both , and ，) and keeps case-sensitive entries distinct.
• Custom resource scan paths include matching resource subdirectories and top-level related resource files in the analysis result.
• After analysis, select a dependency, resource directory, or data file in the tree and use Remove Selected to exclude it from the current deploy/ZIP result.
• In both frontends, you can drag a DLL item from the dependency tree into Excluded Directories to add its base name quickly.
• Use File → Recent Files to quickly reopen previously analysed targets.
• Open File → History Logs to browse or export any past analysis session log.

LibDeploy/
├── app/                  # wxWidgets frontend
├── qt_frontend/          # Qt Widgets frontend
├── engine/               # Core dependency analysis and deployment logic
├── config/               # JSON configuration management
├── cmake/                # CMake helper scripts
├── docs/                 # Project documentation
├── locale/               # wxWidgets .po translation sources
├── assets/               # Application icons and source assets
├── third_party/          # Bundled source/prebuilt third-party dependencies
├── runtime/              # MinGW runtime DLLs for wxWidgets release
├── tools/                # Bundled deployment tools
├── CMakeLists.txt
├── libdeploy_config.json
└── .gitignore

Additional bundled tool:

The two frontends (wxWidgets and Qt Widgets) share the same core engine, configuration, and third-party libraries.

flowchart TD
    subgraph Frontends
        A[wxWidgets Frontend<br/>app/]
        B[Qt Widgets Frontend<br/>qt_frontend/]
    end

    subgraph Core
        C[Engine<br/>engine/]
        D[Config<br/>config/]
        E[Third Party<br/>third_party/]
    end

    subgraph Output
        F[Deployment Directory]
        G[ZIP Archive]
        H[NSIS Installer]
    end

    A --> C
    B --> C
    C --> D
    C --> E
    C --> F
    F --> G
    F --> H

flowchart LR
    Input[Target EXE/DLL] --> PE[PE Import Table Parser]
    PE --> Tree[Build Dependency Tree<br/>BFS]
    Tree --> Classify[DLL Classification]
    Classify --> OS[OS / Network DLLs]
    Classify --> ThirdParty[Third‑party DLLs]
    Classify --> Redist[Redistributables]
    Classify --> ApiSet[ApiSet DLLs]

    ThirdParty --> Copy[Copy to Deployment Dir]
    Redist --> Copy
    OS --> Ignore[Ignore]
    ApiSet --> Ignore

    Copy --> Resources[Collect Resource Folders<br/>assets, images, scripts, ...]
    Resources --> Package[Create ZIP / NSIS]

flowchart TD
    Start[DLL Found] --> IsKnownOS{In OS core / network list?}
    IsKnownOS -->|Yes| OS[Mark as OS DLL<br/>Do not deploy]
    IsKnownOS -->|No| IsThirdParty{In third‑party list?}
    IsThirdParty -->|Yes| ThirdParty[Mark as Third‑party<br/>Deploy]
    IsThirdParty -->|No| IsRedist{Is redistributable?}
    IsRedist -->|Yes| Redist[Mark as Redist<br/>Deploy if needed]
    IsRedist -->|No| IsApiSet{Is ApiSet DLL?}
    IsApiSet -->|Yes| ApiSet[Mark as ApiSet<br/>Do not deploy]
    IsApiSet -->|No| Unknown[Mark as Unknown<br/>Warn user]

flowchart LR
    UI[User Action] --> BG[Background Thread]
    BG -->|progress callback| PD[Progress Dialog]
    BG -->|finished| Main[Main Thread]
    Main --> Result[Update Tree / Log / Status]

flowchart LR
    subgraph WxBuild[wxWidgets Build]
        WC[CMake + MinGW] --> WB[Build engine + app] --> WOut[LibDeploy.exe<br/>+ bundled runtime]
    end

    subgraph QtBuild[Qt Build]
        QC[CMake + MSVC<br/>+ Qt SDK] --> QB[Build qt_frontend] --> QOut[LibDeployQt.exe]
        QOut --> Windeployqt[windeployqt] --> QRelease[Release folder<br/>with Qt DLLs & plugins]
    end