Borderless Gaming Copyright Violation

[MikuLover1983]

Hi. Writing to make it known that there's been a new development with the software "Borderless Gaming". This software has existed for a long while now, but as of the past year the developer has been making updates much more frequently. In one of the most recent updates, the developer included functionality for what was coined "BGFX". This update allows the user to design and create shaders/filters specifically for the Borderless Gaming software that can be applied in post.

Many users have noticed that this functionality is extremely similar to the ones that Magpie provides. So much so that the loose shader files included with Borderless Gaming are direct copies (including the directory structure) of the shaders that are included with Magpie with additional LLM style comment modifications (without disclosure to purchasers) to them without the required licenses propigated to do so.

Additionally, if you are to take the original Magpie shaders, and throw them into the Borderless Gaming software with the file extension that Borderless Gaming is looking for, the shaders do load properly -- which suggests that much more of the work of Magpie has been derrived without any proper licensing or releasing of code for derived work.

I will admit, I cannot reverse engineer much. So I am making this report in hopes that the smarter tech crowd will be able to dive into this and report what is necessary to prove or deny such.

[Blinue]

Thanks for letting me know! Based on the screenshots you provided, BGFX is clearly derived from MagpieFX, with only minor modifications.

I’m not too concerned about licensing issues, since Borderless-Gaming is licensed under GPLv2. I expect the source code for the new version to be released before long, though that may imply BG would need to be relicensed under GPLv3. I’m not an expert on licensing details, however.

[MikuLover1983]

My understanding is that the GitHub linked there is only to provide the source for the "Legacy" version of Borderless Gaming (Pre V1.0 rewrite -- I know the version numbers do not make any sense to me either). Which does not, and will likely not ever include the changes made to the software in it's BGFX update.

[andrewmd5]

Maintainer of Borderless Gaming here.

To clarify: Borderless Gaming is written entirely in C# / .NET. It doesn't link against, include, or use any Magpie code.

BGFX was designed with compatibility in mind for the existing shader ecosystems. This is also why it supports RetroArch pipeline features like feedback textures and history buffers. The parser is intentionally fault-tolerant; I'd rather load a slightly malformed effect than fail on users. Here's how it handles directives:

switch (keyword)
{
    case "VERSION":
        if (int.TryParse(value, out version))
            hasVersion = true;
        break;
    case "NAME":
        if (currentBlock == "PASS" && blockState != null)
            blockState.PassName = value;
        else
            displayName = value;
        break;
    case "CATEGORY":
        category = value;
        break;
    case "DESCRIPTION":
    case "DESC":  // accepts both forms
        if (currentBlock == null)
            description = value;
        else if (blockState != null)
            blockState.Description = value;
        break;
    case "FILTER":
        if (blockState != null) blockState.Filter = value;
        break;
    case "ADDRESS":
        if (blockState != null) blockState.Address = value;
        break;
    // ... additional directives
}

Multiple keywords map to the same behavior where it makes sense (DESC/DESCRIPTION), and the parser handles context-dependent directives like NAME differently depending on whether you're inside a PASS block or at the top level.

Post-parsing, there's additional mapping logic to translate various formats (MagPie-style and RetroArch-style) into the internal BGFX representation. That's why Magpie effects happen to load; it was a deliberate compatibility decision.

All license attributions are preserved in bundled open-source based effects, and BGFX.md documents the format. I can add clear language this version 1 is derived from MagPieFX, and I will provide links in the markdown file to where each effect was originally pulled from.

However, version 2 which releases next month moves to SPIR-V/Slang to support Vulkan and DX12 backends (the former being open sourced under GPLv3 to support SteamDeck). However I'll retain things for historical context.

Happy to answer questions. If @Blinue has any preferences I'll work with them.

[PancakeTAS]

All license attributions are preserved in bundled open-source based effects, and BGFX.md documents the format. I can add clear language this version 1 is derived from MagPieFX, and I will provide links in the markdown file to where each effect was originally pulled from.

You have a fatal misunderstanding of how OSS licenses work. The GPL (more specifically GPLv3) requires you to release the source code of your entire derivative work, this includes Borderless Gaming itself. Just providing a "license notice" is not enough. You've essentially just admitted to violating the copyright.

To clarify: Borderless Gaming is written entirely in C# / .NET. It doesn't link against, include, or use any Magpie code.

If this is truly the case, care to comment why nearly all Magpie class-names exists 1:1 in your binary? To me this clearly sounds like you either manually translated Magpie's source code into your application, or told an LLM to write it for you (which took plenty of inspiration from Magpie's code).

$ cat BorderlessGaming.exe | grep -i AdaptivePresenter                 
grep: (standard input): binary file matches
$ cat BorderlessGaming.exe | grep -i CompSwapchainPresenter
grep: (standard input): binary file matches
$ cat BorderlessGaming.exe | grep -i CursorDrawer          
grep: (standard input): binary file matches
$ cat BorderlessGaming.exe | grep -i CursorManager
grep: (standard input): binary file matches
$ cat BorderlessGaming.exe | grep -i DDSHelper                         
grep: (standard input): binary file matches
$ cat BorderlessGaming.exe | grep -i DesktopDuplicationFrameSource
grep: (standard input): binary file matcher
$ cat BorderlessGaming.exe | grep -i DeviceResources              
grep: (standard input): binary file matches
$ cat BorderlessGaming.exe | grep -i DwmSharedSurfaceFrameSource  
grep: (standard input): binary file matches
$ cat BorderlessGaming.exe | grep -i EffectCacheManager
grep: (standard input): binary file matches
$ cat BorderlessGaming.exe | grep -i EffectCompiler    
grep: (standard input): binary file matches
$ cat BorderlessGaming.exe | grep -i EffectDrawer  
grep: (standard input): binary file matches
(it goes on - I did not want to bother checking the rest)

Please release the source code under GPLv3.

[andrewmd5]

You have a fatal misunderstanding of how OSS licenses work. The GPL (more specifically GPLv3) requires you to release the source code of your entire derivative work,

I appreciate the concern, but this isn't quite right. The effects are bundled with the software as a derivative work, yes. But you can't copyright a protocol or abstraction. Providing a compatible interface doesn't make something a derivative work per Google v. Oracle. We had counsel review this before shipping specifically because we wanted to be certain about our obligations around shaders.

Second, grepping for strings in a compiled binary without context is misleading. Here's an example from our DXGI capture code:

using System;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BorderlessGaming.Infrastructure.Diagnostic;
using DirectN;
using DirectN.Extensions;
using DirectN.Extensions.Com;
using Serilog;
using Windows.Win32;
using Win32HWND = Windows.Win32.Foundation.HWND;
using Win32RECT = Windows.Win32.Foundation.RECT;
using Win32HMONITOR = Windows.Win32.Graphics.Gdi.HMONITOR;

namespace BorderlessGaming.Core.Graphics;

[SupportedOSPlatform("windows10.0.19041.0")]
internal sealed class DesktopDuplicationFrameSource : FrameSourceBase
{
    private static readonly int MoveRectSize = Marshal.SizeOf<DXGI_OUTDUPL_MOVE_RECT>();
    private static readonly int DirtyRectSize = Marshal.SizeOf<DirectN.RECT>();

    private readonly Win32HWND _sourceWindow;
    private readonly Win32HWND _overlayWindow;

    private IComObject<IDXGIOutput1>? _dxgiOutput;
    private IComObject<IDXGIOutputDuplication>? _outputDuplication;

    private Win32RECT _captureRegion;
    private D3D11_BOX _copyRegion;
    private byte[]? _metadataBuffer;
    private bool _frameAcquired;

    public override string Name => "Desktop Duplication";

    public DesktopDuplicationFrameSource(Win32HWND sourceWindow, Win32HWND overlayWindow)
    {
        if (sourceWindow.IsNull)
            throw new ArgumentException("Invalid source window handle", nameof(sourceWindow));

        _sourceWindow = sourceWindow;
        _overlayWindow = overlayWindow;
    }

    public static bool IsSupported()
    {
        return OperatingSystem.IsWindowsVersionAtLeast(10, 0, 19041);
    }

    protected override unsafe bool InitializeCore()
    {
        if (_deviceResources == null || _windowing == null) return false;

        try
        {
            var monitor = PInvoke.MonitorFromWindow(_sourceWindow,
                Windows.Win32.Graphics.Gdi.MONITOR_FROM_FLAGS.MONITOR_DEFAULTTONULL);
            if (monitor.IsNull)
            {
                Log.Warning("Failed to get monitor for source window");
                return false;
            }

            var monitorInfo = new Windows.Win32.Graphics.Gdi.MONITORINFO
            {
                cbSize = (uint)Marshal.SizeOf<Windows.Win32.Graphics.Gdi.MONITORINFO>()
            };
            if (!PInvoke.GetMonitorInfo(monitor, ref monitorInfo))
            {
                Log.Warning("GetMonitorInfo failed");
                return false;
            }

            var windowRect = _windowing.SourceRect;

            Log.Information("Window rect: {X},{Y} {W}x{H}, Monitor: {MX},{MY}",
                windowRect.Left, windowRect.Top, windowRect.Width, windowRect.Height,
                monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.top);

            _captureRegion = new Win32RECT
            {
                left = windowRect.Left - monitorInfo.rcMonitor.left,
                top = windowRect.Top - monitorInfo.rcMonitor.top,
                right = windowRect.Right - monitorInfo.rcMonitor.left,
                bottom = windowRect.Bottom - monitorInfo.rcMonitor.top
            };

            _copyRegion = new D3D11_BOX
            {
                left = (uint)_captureRegion.left,
                top = (uint)_captureRegion.top,
                front = 0,
                right = (uint)_captureRegion.right,
                bottom = (uint)_captureRegion.bottom,
                back = 1
            };

            int width = windowRect.Width;
            int height = windowRect.Height;

            if (!CreateOutputTexture(width, height))
            {
                Log.Warning("Failed to create output texture");
                return false;
            }

            _dxgiOutput = GetOutputForMonitor(monitor);
            if (_dxgiOutput == null)
            {
                Log.Warning("Failed to find DXGI output for monitor");
                return false;
            }

            if (!_overlayWindow.IsNull)
            {
                if (!PInvoke.SetWindowDisplayAffinity(_overlayWindow,
                        Windows.Win32.UI.WindowsAndMessaging.WINDOW_DISPLAY_AFFINITY.WDA_EXCLUDEFROMCAPTURE))
                {
                    Log.Warning("SetWindowDisplayAffinity failed");
                    return false;
                }
            }

            Log.Information("Initialized for {Width}x{Height} region", width, height);
            return true;
        }
        catch (Exception ex)
        {
            Log.Warning(ex, "DesktopDuplicationFrameSource: Initialization failed");
            return false;
        }
    }

    private unsafe IComObject<IDXGIOutput1>? GetOutputForMonitor(Win32HMONITOR targetMonitor)
    {
        if (_deviceResources == null) return null;

        uint index = 0;
        while (true)
        {
            var hr = _deviceResources.GraphicsAdapter.Object.EnumOutputs(index, out var output);
            if (hr.IsError) break;

            var outputWrapper = new ComObject<IDXGIOutput>(output);
            output.GetDesc(out var desc);

            if (desc.Monitor == (nint)targetMonitor.Value)
            {
                var output1 = outputWrapper.As<IDXGIOutput1>();
                if (output1 != null)
                {
                    return output1;
                }

                Log.Warning("Failed to get IDXGIOutput1");
                outputWrapper.Dispose();
                return null;
            }

            outputWrapper.Dispose();
            index++;
        }

        return null;
    }

    public override bool Start()
    {
        if (_dxgiOutput == null || _deviceResources == null) return false;

        try
        {
            WindowHelper.DisableRoundCornerInWin11(_sourceWindow);

            _outputDuplication = _dxgiOutput.DuplicateOutput(_deviceResources.D3DDevice);
            if (_outputDuplication == null)
            {
                Log.Warning("DuplicateOutput failed");
                return false;
            }

            Log.Information("Capture started");
            return true;
        }
        catch (Exception ex)
        {
            Log.Warning(ex, "DesktopDuplicationFrameSource: Failed to start capture");
            return false;
        }
    }

    public override void Stop()
    {
        if (_frameAcquired && _outputDuplication != null)
        {
            _outputDuplication.Object.ReleaseFrame();
            _frameAcquired = false;
        }

        _outputDuplication?.Dispose();
        _outputDuplication = null;

        Log.Debug("Capture stopped");
    }

    protected override unsafe FrameSourceState UpdateCore()
    {
        if (_outputDuplication == null || _deviceResources == null || _output == null)
            return FrameSourceState.Error;

        if (_frameAcquired)
        {
            _outputDuplication.Object.ReleaseFrame();
            _frameAcquired = false;
        }

        var hr = _outputDuplication.Object.AcquireNextFrame(1, out var frameInfo, out var resource);

        if (hr.Value == unchecked((int)0x887A0027))
        {
            return FrameSourceState.Waiting;
        }

        if (hr.IsError)
        {
            Log.Warning("AcquireNextFrame failed: 0x{Hr:X}", hr.Value);
            return FrameSourceState.Error;
        }

        _frameAcquired = true;

        using var resourceWrapper = new ComObject<IDXGIResource>(resource);

        if (!HasUpdatesInRegion(frameInfo))
        {
            return FrameSourceState.Waiting;
        }

        using var texture = resourceWrapper.As<ID3D11Texture2D>();
        if (texture == null)
        {
            Log.Warning("Failed to get texture from resource");
            return FrameSourceState.Error;
        }

        fixed (D3D11_BOX* pBox = &_copyRegion)
        {
            _deviceResources.D3DContext.Object.CopySubresourceRegion(
                _output.Object, 0, 0, 0, 0,
                texture.Object, 0, (nint)pBox);
        }

        return FrameSourceState.NewFrame;
    }

    private unsafe bool HasUpdatesInRegion(DXGI_OUTDUPL_FRAME_INFO frameInfo)
    {
        if (_outputDuplication == null) return false;

        if (frameInfo.TotalMetadataBufferSize == 0)
            return false;

        if (_metadataBuffer == null || _metadataBuffer.Length < frameInfo.TotalMetadataBufferSize)
        {
            _metadataBuffer = new byte[frameInfo.TotalMetadataBufferSize];
        }

        fixed (byte* pBuffer = _metadataBuffer)
        {
            uint bufSize = frameInfo.TotalMetadataBufferSize;

            var hr = _outputDuplication.Object.GetFrameMoveRects(bufSize, (nint)pBuffer, out bufSize);
            if (hr.IsError)
            {
                Log.Warning("GetFrameMoveRects failed: 0x{Hr:X}", hr.Value);
                return false;
            }

            if (bufSize > 0)
            {
                int count = (int)(bufSize / MoveRectSize);
                var rects = (DXGI_OUTDUPL_MOVE_RECT*)pBuffer;

                for (int i = 0; i < count; i++)
                {
                    if (Overlaps(_captureRegion, rects[i].DestinationRect))
                        return true;
                }
            }

            bufSize = frameInfo.TotalMetadataBufferSize;

            hr = _outputDuplication.Object.GetFrameDirtyRects(bufSize, (nint)pBuffer, out bufSize);
            if (hr.IsError)
            {
                Log.Warning("GetFrameDirtyRects failed: 0x{Hr:X}", hr.Value);
                return false;
            }

            if (bufSize > 0)
            {
                int count = (int)(bufSize / DirtyRectSize);
                var rects = (DirectN.RECT*)pBuffer;

                for (int i = 0; i < count; i++)
                {
                    if (Overlaps(_captureRegion, rects[i]))
                        return true;
                }
            }
        }

        return false;
    }

    private static bool Overlaps(Win32RECT a, DirectN.RECT b)
    {
        return a.left < b.right && a.right > b.left &&
               a.top < b.bottom && a.bottom > b.top;
    }

    public override void Dispose()
    {
        if (_disposed) return;

        Stop();

        _dxgiOutput?.Dispose();
        _dxgiOutput = null;

        base.Dispose();
    }
}

This is C# using DirectN and CsWin32. Different language, different class hierarchies, different resource management patterns. The reason there's overlap in naming is that we're both using the same Windows API. Desktop Duplication is literally called Desktop Duplication. If you call DuplicateOutput and it fails, what else are you going to log? "DuplicateOutput failed" is the obvious message.

The same logic applies to the other class names you found:

• DeviceResources manages D3D device resources. This name shows up in Microsoft's own DirectX templates.
• DesktopDuplicationFrameSource is a frame source that uses Desktop Duplication. The API is called that.
• EffectCompiler compiles effects. It calls the DX shader compiler.
• CursorManager manages cursor state. We've had cursor handling in Borderless Gaming for years, for clipping and visibility.

By this logic, every project with a ConnectionManager or FileHelper is derived from every other. Descriptive names for what classes do aren't protectable expression.

Happy to discuss specific technical concerns, but grep output on generic class names doesn't establish copying.

or told an LLM to write it for you

I am quite capable of writing bad code on my own.

[PancakeTAS]

Thanks for the reply. I'll retract my string-grepping-argument then, I do agree that simple string matches are not in any way proof of copying. I also took a deeper look and it does indeed look like none of the constants match Magpie, so this might very well just be a coincidence.

As for the licenses, I'm still not entirely sure you're correct here, but I'm not a lawyer and not a copyright holder, so I'll leave you to discuss this with the original authors instead.

I am quite capable of writing bad code on my own.

🥲

[Blinue]

@andrewmd5 Thank you for your response! I haven’t purchased BG, so I haven’t been able to investigate it directly; however, based on the screenshots MikuLover1983 shared, the effect code appears to be derived from Magpie’s effects and distributed as part of BG. For example, the presence of the MF macros (short for Magpie Float) suggests that the code originated from Magpie and was subsequently modified.

Under the terms of GPLv3, this would likely classify BG as a derivative work of Magpie. Please consider releasing the source code of the new version of BG in accordance with the license, or removing any code that was ported or modified from Magpie (the DesktopDuplicationFrameSource you provided is clearly ported from Magpie).

[andrewmd5]

Thanks for following up. To clarify how BGFX works: its textual structure provides compatibility for both MagPie and RetroArch formats. When these files are loaded, they're parsed and mapped to BGFX's internal structures. No prior art is utilized in those internals. The MF macros you're seeing exist only in the BGFX file so users can load their existing MagPie effects. The C# codebase is entirely independent.

That said, I'll respect your wishes and remove the MagPie compatibility layer from the BGFX format. It's being deprecated with the Slang migration anyway.

EDIT: that code is ported from Rainway, which I also wrote. Any similarities to Magpie are coincidental. There isn't exactly a novel way to get frames from DXGI. Also looking at your DesktopDuplication implementation it doesn't utilize dirty rects.

[Blinue]

Thank you. To clarify: distributing modified shader code with BG constitutes a violation of the license. All effect files derived from Magpie must be removed, regardless of any internal format produced after parsing.

It is evident that DesktopDuplicationFrameSource was ported from Magpie, as not only is the code logic almost identical, but the class names and inheritance structure are exactly the same.

I welcome derivatives of Magpie, as contributing references to the open-source community is one of the primary reasons I maintain the project. However, this does not extend to commercial, closed-source software.

[andrewmd5]

All effect files derived from Magpie must be removed, regardless of any internal format produced after parsing.

I'll remove them tonight.

[MikuLover1983]

The effects are bundled with the software as a derivative work, yes.

Why was this not publically disclosed to purchasers/users?
Are you going to release the full source code of Borderless Gaming's current version?
What's with the LLM passes on the loose shader files?

[andrewmd5]

The effects are bundled with the software as a derivative work, yes.

Why was this not publically disclosed to purchasers/users? Are you going to release the full source code of Borderless Gaming's current version? What's with the LLM passes on the loose shader files?

All effect files based on GPL code have their copyright and attributions preserved. Borderless Gaming does not incorporate any copyleft code. Shader files are not linked against by the process. Compilation happens out of process.

As for "why wasn't this disclosed to purchasers": GPLv3 requires that recipients of the covered work receive the license text and copyright notices. It doesn't require upfront disclosure to purchasers that GPL-licensed components exist. The attributions are preserved in the files themselves and the source code is available.

As for "LLM passes on the loose shader files": not sure what you're referring to. All effects have human-friendly descriptions and detailed parameters because they're rendered in the UI so people know what each one does. BGFX isn't MagpieFX.

Per GPLv3 Section 5:

A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.

The shader files are separate works distributed alongside the application. They are not compiled into the binary, not linked, and not combined to form a larger program. They're data files read at runtime. This is the textbook definition of an aggregate.

On the flip side, the Vulkan backend will be open source because it directly links against GPLv3 code. We’re aware of our obligations for open source and will comply accordingly.

So no, the source code for Borderless Gaming will not be released. The codebase does not incorporate any copyleft code or prior art, contrary to what's been claimed.

That said, I've already stated I'll remove the MagPie compatibility layer that allows effects in this repo to be loaded, so further probing is moot.

[MikuLover1983]

All effects have human-friendly descriptions and detailed parameters because they're rendered in the UI so people know what each one does. BGFX isn't MagpieFX.

No one writes comments on every other line of shader code (original source of the shaders didn't do this either - as they were very obviously taken from the Magpie repoistory). Especially for simple functions. Seeing the current actions and unwillingess to be faithful to the copyright, I'll be writing an email and report over to Valve to have them mark the software as using AI generation.

The shader files are separate works distributed alongside the application.

Making them a part of your software/program. Regardless of them being shipped in the executable or not.

GPLv3 requires that recipients of the covered work receive the license text and copyright notices. It doesn't require upfront disclosure to purchasers that GPL-licensed components exist. The attributions are preserved in the files themselves and the source code is available.

Doesn't matter. Should have still been disclosed to both the users and purchasers.

We’re aware of our obligations for open source and will comply accordingly.

You're not as you're arguing against the current license that you're pulling works from and yet still misunderstanding the general concept. Shaders should be immediately removed ASAP or rebuilt manually (this takes way more than a day).

So no, the source code for Borderless Gaming will not be released. The codebase does not incorporate any copyleft code or prior art, contrary to what's been claimed.

It does. You've made copyleft works a part of your package/software/program. The claim of aggregation is weak because the program and the shaders do not exist independently; they form a single functional product. Under GPLv3, if the binary cannot perform its core purpose (upscaling and image processing) without these specific shaders, they are not merely "bundled" together like a collection of random tools. Instead, they are functionally integrated, meaning the binary acts as the engine for the GPL-licensed logic, making the entire package a combined work.

The Magpie developer’s assertion that "not only is the code logic almost identical, but the class names and inheritance structure are exactly the same" points directly to a derivative work. If the binary’s logic replicates the structure, sequence, or specific algorithms of Magpie, it is legally derived from the original source. Compiling code into a binary does not strip away the GPL obligations; if the underlying logic is a derivative of Magpie, the binary itself must be licensed under the GPLv3 and its source code made available.

That said, I've already stated I'll remove the MagPie compatibility layer that allows effects in this repo to be loaded, so further probing is moot.

Hoping to see that done. If not, I hope that contributing members will end up filing legal corrispondence in order to have such works removed forcefully.

[andrewmd5]

All effects have human-friendly descriptions and detailed parameters because they're rendered in the UI so people know what each one does. BGFX isn't MagpieFX.

No one writes comments on every other line of shader code (original source of the shaders didn't do this either - as they were very obviously taken from the Magpie repoistory). Especially for simple functions. Seeing the current actions and unwillingess to be faithful to the copyright, I'll be writing an email and report over to Valve to have them mark the software as using AI generation.

The shader files are separate works distributed alongside the application.

Making them a part of your software/program. Regardless of them being shipped in the executable or not.

GPLv3 requires that recipients of the covered work receive the license text and copyright notices. It doesn't require upfront disclosure to purchasers that GPL-licensed components exist. The attributions are preserved in the files themselves and the source code is available.

Doesn't matter. Should have still been disclosed to both the users and purchasers.

We’re aware of our obligations for open source and will comply accordingly.

You're not as you're arguing against the current license that you're pulling works from and yet still misunderstanding the general concept. Shaders should be immediately removed ASAP or rebuilt manually (this takes way more than a day).

So no, the source code for Borderless Gaming will not be released. The codebase does not incorporate any copyleft code or prior art, contrary to what's been claimed.

It does. You've made copyleft works a part of your package/software/program. The claim of aggregation is weak because the program and the shaders do not exist independently; they form a single functional product. Under GPLv3, if the binary cannot perform its core purpose (upscaling and image processing) without these specific shaders, they are not merely "bundled" together like a collection of random tools. Instead, they are functionally integrated, meaning the binary acts as the engine for the GPL-licensed logic, making the entire package a combined work.

The Magpie developer’s assertion that "not only is the code logic almost identical, but the class names and inheritance structure are exactly the same" points directly to a derivative work. If the binary’s logic replicates the structure, sequence, or specific algorithms of Magpie, it is legally derived from the original source. Compiling code into a binary does not strip away the GPL obligations; if the underlying logic is a derivative of Magpie, the binary itself must be licensed under the GPLv3 and its source code made available.

That said, I've already stated I'll remove the MagPie compatibility layer that allows effects in this repo to be loaded, so further probing is moot.

Hoping to see that done. If not, I hope that contributing members will end up filing legal corrispondence in order to have such works removed forcefully.

I'm going to be direct here.

On comments in shader code: These aren't "LLM passes." The descriptions exist because BGFX renders effect parameters in the UI. Users need to understand what each slider does. This is basic UX. If you think documenting shader parameters is evidence of AI generation, I don't know what to tell you. Report it to Valve. I'll happily explain to them why my shader files have comments. Not that it matters, because they allow AI tools for localization now.

On "making them part of your software": You're conflating distribution with derivation. GPLv3 Section 5 is explicit:

A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.

Shipping files alongside an executable is not the same as incorporating them into the program. The shaders are loaded at runtime as data. They are not linked. They are not compiled into the binary. This is the definition of an aggregate. You can disagree with the GPL's terms, but you can't rewrite them.

On disclosure: "Doesn't matter. Should have still been disclosed." That's not an argument. GPLv3 Section 4 specifies exactly what's required: preserve copyright notices, keep the license intact, provide recipients with the license text. There is no clause requiring a Steam store banner or purchase-time disclosure. The attributions are in the files. The license is preserved. That is compliance. Your opinion that more should be required doesn't change what the license actually says.

On "you're not aware of your obligations": I've cited specific sections of the license. You've responded with "doesn't matter" and assertions about what you think the license means. That's not a rebuttal.

On "the program cannot perform its core purpose without the shaders": Borderless Gaming's core purpose is making windowed games borderless. It's been doing that since 2013. Effects are an optional feature added recently. The application runs fine without any shaders loaded. This isn't a shader engine that happens to have a window manager attached. It's a window manager with optional post-processing. Your "functional integration" argument falls apart when the functionality is optional.

On "class names and inheritance structure are exactly the same": I've already addressed this. The author made a claim. I provided the actual source code showing its C# using DirectN and CsWin32, ported from Rainway, which I also wrote. Identical class names like DesktopDuplicationFrameSource exist because we're both using an API literally called Desktop Duplication. Microsoft's own sample code uses the same patterns. I linked it. The author's assertion isn't evidence. The code I showed is.

On "if the underlying logic is a derivative": It isn't. Two programs calling the same Windows API will have similar structure because the API dictates the structure. You get a monitor handle, find the DXGI output, call DuplicateOutput, acquire frames, check dirty rects (MagPie does not), copy the region. That's not Magpie's invention. That's the API. Similar constructs in OOP code wrapping Windows APIs isn't evidence of derivation. It's just how everyone writes this code.

And even if by providing a compatible interface to Magpie shaders, Google v. Oracle established that's not derivation either. But that's not even the claim here. The claim is that similar class names prove copying. They don't.

On "shaders should be removed ASAP or rebuilt manually": The shaders are already being deprecated. The Vulkan and DX12 backends release Feb 5th and the entire format moves to Slang. I've already said the MagPie compatibility layer is being removed. You're demanding something that's already happening.

@Blinue you may email me anytime if you have further questions or concerns. I will be muting notifications as this discussion is no longer productive.

[PancakeTAS]

Curiosity killed the cat..

Take a look at the MaskedCursorPS.hlsl shader as a string in the binary:

^ Notice identical variable names and the noperspective attribute, which was added as part of the latest commit on the file.
^^ Also notice constants 255.001953f being 1:1 identical, although this could technically just be a coincidence (I don't quite understand the source of this constant from the linked stackoverflow post)

I'm able to find all shaders except the ImGui shaders and the compute shader DuplicateFrameCS.hlsl.

Very interesting are these shaders here, which corresponds to SimpleVS and SimplePS:

^ Despite being simple shaders, the variable names as well as the noperspective attribute have been copied (despite from my understanding,noperspective having absolutely zero effect in this context).

What I find curious about these shaders is the comments which speak of alpha blending and cursor rendering, when the shaders themselves are so primitive, that they are not strictly tied to cursor rendering. Ontop of this, the shader is so primitive, no human would ever even leave a comment on the shader. To me this is very clear LLM usage, regardless of what AndrewMD5 claims it is.

In conclusion, all of the shaders from Magpie.Core have been taken and "linked" into the application, contrary to what AndrewMD5 is claiming is "perfectly valid GPLv3 compliance" (which it's not anyways). The shaders may be extremely simple and there's no need to fret over that fact by itself, but I believe this shows that there is overall more than just a "Magpie compatibility layer" here (I'm hinting at my original hunch being correct: That the entirety of Borderless Gaming is an LLM-written clone of Magpie).

---

It is extremely disheartening to see AndrewMD5 lie about not taking code and constantly trying to play it down by being a "compatibility layer", when he himself has inadvertently provided proof that it is not (as Blinue stated, the C# class was a clear derivative of Magpie to them; and I believe the class names I found in the binary are more than just happy coincidences and API naming).

AndrewMD5 claims they have sold a company to Microsoft and brings it up very frequently too.. Is license violation, blatant copying of source code and doubling/tripling down on it not being LLM-written or stolen and then ultimately misleading or outright scamming poor consumers who are unaware of this copy the kind of morality we should expect from such a person?

My personal next action would be issuing a takedown request to Valve with this information. The copyright holders are the contributors and maintainers of this awesome project. I do not support immorally or illegally taking money from poor consumers and I really, really wish for the Steam page to be taken down <3