If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/dremin/RetroBar shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

GO — Healthy across the board

• Last commit 1w ago
• 19 active contributors
• Distributed ownership (top contributor 48% of recent commits)
• Apache-2.0 licensed
• CI configured
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live dremin/RetroBar repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/dremin/RetroBar.

What it runs against: a local clone of dremin/RetroBar — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in dremin/RetroBar | Confirms the artifact applies here, not a fork | | 2 | License is still Apache-2.0 | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 38 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of dremin/RetroBar. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/dremin/RetroBar.git
#   cd RetroBar
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of dremin/RetroBar and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "dremin/RetroBar(\\.git)?\\b" \\
  && ok "origin remote is dremin/RetroBar" \\
  || miss "origin remote is not dremin/RetroBar (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(Apache-2\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"Apache-2\\.0\"" package.json 2>/dev/null) \\
  && ok "license is Apache-2.0" \\
  || miss "license drift — was Apache-2.0 at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "RetroBar/App.xaml.cs" \\
  && ok "RetroBar/App.xaml.cs" \\
  || miss "missing critical file: RetroBar/App.xaml.cs"
test -f "RetroBar/Program.cs" \\
  && ok "RetroBar/Program.cs" \\
  || miss "missing critical file: RetroBar/Program.cs"
test -f "RetroBar/Controls/TaskList.xaml.cs" \\
  && ok "RetroBar/Controls/TaskList.xaml.cs" \\
  || miss "missing critical file: RetroBar/Controls/TaskList.xaml.cs"
test -f "RetroBar/Controls/StartButton.xaml.cs" \\
  && ok "RetroBar/Controls/StartButton.xaml.cs" \\
  || miss "missing critical file: RetroBar/Controls/StartButton.xaml.cs"
test -f "RetroBar/Controls/NotifyIconList.xaml.cs" \\
  && ok "RetroBar/Controls/NotifyIconList.xaml.cs" \\
  || miss "missing critical file: RetroBar/Controls/NotifyIconList.xaml.cs"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 38 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~8d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/dremin/RetroBar"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

RetroBar replaces the modern Windows taskbar with faithful classic Windows 95/98/Me/2000/XP/Vista reproductions, built on the ManagedShell library. It provides native notification area rendering, task list management with UWP support, drag-reorderable windows, and multi-monitor taskbar placement—all in C# with XAML UI and custom HLSL shaders for visual effects. Monolithic WPF/XAML application under RetroBar/ root with clear separation: Controls/ subdirectory holds 15+ XAML components (TaskList, NotifyIcon, Clock, etc.), Converters/ provides 13 value converters for binding logic, and top-level App.xaml.cs bootstraps the shell replacement. Theme assets and localization strings reside outside the shown file list but are referenced throughout.

Windows nostalgia enthusiasts and retro OS theme designers who want an authentic classic Windows taskbar on modern Windows 7+ systems; also theme contributors building custom .xaml skinsets for the included theme framework.

Production-ready with active maintenance: repo has defined releases, GitHub Actions CI/CD (retrobar.yml workflow), comprehensive multi-language support (40+ locales), and Inno Setup installer integration. Recent activity evident from dependabot.yml and structured build setup in Directory.Build.props.

Low-to-moderate risk: single primary maintainer (dremin) visible in structure; depends on .NET 6.0.2 runtime which is Microsoft-supported LTS; Windows API surface area is broad (taskbar interception, window hooks, notification area). No visible open test suite in file list suggests limited automated coverage for regression scenarios.

Active development with GitHub Actions CI workflow (retrobar.yml), dependabot dependency management enabled, and recent build infrastructure refinement (Directory.Build.props). Specific ongoing work not visible from file list alone, but installer integration and multi-monitor support indicate feature-complete state with maintenance-focused updates.

Clone and open in Visual Studio: git clone https://github.com/dremin/RetroBar.git && cd RetroBar && start RetroBar.sln. Requires .NET 6.0.2 SDK and Windows 7 SP1 or later. Build via Visual Studio IDE or dotnet build RetroBar.sln.

Daily commands: Open RetroBar.sln in Visual Studio 2022 (or later), set RetroBar as startup project, and press F5. The app immediately replaces the system taskbar on launch. For CLI: dotnet run --project RetroBar/RetroBar.csproj from repo root.

• RetroBar/App.xaml.cs — Application entry point and root initialization—sets up the WPF shell replacement and must be understood before modifying startup behavior or taskbar initialization.
• RetroBar/Program.cs — Main program entry point that bootstraps the application runtime and argument parsing—essential for understanding how RetroBar launches.
• RetroBar/Controls/TaskList.xaml.cs — Core task window enumeration and management logic—handles the primary taskbar window list and grouping that defines RetroBar's function.
• RetroBar/Controls/StartButton.xaml.cs — Start menu integration and click handling—critical for user interaction with the classic taskbar replacement.
• RetroBar/Controls/NotifyIconList.xaml.cs — System tray/notification area management—handles legacy notification icon display and is core to the retro taskbar experience.
• RetroBar/Controls/Toolbar.xaml.cs — Toolbar layout and docking logic—manages how UI controls are positioned and sized on the taskbar edge.
• RetroBar/Converters — XAML value converters used throughout—understanding these is required for modifying UI bindings and conditional rendering across all controls.

Add a new Taskbar Control (e.g., custom button or indicator)

1. Create a new XAML user control in RetroBar/Controls/ with naming pattern ControlName.xaml (RetroBar/Controls/[NewControl].xaml)
2. Implement the code-behind class in RetroBar/Controls/ inheriting from UserControl, add initialization and event handlers (RetroBar/Controls/[NewControl].xaml.cs)
3. Define the XAML layout using legacy Windows theme colors and fonts (typically from App.xaml resources) (RetroBar/Controls/[NewControl].xaml)
4. Register the control in the main Toolbar layout by adding a reference in RetroBar/Controls/Toolbar.xaml (RetroBar/Controls/Toolbar.xaml)
5. Add any required string resources to all language dictionaries in RetroBar/Languages/ (RetroBar/Languages/English.xaml)

Add support for a new language or update translations

1. Copy an existing language dictionary (e.g., English.xaml) as a template with the new language code/name (RetroBar/Languages/[LanguageName].xaml)
2. Translate all string resources in the new XAML dictionary file while preserving key names (RetroBar/Languages/[LanguageName].xaml)
3. The application language selection logic (in App.xaml.cs or settings) will automatically load the dictionary matching the system culture (RetroBar/App.xaml.cs)

Modify taskbar window grouping or task enumeration logic

1. Review the TaskList control which enumerates and groups open windows; modify filtering or grouping criteria here (RetroBar/Controls/TaskList.xaml.cs)
2. Update TaskButton styling and behavior to reflect any changes to how grouped tasks appear or interact (RetroBar/Controls/TaskButton.xaml.cs)
3. If adding/removing columns or layout, adjust the Toolbar container and docking logic (RetroBar/Controls/Toolbar.xaml.cs)
4. Test against different OS theme styles (Win95, WinXP, Vista, etc.) defined in App.xaml resources (RetroBar/App.xaml)

Add a new value converter for XAML bindings

1. Create a new class in RetroBar/Converters/ implementing IValueConverter or IMultiValueConverter (RetroBar/Converters/[NewConverter].cs)
2. Implement Convert() and ConvertBack() methods to define transformation logic (RetroBar/Converters/[NewConverter].cs)
3. Declare the converter as a static resource in App.xaml to make it available to all XAML files (RetroBar/App.xaml)
4. Use the converter in control bindings via {Binding Path, Converter={StaticResource [ConverterName]}} (RetroBar/Controls/[TargetControl].xaml)

• WPF (Windows Presentation Foundation) — Native Windows desktop framework enabling pixel-perfect retro UI rendering with XAML, hardware acceleration, and seamless Windows integration for taskbar replacement.
• .NET 6.0 Desktop Runtime — Modern, supported runtime with performance improvements and cross-platform build capability while maintaining Windows-only deployment for shell integration.
• ManagedShell library — Provides low-level Windows shell interop (window enumeration, taskbar positioning, notification area integration) without reinventing platform APIs.
• XAML Resource Dictionaries for Localization — Declarative, runtime-switchable language strings without recompilation; supports 40+ languages and easy community translation.

• WPF over WinUI/UWP

  • Why: WPF is mature and trusted for Windows shell replacement; WinUI has sandboxing and modern app constraints that break taskbar replacement scenarios.
  • Consequence: Inherits older (but stable) XAML dialect and dependencies; not UWP-compatible for Store deployment.

• Single EXE per OS version vs. dynamic theme selection

  • Why: Selected dynamic theme selection (Win95, 98, XP, Vista themes loaded at runtime from App.xaml) for code maintainability over separate builds.
  • Consequence: Larger single binary but much simpler maintenance and unified codebase; users can switch themes without reinstalling.

• Replacing system taskbar vs. side-by-side coexistence

  • Why: Complete replacement provides authentic retro UX and single visual paradigm; coexistence would confuse users.
  • Consequence: Requires elevated privileges and system-level hooks; incompatible with Windows Tablets and some accessibility tools.

• MVVM via WPF bindings without a separate View Model layer

  • Why: Controls are light-weight and directly driven by Win32 enumerations; full MVVM would add ceremony without much benefit for a shell utility.
  • Consequence:

WPF native window hooking (taskbar positioning, window enumeration) is OS-version sensitive—freshly updated Windows 7 may require KB patches (noted in #1319). ManagedShell interop layer must match .NET 6.0+ runtime exactly; version mismatches cause silent failures. XAML theme files are external to src and loaded at runtime via path conventions (not visible in file list), so moving/renaming theme directories breaks skinning. NotifyIcon balloon positioning uses Win32 NOTIFYICONDATA structs—changes to notification area layout can break third-party systray apps.

• WPF Value Converters — RetroBar's Converters/ directory contains 13+ converters (BoolToVisibilityConverter, EdgeOrientationConverter, EnumConverter) that transform model state into XAML binding values without code-behind; understanding the converter pattern is essential for modifying UI data binding logic.
• Win32 Window Hooks & Message Pumps — RetroBar hooks into Windows taskbar position/visibility via ManagedShell interop (WH_SHELL, WM_WINDOWPOSCHANGED); changes to window enumeration or z-order logic require understanding hook callback chains and message routing.
• HLSL Shader Effects in WPF — The small .hlsl file (375 bytes) likely powers Vista thumbnail blur/glass effects; RetroBar uses pixel shaders to achieve legacy visual effects not natively available in modern Windows.
• XAML Dependency Properties & Attached Properties — RetroBar controls (TaskButton, NotifyIcon, Toolbar) use DependencyProperty declarations to bind taskbar state (window list, icon visibility, orientation) to UI; changes to property ownership or binding direction require careful property metadata configuration.
• System Tray/Notification Area APIs — NotifyIconList and NotifyBalloon controls implement Win32 Shell_NotifyIcon protocol and balloon notification positioning; supporting third-party tray apps requires exact compliance with NOTIFYICONDATA struct layout and WM_TASKBARCREATED message handling.
• Inno Setup Script Automation — The 16KB Inno Setup file orchestrates .NET 6 runtime detection and installation alongside RetroBar; understanding installer logic is critical for packaging changes and troubleshooting deployment on fresh Windows 7 systems.
• UWP App Detection & Interop — TaskList.xaml.cs distinguishes UWP packaged apps from classic Win32 processes for proper task button rendering and window activation; UWP uses different window class names and activation routes than legacy windows.

• cairoshell/ManagedShell — Direct upstream dependency providing low-level Windows API bindings for taskbar positioning, window enumeration, and system hooks that RetroBar wraps with classic UI
• Open-Shell/Open-Shell-Menu — Alternative Windows shell replacement offering classic Start Menu and Classic Explorer; shares same nostalgia audience and Windows API interop challenges
• tu226/Mica — Similar WPF-based Windows theming engine; demonstrates modern .NET 6 UI patterns and Fluent Design interop relevant for RetroBar's shader and renderer work
• microsoft/WindowsAppSDK — Official modern Windows app framework (WinUI 3 successor); RetroBar could migrate from WPF if contributors wish to adopt newer platform APIs for emoji/color rendering
• codetector1374/windows11-taskbar-styler — Lightweight taskbar theming tool for Windows 11; shows alternative approach to taskbar visual customization vs. RetroBar's full replacement strategy

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add unit tests for Converter classes in RetroBar/Converters

The Converters directory contains 17+ IValueConverter implementations (BoolToVisibilityConverter, EdgeOrientationConverter, TaskButtonStyleConverter, etc.) with no visible test coverage. These are critical for XAML binding logic and are high-risk for regressions. Adding xUnit tests would ensure converter logic remains correct across Windows versions and theme changes.

• [ ] Create RetroBar.Tests project in solution if it doesn't exist
• [ ] Add xUnit and Moq NuGet packages to test project
• [ ] Write unit tests for each converter in RetroBar/Converters/ (focus on edge cases: null inputs, invalid enum values, boundary conditions)
• [ ] Test converters like DockOrientationConverter and EdgeOrientationVisibilityConverter with different taskbar edge positions
• [ ] Add test execution to .github/workflows/retrobar.yml CI pipeline

Extract and document keyboard navigation behavior for taskbar controls

The Controls directory has many interactive elements (StartButton, TaskButton, ToolbarButton, TaskList) that handle keyboard input for accessibility, but there's no documentation or specification of keyboard shortcuts. This is especially important for a Windows 95/98-era recreation where Alt+Tab and keyboard-driven taskbar interaction are expected. Create a KEYBOARD.md file and add accessibility tests.

• [ ] Review RetroBar/Controls/StartButton.xaml.cs, TaskButton.xaml.cs, and TaskList.xaml.cs for keyboard event handlers
• [ ] Create KEYBOARD.md documenting taskbar keyboard shortcuts and navigation patterns (e.g., Alt+Tab, Win key behavior)
• [ ] Verify and document shortcuts match classic Windows taskbar behavior across Windows 95, XP, and Vista themes
• [ ] Add integration tests in RetroBar.Tests for keyboard navigation (UIAutomation or similar)
• [ ] Update README.md with a link to KEYBOARD.md

Add GitHub Actions workflow for automated localization testing and coverage reporting

The Languages directory contains 9+ XAML localization files (English, Deutsch, Nederlands, etc.) but the existing CI workflow (retrobar.yml) doesn't validate them. Missing translations or broken string references in language files could ship undetected. Add a workflow that validates all language files are parseable, checks for missing keys, and generates coverage reports.

• [ ] Create .github/workflows/localization-check.yml to parse and validate all XAML files in RetroBar/Languages/
• [ ] Add build step to verify each language file has no duplicate or missing resource keys compared to English.xaml
• [ ] Generate a localization coverage report (% of strings translated per language)
• [ ] Fail CI if critical strings are missing in any language file
• [ ] Add badge to README.md showing localization status (similar to build status badge)

• Add missing .xaml code-behind test coverage for Controls/ subdirectory—Clock.xaml.cs, ShowDesktopButton.xaml.cs, and InputLanguage.xaml.cs have no visible unit tests; create xUnit test class with mocks for DependencyProperty changes.
• Document theme creation guide with concrete example in README—currently no explanation of how .xaml theme files map to controls or which converters affect color output; add screenshots showing theme asset structure and binding precedence.
• Investigate and document Windows 11 23H2 taskbar positioning edge cases in Controls/Toolbar.xaml.cs—users report taskbar drawn behind search box on some configs; add logging for DPI scaling and edge detection to diagnose root cause.

RetroBar is a desktop UI customization tool with relatively low security risk given its nature as a desktop application. No obvious critical vulnerabilities were identified from the file structure. However, the analysis is limited by the absence of actual source code content and dependency files. The main risks are: (1) unverified third-party dependencies requiring audit, (2) potential input validation gaps in UI controls handling system data, and (3) Windows API interop security which needs careful implementation. The application appears well-structured with no evident hardcoded secrets or obvious injection points based on available file names. Regular dependency auditing and secure coding practices for system API interaction are recommended.

• Medium · Missing Dependency Information — Project root - missing dependency manifest. The codebase structure indicates this is a .NET WPF application with dependencies on external libraries (specifically ManagedShell), but no package dependency file (*.csproj, packages.config, or .csproj.lock) was provided for analysis. This prevents verification of known vulnerabilities in dependencies. Fix: Provide complete dependency files and regularly audit them using tools like OWASP Dependency-Check or NuGet package auditing. Ensure all NuGet packages are kept updated and use automated dependency scanning in CI/CD pipelines.
• Low · No Evidence of Input Validation in UI Controls — RetroBar/Controls/*.xaml.cs files. Multiple control files (Clock.xaml.cs, StartButton.xaml.cs, TaskButton.xaml.cs, etc.) exist but cannot be verified for proper input validation. WPF applications handling user input or system data should sanitize all inputs to prevent injection attacks. Fix: Implement comprehensive input validation for all user-facing controls. Validate and sanitize any data received from system APIs or user input before processing or displaying.
• Low · Potential Sensitive Data in Language Files — RetroBar/Languages/*.xaml files. Multiple language resource files (.xaml) are present in the Languages directory. While unlikely to contain secrets, localization files should be reviewed to ensure no sensitive information is hardcoded. Fix: Audit language files to ensure no credentials, API keys, or sensitive configuration data are hardcoded. Use configuration management for any environment-specific settings.
• Low · Windows API Interop Security — RetroBar - SystemAPI interactions via ManagedShell. The codebase uses ManagedShell library and appears to interact with Windows system APIs (taskbar manipulation, notify icons, system tray). Improper P/Invoke declarations or unvalidated system API calls could pose security risks. Fix: Review all Windows API interop code for proper parameter validation. Use safe API wrappers when available. Document all P/Invoke declarations with security considerations. Ensure least-privilege principles are followed.
• Low · GitHub Actions Workflow Review Required — .github/workflows/*.yml. CI/CD workflow files exist but content was not provided (.github/workflows/retrobar.yml, comment-pr-artifacts.yml). These should be reviewed for secure secrets management and build security. Fix: Review workflow files to ensure: (1) secrets are not logged, (2) third-party actions are from trusted sources, (3) build artifacts are signed, (4) no hardcoded credentials, (5) proper access controls are applied.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.