# WinDevPilot 2.5.81


WinDevPilot is a native C++ application for Windows 11 x64. It brings installed
applications, available updates and package details into a searchable list or
icon gallery. Scans inspect installed software; updates run only when requested.
Optional gallery fades finish each started morph on its original 250 ms clock,
keeping the chosen icon and name together during rapid resizing. The next morph
uses the latest layout target rather than blending unfinished transitions.
During gallery resizing, animation timers avoid repainting a frame that was
just drawn by the resize itself; ordinary scrolling keeps its GPU path.

## Run

Extract the complete portable ZIP into a folder and open
`WinDevPilot.exe`. The minimal release contains four files directly in the ZIP:
`WinDevPilot.exe`, `README.md`, `LICENSE` and `LEGAL.txt`. Start as a standard user; operations that require administrator
permission request it when necessary. The build is unsigned.

Browse All packages or Updates, select the desired update checkboxes, and choose
Update selected. Use the view button or Ctrl plus the mouse wheel to switch
between list, small icons and large icons. Details windows support left/right
arrow navigation through the current view.
Settings includes optional Nineties Morphing: known icon replacements use a small
image-derived deformation grid and the existing 250 ms eased transition. Empty
backgrounds still fade normally. Original artwork is restored at full resolution
on completion, with its target name held throughout. The option is off by default;
it and ordinary Fade Icon Changes are alternative styles. Morph landmarks favor
foreground silhouette and color, with interior texture contribution capped;
coordinate scratch is reused without extra transition bitmaps. Subpixel icon rendering
is retired from Settings and compiled out of the application; its source and
standalone experiments are retained for possible future work.

In the update log, **Skip remaining** lets the current installer finish safely
and prevents further updates from starting. The dialog shows **Finishing update...**
while it waits. If the batch stops before the installed-version check starts,
that check is reported as **verification skipped after cancel**, separately from
a failed or incomplete check. Scan again to verify the installed version.

An explicitly selected WinGet update that reports administrator permission is
required can request UAC once after fresh scope, version and pin checks. The
upgrade keeps the same Windows account, exact version and installed scope.
Cancelling permission does not retry it. A user/machine installer conflict is
reported for manual review; the app does not migrate or reinstall it automatically.
After a successful WinGet update, a bounded read checks the exact installed
version in the original scope. An inconclusive check is shown as unverified and
does not cause an automatic reinstall. Explicit architecture labels such as
"(x86)" or "(x64)" constrain the upgrade and verification, including elevated
retries. Registrations of a positively identified different architecture are
checked separately; unknown or duplicate target registrations remain unverified.
A completed-but-unverified package holds further entries for that package while
unrelated selected updates continue. A timeout, incomplete installer capture or
possibly running installer still stops the batch. Elevated retries use the registered
Microsoft WinGet executable rather than a command found through user PATH.

Main-window and Details actions share the same validated launch, folder and
terminal path. Terminals receive the installation directory separately from
shell commands. Launch uses a known executable or a unique application candidate;
ambiguous folders can be opened for a manual choice.

Provider commands use the Windows system directory by default so launch-folder
modules and project configuration do not change their behavior. Explicit internal
working directories must be absolute and accessible. pip discovery and updates
share the available launcher/interpreter selection.

Package managers are separate programs; WinGet is recommended. Optional
providers are available when their tools are installed.
vcpkg checks cover global/classic packages. When both queries confirm a
project-managed installation with no global package list, scanning finishes
normally and the system report includes an informational note. Project manifests
stay with their projects. Previously cached vcpkg entries remain unverified
inventory without update offers; genuine query failures still report incomplete
discovery.
MSYS2 stays in All packages with a "Managed by MSYS2/pacman" status and update
instructions in Details and system reports. Its installer date is not treated
as an available package update. WinDevPilot does not reinstall it or run pacman.
Store PowerShell can refuse the private process job used to contain discovery.
WinDevPilot keeps containment mandatory and explains the refusal. Installing
desktop PowerShell 7 alongside the Store edition provides a compatible host;
the app does not install it automatically or substitute Windows PowerShell 5.

Each package view remembers its list, small-icon or large-icon mode. Column
sorts preserve previous ordering within equal groups. Cached artwork and
inventory speed up later starts. Settings > Verbose update output (debug) is off
by default; enable it only when extra provider console diagnostics are wanted.
An npm install that leaves dependency setup scripts unapproved is shown with a
setup-review warning, even when npm returns success. Review the listed packages
and npm policy manually; WinDevPilot does not enable scripts automatically.
The choice persists for the current account. Required WinGet file diagnostics
remain available for guarded update verification. Settings belong to the current Windows
account. Writable portable folders retain their adjacent `cache` and `logs`
directories. Read-only folders and installations under Program Files or Windows
use the current account's Local AppData folder, under
`WinDevPilot/NativeCpp/<installation-id>/cache` and `logs`. The installation ID
keeps separate app copies apart. Existing portable data is preserved; nothing is
automatically migrated or deleted. Reports may include installation paths
and should be reviewed before sharing.

Updates found so far appear once three quarters of providers finish or 20 seconds
elapse, whichever comes first. Further verified finds appear as providers finish.
Cancel scan, beside the progress bar, stops discovery while retaining verified
finds, completed registry/portable discoveries, and prior inventory where verification was incomplete. It also cancels icon
preparation. Active package installations are unaffected. Updates become usable
when discovery ends or is cancelled.

Valid scan results are retained even when icon retrieval is slow. Catalog artwork
prefetch respects a bounded queue; after a 30-second preparation limit, fresh
metadata becomes usable while remaining artwork continues in the background.
Incomplete providers and unverified update offers keep their existing holds.

Toolchain Health caches ordinary reopens for five minutes. Re-scan explicitly
refreshes probe results and executable snapshots without replacing the launching
process's PATH, and runs at most three tool probes concurrently. Closing an
unfinished check preserves the last complete cached report.

The scanning progress bar normally occupies the centered half of the footer;
long status messages can shift it right, leaving room for Cancel scan. GUI scans cancel slow provider queries
after 90 seconds, retain unverified inventory and report incomplete discovery.
This prevents a stalled package manager from leaving the scan open indefinitely;
it does not repair a blocked Windows deployment or certify stale update offers.
Read-only WinGet commands, including CLI scans, have a 30-second budget that
includes waiting for another query, and a 90-second budget per provider context.
After one times out, that context skips further WinGet reads and reports
incomplete discovery. A fresh scan can retry; active installers are unaffected.

## Command line

```text
WinDevPilot.exe --help
WinDevPilot.exe --report report.txt
WinDevPilot.exe --report --icons --output icon-report.txt
WinDevPilot.exe --cached-only
```

Reports use configured providers and return a nonzero status for failure or
incomplete discovery. `--cached-only` skips the startup scan and displays the
existing session cache. It does not create current update information.

## Build the source package

Use Visual Studio with the x64 C++ workload and Windows SDK, CMake 3.28 or newer,
and Ninja. Build Tools, Community, Professional and Enterprise installations
are discovered with `vswhere`; no installation drive or edition is hardcoded.
From PowerShell in the source folder (PowerShell 7 recommended):

```powershell
./build.ps1
./build.ps1 -Dist
```

The normal command builds and stages `dist/WinDevPilot.exe` and its supplied
renderer DLL. `-Dist` builds the optional standalone target and stages its four
files in `dist/standalone`; it needs x64 LLVM/Clang on PATH. `-Clean` cleans the
build first and `-Run` opens the selected build. The script respects Windows
script-execution policy and uses two build workers. `build_release.bat` calls the
same standalone workflow. No command uploads or publishes the result.

Alternatively, open an x64 Developer PowerShell and use CMake directly:

```text
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build --target WinDevPilot --parallel 2
```

The optional release target additionally needs x64 LLVM/Clang on PATH:

```text
cmake --build build --target WinDevPilot_Minimal --parallel 2
```

Its output is `build/release-2.5.81-minimal/WinDevPilot.exe`. The optional release
target links the full renderer and runtime statically, enables whole-program
optimization and discards unused code/data. It builds separately from the normal
application target. Its versioned target and output follow the application header;
`WinDevPilot_2_5_81_Minimal` also remains available for this release. The normal
target retains its supplied renderer DLL layout.

The source archive includes application sources, generated artwork and lookup
headers, required artwork catalogs, renderer sources and its matching import
library/DLL. The minimal target builds its own static renderer archive from the
same sources with strict floating-point settings.

Focused native checks can be built separately:

```text
cmake --build build --target smooth_list_message_regression row_landing_regression gallery_columns_regression --parallel 2
build/smooth_list_message_regression.exe
build/row_landing_regression.exe
build/gallery_columns_regression.exe
```

After building the default targets, run `ctest --test-dir build --output-on-failure
--parallel 2` for the local deterministic core checks. They do not install packages,
send desktop input or require network access. The larger fixture and visual
comparison scripts in `tests/` provide additional qualification. The retained,
disabled subpixel experiment has an explicit `icon_subpixel_regression` target.

## Notices and verification

The separable application code uses the MIT license in `LICENSE`. The executable
embeds GPL-3.0-or-later font outlines, so combined redistribution must satisfy
those terms and include access to the matching corresponding source. See
`LEGAL.txt` for this distinction and the included GPL text. Third-party components,
font outlines and vendor artwork retain their own terms and attribution; see
`LEGAL.txt`, which contains the necessary component notices and license texts. Vendor marks and adapted fallback artwork identify installed products. Their
copyrights and trademarks remain with their owners; no affiliation or endorsement
is implied. See LEGAL.txt for the identification-use notice and component terms.

Compare the ZIP's SHA-256 against the download page before opening it. A matching
checksum verifies file integrity, not signing or a security certification.
This standalone build passed command, settings-persistence and native update
verification fixtures. A separate clean-PC or real elevated-update session is
not part of these checks.
