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/andrewmd5/Borderless-Gaming 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.

WAIT — Slowing — last commit 8mo ago

• Last commit 8mo ago
• 17 active contributors
• GPL-2.0 licensed
• ⚠ Slowing — last commit 8mo ago
• ⚠ Concentrated ownership — top contributor handles 60% of recent commits
• ⚠ GPL-2.0 is copyleft — check downstream compatibility
• ⚠ No CI workflows detected
• ⚠ 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 andrewmd5/Borderless-Gaming repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/andrewmd5/Borderless-Gaming.

What it runs against: a local clone of andrewmd5/Borderless-Gaming — 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 andrewmd5/Borderless-Gaming | Confirms the artifact applies here, not a fork | | 2 | License is still GPL-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 ≤ 276 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of andrewmd5/Borderless-Gaming. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/andrewmd5/Borderless-Gaming.git
#   cd Borderless-Gaming
#
# 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 andrewmd5/Borderless-Gaming and re-run."
  exit 2
fi

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

# 2. License matches what RepoPilot saw
(grep -qiE "^(GPL-2\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"GPL-2\\.0\"" package.json 2>/dev/null) \\
  && ok "license is GPL-2.0" \\
  || miss "license drift — was GPL-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 "BorderlessGaming/Program.cs" \\
  && ok "BorderlessGaming/Program.cs" \\
  || miss "missing critical file: BorderlessGaming/Program.cs"
test -f "BorderlessGaming/Forms/MainWindow.cs" \\
  && ok "BorderlessGaming/Forms/MainWindow.cs" \\
  || miss "missing critical file: BorderlessGaming/Forms/MainWindow.cs"
test -f "BorderlessGaming.Logic/Windows/Manipulation.cs" \\
  && ok "BorderlessGaming.Logic/Windows/Manipulation.cs" \\
  || miss "missing critical file: BorderlessGaming.Logic/Windows/Manipulation.cs"
test -f "BorderlessGaming.Logic/Windows/Native.cs" \\
  && ok "BorderlessGaming.Logic/Windows/Native.cs" \\
  || miss "missing critical file: BorderlessGaming.Logic/Windows/Native.cs"
test -f "BorderlessGaming.Logic/Core/ProcessWatcher.cs" \\
  && ok "BorderlessGaming.Logic/Core/ProcessWatcher.cs" \\
  || miss "missing critical file: BorderlessGaming.Logic/Core/ProcessWatcher.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 276 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~246d)"
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/andrewmd5/Borderless-Gaming"
  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).

Borderless Gaming is a C# Windows utility that removes window borders and decorations from fullscreen windowed games, allowing them to display edge-to-edge on the entire monitor without the performance penalty of true fullscreen mode. It manipulates window properties via Win32 API (see BorderlessGaming.Logic/Windows/Manipulation.cs and Native.cs) to transform borderless windowed games into seamless fullscreen experiences. Dual-project solution: BorderlessGaming.Logic is a class library containing core Windows manipulation (Manipulation.cs, ForegroundManager.cs, VolumeMixer.cs), process handling (ProcessWatcher.cs), and system integration (AutoStart.cs, Uac.cs); BorderlessGaming is the WinForms UI frontend. Models live in BorderlessGaming.Logic/Models/ (Favorite.cs, Config.cs, AppSettings.cs), and native Win32 interop is centralized in BorderlessGaming.Logic/Windows/.

PC gamers who play windowed games and want to eliminate alt-tab delays and window chrome, and modders/developers who contribute C# code to extend game compatibility or add window management features.

Production-ready and actively maintained. The project is sold on Steam (app/388080) with a multi-year history, has a structured codebase with clean separation between UI (BorderlessGaming/) and logic (BorderlessGaming.Logic/), and includes issue templates and contribution guidelines. However, the repo lacks visible CI/CD pipelines and automated test suites in the file list.

Low-to-moderate risk: single maintainer (andrewmd5), relies heavily on Win32 API surface which changes across Windows versions (requires careful testing on Windows 7–11), and no visible unit test coverage in the file structure. The BGKey.pfx code signing certificate is checked in, which is a security concern. Open issues likely accumulate since no automated CI is evident.

Unable to determine from file structure alone (no recent commit history, PR list, or milestones visible). Check GitHub Actions workflows and the Issues tab for current activity.

Clone the repository: git clone https://github.com/andrewmd5/Borderless-Gaming.git. Open BorderlessGaming.sln in Visual Studio 2017 or later. Select Release configuration. Build solution (Ctrl+Shift+B). Generated executable will be in bin/Release/ of the BorderlessGaming project.

Daily commands: Open BorderlessGaming.sln in Visual Studio → Select Release config → Build All → Run BorderlessGaming.exe from bin/Release/. No package.json or build script; compilation is IDE-driven.

• BorderlessGaming/Program.cs — Application entry point; establishes initialization flow and main window lifecycle for the borderless gaming tool.
• BorderlessGaming/Forms/MainWindow.cs — Primary UI controller managing game list, process detection, and user interactions; central orchestrator for all feature workflows.
• BorderlessGaming.Logic/Windows/Manipulation.cs — Core window manipulation logic; implements the borderless window transformation via native Windows API calls—the heart of the tool.
• BorderlessGaming.Logic/Windows/Native.cs — P/Invoke declarations for all Windows API calls (SetWindowPos, FindWindow, etc.); any API change breaks core functionality.
• BorderlessGaming.Logic/Core/ProcessWatcher.cs — Real-time process monitoring system; detects running games and triggers window transformation events.
• BorderlessGaming.Logic/Models/Favorite.cs — Data model for saved game configurations; defines the serialization contract for persistence across sessions.
• BorderlessGaming.Logic/System/Tools.cs — Utility functions for file I/O, configuration loading, and system state management; widely used across codebase.

Add support for a new game platform (Steam integration, Epic, etc.)

1. Create a new platform provider class in BorderlessGaming.Logic (e.g., PlatformDetector.cs) that implements IGameProvider interface (BorderlessGaming.Logic/System/Tools.cs)
2. Add method to scan the platform's installation directory and populate a list of game executables (BorderlessGaming/Forms/MainWindow.cs)
3. Integrate the provider into MainWindow.cs event handlers that populate the game list on startup (BorderlessGaming/Forms/MainWindow.cs)
4. Test with ProcessWatcher to ensure new games are detected when launched (BorderlessGaming.Logic/Core/ProcessWatcher.cs)

Add a new window transformation setting (e.g., custom transparency, aspect ratio lock)

1. Add new property to Favorite.cs model to store the setting (BorderlessGaming.Logic/Models/Favorite.cs)
2. Create UI control in MainWindow.Designer.cs and corresponding handler in MainWindow.cs (BorderlessGaming/Forms/MainWindow.Designer.cs)
3. Implement the transformation logic in Manipulation.cs using appropriate Windows API calls (BorderlessGaming.Logic/Windows/Manipulation.cs)
4. Persist setting to config file via Tools.cs and reload on application restart (BorderlessGaming.Logic/System/Tools.cs)

Add a new language localization

1. Create a new .lang file in Languages/ directory following the format of existing language files (e.g., Languages/es-MX.lang) (Languages/en-US.lang)
2. Update LanguageManager.cs to register the new language code and load resources (BorderlessGaming.Logic/Core/LanguageManager.cs)
3. Translate all form .resx files for the new locale (AboutForm.es-MX.resx, MainWindow.es-MX.resx, etc.) (BorderlessGaming/Forms/MainWindow.en-US.resx)
4. Add language option to MainWindow UI dropdown and test locale switching (BorderlessGaming/Forms/MainWindow.cs)

Modify window manipulation behavior or add custom positioning logic

1. Review current SetWindowPos and SetWindowLong calls in Manipulation.cs to understand style flags (BorderlessGaming.Logic/Windows/Manipulation.cs)
2. Add new native API declarations to Native.cs if additional Windows calls are needed (BorderlessGaming.Logic/Windows/Native.cs)
3. Implement new positioning logic in Manipulation.cs, passing custom RECT coordinates (BorderlessGaming.Logic/Windows/Manipulation.cs)
4. Test end-to-end through MainWindow by triggering transformation on a selected game (BorderlessGaming/Forms/MainWindow.cs)

• Windows Forms (.NET Framework) — Lightweight desktop UI for Windows-only application; direct OS integration without web overhead; proven stability for system utilities.
• P/Invoke (Windows API interop) — Direct access to native SetWindowPos, SetWindowLong, and window handle manipulation—essential for borderless window transformation.
• Process monitoring via WMI/System.Diagnostics — Real-time detection of game launch and termination without polling overhead; enables automatic window transformation.
• XML/JSON-based configuration persistence — Human-readable storage of game favorites and user preferences; simple serialization without database dependency.
• Registry access for UAC and startup management — Windows-standard mechanism for auto-start and privilege elevation without external dependencies.

• Tightly coupled Windows Forms UI to business logic in MainWindow.cs

  • Why: Rapid development for small, focused tool; avoids MVVM boilerplate overhead.
  • Consequence: UI logic is difficult to test independently; refactoring UI requires careful modification of event handlers.

• Synchronous window manipulation in main thread

  • Why: Simplifies state management and avoids race conditions on window handles.
  • Consequence: Long-running manipulation operations may briefly freeze UI; no apparent latency for typical game windows.

• Manual process enumeration and monitoring instead of event-driven OS notifications

  • Why: Greater control and compatibility across Windows versions; avoids WMI overhead for simple filtering.
  • Consequence: undefined

BGKey.pfx is committed to the repo — this code-signing certificate should be removed or moved to secure storage immediately. Win32 API calls in Native.cs may behave differently on Windows 7, 8, 10, 11; test on all target versions before release. ProcessWatcher uses polling (not WMI events), which may consume CPU on old hardware. Config serialization format unknown — changes to Config.cs might silently break existing user settings. No visible async/await pattern; long-running window operations may freeze the UI.

• Win32 P/Invoke — This entire project is built on calling native Windows APIs (SetWindowPos, FindWindow, GetWindowLong) from managed C#; understanding marshaling, calling conventions, and error codes is essential to any modification.
• Window Class Manipulation (SetWindowLong/GWL_STYLE) — Borderless Gaming works by removing WS_CAPTION, WS_THICKFRAME, and WS_DLGFRAME window style flags; understanding how Windows interprets these flags is core to the tool's function.
• Process Polling vs Event-Driven Monitoring — ProcessWatcher.cs uses polling to detect new game processes; this design choice affects CPU usage and responsiveness. A learner should understand trade-offs between polling and WMI event subscriptions.
• Foreground Window Detection — ForegroundManager.cs must detect when a game window comes to focus to apply borderless mode; GetForegroundWindow() has subtle timing issues that cause missed detections.
• Application Configuration Persistence — Config.cs and AppSettings.cs handle saving user-selected favorite games and preferences; schema changes must be backward-compatible to avoid breaking existing installations.
• Inno Setup Installer Scripting — The .iss files in this repo (visible in .github/) drive the Windows installer; Inno Setup syntax is non-obvious and affects distribution/installation flow.
• UAC (User Access Control) Elevation — BorderlessGaming.Logic/Windows/Uac.cs handles privilege escalation; certain window manipulations (like resizing system windows) may require admin rights, and failing to request them silently breaks functionality.

• Codeusa/Borderless-Gaming — This is the original/canonical repo (note: andrewmd5/Borderless-Gaming is a fork or mirror of the community-maintained version)
• Orbmu2k/nvidiaProfileInspector — Related Windows game optimization tool; uses similar Win32 API patterns for system-level game tweaking
• GameTechWiki/DXVK — Complementary graphics layer for borderless fullscreen gaming; often used alongside Borderless Gaming for better performance
• maximegmd/GlosSI — Similar borderless window/game wrapping tool for Steam Deck/Linux; shared problem domain and UI patterns
• microsoft/terminal — Example of modern C# + Win32 P/Invoke patterns; useful reference for cross-version Windows API handling

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 BorderlessGaming.Logic core modules

The repo lacks any visible test project despite having complex logic in BorderlessGaming.Logic/Core (LanguageManager.cs, ProcessWatcher.cs) and BorderlessGaming.Logic/Windows (Native.cs, Manipulation.cs, ForegroundManager.cs). These modules handle critical window manipulation and process detection. Adding xUnit or NUnit tests would improve code reliability and make refactoring safer.

• [ ] Create new project: BorderlessGaming.Logic.Tests with xUnit
• [ ] Add unit tests for ProcessWatcher.cs (process detection and filtering logic)
• [ ] Add unit tests for LanguageManager.cs (language switching and resource loading)
• [ ] Add unit tests for Windows/Manipulation.cs (window border removal operations)
• [ ] Configure test project in BorderlessGaming.sln and add basic CI workflow

Add GitHub Actions workflow for .NET build and release automation

The .github/ISSUE_TEMPLATE directory exists but there are no GitHub Actions workflows (.github/workflows/) for automated building, testing, or releasing. With a signed certificate (BGKey.pfx present) and Windows Forms application, setting up CI/CD would catch build regressions and streamline releases.

• [ ] Create .github/workflows/build.yml to compile both BorderlessGaming and BorderlessGaming.Logic projects on pull requests
• [ ] Add .github/workflows/release.yml to automatically build and create releases when tags are pushed
• [ ] Configure certificate signing in the release workflow using the BGKey.pfx (store as secret)
• [ ] Add step to run any unit tests from the test project (from PR #1)
• [ ] Update README with build status badge

Create XML documentation and generate API docs for BorderlessGaming.Logic public API

Critical classes like Native.cs, Manipulation.cs, ForegroundManager.cs, ProcessWatcher.cs, and Models/* lack XML documentation comments. This is a library that others might want to extend or integrate with. Adding documentation comments and generating Sandcastle/DocFX documentation would significantly improve maintainability.

• [ ] Add XML documentation comments (///) to all public types and methods in BorderlessGaming.Logic/Windows/Native.cs
• [ ] Add XML documentation to BorderlessGaming.Logic/Windows/Manipulation.cs and ForegroundManager.cs
• [ ] Add XML documentation to all Model classes in BorderlessGaming.Logic/Models/*
• [ ] Enable XML documentation generation in BorderlessGaming.Logic.csproj (GenerateDocumentationFile)
• [ ] Add .docfx.json configuration and generate docs site, commit docs folder to support GitHub Pages

• Add unit tests for BorderlessGaming.Logic/Models/Config.cs serialization/deserialization to prevent silent corruption of user settings on schema changes.
• Document the exact Win32 API contract in BorderlessGaming.Logic/Windows/Native.cs (e.g. which calls fail on which Windows versions) and add version-gated code paths.
• Implement automated integration tests that launch a test game window and verify Manipulation.cs correctly removes borders across Windows 7, 10, 11.

• High · Hardcoded Signing Certificate Exposed — BGKey.pfx (repository root). The file 'BGKey.pfx' is a code signing certificate that should never be committed to version control. This is a private key file used for signing assemblies and could be used by attackers to sign malicious code with the project's identity, leading to supply chain attacks. Fix: Immediately revoke this certificate, generate a new one, and store it securely outside the repository (e.g., in CI/CD secrets management). Add *.pfx to .gitignore and use environment variables or secure vaults for certificate handling during builds.
• High · Potential UAC Bypass or Privilege Escalation — BorderlessGaming.Logic/Windows/Uac.cs. The presence of 'BorderlessGaming.Logic/Windows/Uac.cs' suggests UAC (User Account Control) manipulation. Without inspecting the code, there's a risk this utility could be used to bypass UAC prompts or escalate privileges improperly, which is a common attack vector in Windows applications. Fix: Review and validate that UAC interactions follow Microsoft's security guidelines. Ensure prompts are not bypassed silently, and that elevation is only requested when legitimately needed. Use proper Windows API calls with adequate validation.
• High · Unsafe Window Manipulation — BorderlessGaming.Logic/Windows/Manipulation.cs, BorderlessGaming.Logic/Windows/Native.cs. The application manipulates window properties (BorderlessGaming.Logic/Windows/Manipulation.cs) and uses native Windows API calls (Native.cs). This could expose the system to window-based injection attacks or allow manipulation of other applications' windows, potentially facilitating malicious behavior. Fix: Validate that window manipulation only targets explicitly selected processes. Implement safeguards to prevent unauthorized access to sensitive windows (e.g., password fields, authentication dialogs). Use proper error handling for API calls.
• Medium · Process Monitoring Without Validation — BorderlessGaming.Logic/Core/ProcessWatcher.cs. The ProcessWatcher (BorderlessGaming.Logic/Core/ProcessWatcher.cs) monitors running processes. Insufficient validation of process targeting could allow the tool to apply styles to unintended applications, including system processes or security software. Fix: Implement strict process validation before applying window modifications. Maintain a whitelist of allowed processes or require explicit user confirmation before modifying critical system processes.
• Medium · Installer with Elevated Privileges — Installers/BorderlessGaming_Standalone_Admin.iss. The Inno Setup installer script (Installers/BorderlessGaming_Standalone_Admin.iss) suggests the application runs with admin privileges. This increases the attack surface and potential impact if the application is compromised. Fix: Evaluate if admin privileges are truly necessary. If required, document why and implement a privilege escalation prompt with clear justification. Consider running only sensitive operations with elevated privileges rather than the entire application.
• Medium · Configuration Files Not Reviewed — BorderlessGaming.Logic/Models/AppSettings.cs, BorderlessGaming.Logic/Models/Config.cs. Configuration files (AppSettings.cs, Config.cs) handle user settings. Without reviewing the code, there's a risk of insecure deserialization, injection attacks through config values, or exposure of sensitive settings. Fix: Validate and sanitize all configuration values before use. Avoid deserialization of untrusted data. Store sensitive settings securely (encrypted) and never log configuration values containing secrets.
• Low · Missing Dependency Information — Dependencies not provided in analysis context. No package dependencies file (packages.config, .csproj dependencies, or similar) was provided for analysis. This prevents evaluation of third-party library vulnerabilities. Fix: Perform regular dependency scanning using tools like OWASP Dependency-Check, NuGet Advisor, or Snyk. Keep all NuGet packages updated to the latest secure versions.
• Low · Audio Volume Mixer Access — BorderlessGaming.Logic/Windows/Audio. The VolumeMixer component (BorderlessGaming.Logic/Windows/Audio/VolumeMixer.cs) accesses audio settings. Improper validation could allow unauthorized manipulation of system audio or other applications' audio levels. Fix: undefined

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.