Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Server SKUs run most Windows software, and the exceptions are the part nobody warns you about. The failures cluster in four places: binaries that import a desktop-only DLL, installers that require Desktop Experience, code paths that need AVX-512 or a GPU driver, and anything that tries to draw a window from a service. Plan on losing 10–20% of a typical desktop app portfolio, and budget time to find out which fifth.
A Windows VPS almost always ships Server 2019 or 2022 without Desktop Experience. That image has no Explorer shell, no Media Foundation stack in its desktop form, no Windows Store, and a different set of default services. Console apps and most .NET workloads do not notice. GUI-heavy line-of-business tools notice immediately.
The rule of thumb that saves the most time: if the vendor’s system requirements mention “Windows 10 or later” rather than “Windows Server”, test it before you commit. Our Windows VPS hosting comparison lists which plans offer Server with Desktop Experience, because that single option changes the compatibility outcome for half the apps in this article.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Server SKUs run most Windows software, and the exceptions are the part nobody warns you about. The failures cluster in four places: binaries that import a desktop-only DLL, installers that require Desktop Experience, code paths that need AVX-512 or a GPU driver, and anything that tries to draw a window from a service. Plan on losing 10–20% of a typical desktop app portfolio, and budget time to find out which fifth.
A Windows VPS almost always ships Server 2019 or 2022 without Desktop Experience. That image has no Explorer shell, no Media Foundation stack in its desktop form, no Windows Store, and a different set of default services. Console apps and most .NET workloads do not notice. GUI-heavy line-of-business tools notice immediately.
The rule of thumb that saves the most time: if the vendor’s system requirements mention “Windows 10 or later” rather than “Windows Server”, test it before you commit. Our Windows VPS hosting comparison lists which plans offer Server with Desktop Experience, because that single option changes the compatibility outcome for half the apps in this article.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Server SKUs run most Windows software, and the exceptions are the part nobody warns you about. The failures cluster in four places: binaries that import a desktop-only DLL, installers that require Desktop Experience, code paths that need AVX-512 or a GPU driver, and anything that tries to draw a window from a service. Plan on losing 10–20% of a typical desktop app portfolio, and budget time to find out which fifth.
A Windows VPS almost always ships Server 2019 or 2022 without Desktop Experience. That image has no Explorer shell, no Media Foundation stack in its desktop form, no Windows Store, and a different set of default services. Console apps and most .NET workloads do not notice. GUI-heavy line-of-business tools notice immediately.
The rule of thumb that saves the most time: if the vendor’s system requirements mention “Windows 10 or later” rather than “Windows Server”, test it before you commit. Our Windows VPS hosting comparison lists which plans offer Server with Desktop Experience, because that single option changes the compatibility outcome for half the apps in this article.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Server SKUs run most Windows software, and the exceptions are the part nobody warns you about. The failures cluster in four places: binaries that import a desktop-only DLL, installers that require Desktop Experience, code paths that need AVX-512 or a GPU driver, and anything that tries to draw a window from a service. Plan on losing 10–20% of a typical desktop app portfolio, and budget time to find out which fifth.
A Windows VPS almost always ships Server 2019 or 2022 without Desktop Experience. That image has no Explorer shell, no Media Foundation stack in its desktop form, no Windows Store, and a different set of default services. Console apps and most .NET workloads do not notice. GUI-heavy line-of-business tools notice immediately.
The rule of thumb that saves the most time: if the vendor’s system requirements mention “Windows 10 or later” rather than “Windows Server”, test it before you commit. Our Windows VPS hosting comparison lists which plans offer Server with Desktop Experience, because that single option changes the compatibility outcome for half the apps in this article.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Server SKUs run most Windows software, and the exceptions are the part nobody warns you about. The failures cluster in four places: binaries that import a desktop-only DLL, installers that require Desktop Experience, code paths that need AVX-512 or a GPU driver, and anything that tries to draw a window from a service. Plan on losing 10–20% of a typical desktop app portfolio, and budget time to find out which fifth.
A Windows VPS almost always ships Server 2019 or 2022 without Desktop Experience. That image has no Explorer shell, no Media Foundation stack in its desktop form, no Windows Store, and a different set of default services. Console apps and most .NET workloads do not notice. GUI-heavy line-of-business tools notice immediately.
The rule of thumb that saves the most time: if the vendor’s system requirements mention “Windows 10 or later” rather than “Windows Server”, test it before you commit. Our Windows VPS hosting comparison lists which plans offer Server with Desktop Experience, because that single option changes the compatibility outcome for half the apps in this article.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Server SKUs run most Windows software, and the exceptions are the part nobody warns you about. The failures cluster in four places: binaries that import a desktop-only DLL, installers that require Desktop Experience, code paths that need AVX-512 or a GPU driver, and anything that tries to draw a window from a service. Plan on losing 10–20% of a typical desktop app portfolio, and budget time to find out which fifth.
A Windows VPS almost always ships Server 2019 or 2022 without Desktop Experience. That image has no Explorer shell, no Media Foundation stack in its desktop form, no Windows Store, and a different set of default services. Console apps and most .NET workloads do not notice. GUI-heavy line-of-business tools notice immediately.
The rule of thumb that saves the most time: if the vendor’s system requirements mention “Windows 10 or later” rather than “Windows Server”, test it before you commit. Our Windows VPS hosting comparison lists which plans offer Server with Desktop Experience, because that single option changes the compatibility outcome for half the apps in this article.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Server SKUs run most Windows software, and the exceptions are the part nobody warns you about. The failures cluster in four places: binaries that import a desktop-only DLL, installers that require Desktop Experience, code paths that need AVX-512 or a GPU driver, and anything that tries to draw a window from a service. Plan on losing 10–20% of a typical desktop app portfolio, and budget time to find out which fifth.
A Windows VPS almost always ships Server 2019 or 2022 without Desktop Experience. That image has no Explorer shell, no Media Foundation stack in its desktop form, no Windows Store, and a different set of default services. Console apps and most .NET workloads do not notice. GUI-heavy line-of-business tools notice immediately.
The rule of thumb that saves the most time: if the vendor’s system requirements mention “Windows 10 or later” rather than “Windows Server”, test it before you commit. Our Windows VPS hosting comparison lists which plans offer Server with Desktop Experience, because that single option changes the compatibility outcome for half the apps in this article.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Server SKUs run most Windows software, and the exceptions are the part nobody warns you about. The failures cluster in four places: binaries that import a desktop-only DLL, installers that require Desktop Experience, code paths that need AVX-512 or a GPU driver, and anything that tries to draw a window from a service. Plan on losing 10–20% of a typical desktop app portfolio, and budget time to find out which fifth.
A Windows VPS almost always ships Server 2019 or 2022 without Desktop Experience. That image has no Explorer shell, no Media Foundation stack in its desktop form, no Windows Store, and a different set of default services. Console apps and most .NET workloads do not notice. GUI-heavy line-of-business tools notice immediately.
The rule of thumb that saves the most time: if the vendor’s system requirements mention “Windows 10 or later” rather than “Windows Server”, test it before you commit. Our Windows VPS hosting comparison lists which plans offer Server with Desktop Experience, because that single option changes the compatibility outcome for half the apps in this article.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Server SKUs run most Windows software, and the exceptions are the part nobody warns you about. The failures cluster in four places: binaries that import a desktop-only DLL, installers that require Desktop Experience, code paths that need AVX-512 or a GPU driver, and anything that tries to draw a window from a service. Plan on losing 10–20% of a typical desktop app portfolio, and budget time to find out which fifth.
A Windows VPS almost always ships Server 2019 or 2022 without Desktop Experience. That image has no Explorer shell, no Media Foundation stack in its desktop form, no Windows Store, and a different set of default services. Console apps and most .NET workloads do not notice. GUI-heavy line-of-business tools notice immediately.
The rule of thumb that saves the most time: if the vendor’s system requirements mention “Windows 10 or later” rather than “Windows Server”, test it before you commit. Our Windows VPS hosting comparison lists which plans offer Server with Desktop Experience, because that single option changes the compatibility outcome for half the apps in this article.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Server SKUs run most Windows software, and the exceptions are the part nobody warns you about. The failures cluster in four places: binaries that import a desktop-only DLL, installers that require Desktop Experience, code paths that need AVX-512 or a GPU driver, and anything that tries to draw a window from a service. Plan on losing 10–20% of a typical desktop app portfolio, and budget time to find out which fifth.
A Windows VPS almost always ships Server 2019 or 2022 without Desktop Experience. That image has no Explorer shell, no Media Foundation stack in its desktop form, no Windows Store, and a different set of default services. Console apps and most .NET workloads do not notice. GUI-heavy line-of-business tools notice immediately.
The rule of thumb that saves the most time: if the vendor’s system requirements mention “Windows 10 or later” rather than “Windows Server”, test it before you commit. Our Windows VPS hosting comparison lists which plans offer Server with Desktop Experience, because that single option changes the compatibility outcome for half the apps in this article.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.
Server SKUs run most Windows software, and the exceptions are the part nobody warns you about. The failures cluster in four places: binaries that import a desktop-only DLL, installers that require Desktop Experience, code paths that need AVX-512 or a GPU driver, and anything that tries to draw a window from a service. Plan on losing 10–20% of a typical desktop app portfolio, and budget time to find out which fifth.
A Windows VPS almost always ships Server 2019 or 2022 without Desktop Experience. That image has no Explorer shell, no Media Foundation stack in its desktop form, no Windows Store, and a different set of default services. Console apps and most .NET workloads do not notice. GUI-heavy line-of-business tools notice immediately.
The rule of thumb that saves the most time: if the vendor’s system requirements mention “Windows 10 or later” rather than “Windows Server”, test it before you commit. Our Windows VPS hosting comparison lists which plans offer Server with Desktop Experience, because that single option changes the compatibility outcome for half the apps in this article.
What runs cleanly with no changes
Native console tools, .NET Framework 4.8 and .NET 6+ services, IIS-hosted ASP.NET, SQL Server, background workers, scheduled tasks and anything that speaks a socket run exactly as they do on a desktop. So do most Java and Node workloads, because their runtimes do not care about the shell.
Legacy VB6 and Delphi console binaries usually run too, provided their OCX dependencies are registered with the correct bitness. The trap is the 32-bit control that expects a 32-bit message pump — it installs fine, then throws an automation error the first time it tries to create a window.
Session 0: why GUI apps fail as services
Since Vista, services run in session 0, which has no interactive desktop and no window station a user can see. An app that calls CreateWindowEx from a service gets a window on an invisible desktop. It does not crash; it hangs waiting for input that will never arrive, or throws on the first screen-scrape.
The supported fix is a scheduled task running as the logged-on user with “Run only when user is logged on”, or an RDP session kept alive with tscon to the console. Both are fragile: a reboot or an expired session kills the app. Screen automation tools that rely on pixel coordinates are especially brittle here, because the session resolution changes on reconnect.
| App class | Server Core | Server + Desktop Experience | Notes |
|---|---|---|---|
| .NET console/service | Runs | Runs | No shell dependency |
| IIS / ASP.NET / SQL | Runs | Runs | Core is the target platform |
| WinForms / WPF LOB tool | Fails | Runs | Needs a desktop, not a service |
| ClickOnce / MSI with shell UI | Fails | Usually runs | Silent install flags help |
| Browser automation | Runs headless | Runs | Needs ≥2 vCPU, 4 GB |
| AVX-512 compute | Depends on CPU flag | Depends on CPU flag | vCPU model varies by host |
| GPU / CUDA workload | No | No | Requires passthrough or vGPU |
| Driver-level hooking (AV, filter) | Rarely | Rarely | Kernel drivers often unsigned for nested virt |
CPU feature and GPU limits
Your vCPU is a masked view of the host’s physical core. Some hosts expose AVX2 but not AVX-512, and a few mask both for live-migration safety. Software that hard-requires AVX-512 throws 0xC000001D (illegal instruction) at startup — the same binary works on your laptop and dies on the VPS.
Check with coreinfo -f or a short CPU-Z run before you blame the app. GPUs are simpler: without passthrough or a virtual GPU SKU, there is no 3D acceleration and no CUDA device. Remoting into a server that has no GPU means software rendering, which is usually fine for a form and hopeless for a CAD viewer.
Licensing: per-user versus per-device
Hosting a desktop app for multiple people on one VPS hits Remote Desktop Services licensing, not just Windows Server licensing. Per-user RDS CALs are the practical choice when staff connect from changing devices; per-device CALs suit fixed workstations. Either way, the app vendor may separately demand a per-seat licence — nesting the two is where audits get expensive.
Two concurrent sessions is the built-in administration allowance; three is a licence conversation. If the plan is “five staff share one box”, you are buying RDS CALs and a Session Host role, and the VPS spec needs to reflect it: roughly 2 GB RAM per light session and 4–6 GB for anything with a browser.
Testing compatibility in an hour
Get-ComputerInfo | Select WindowsProductName, OsHardwareAbstractionLayer
Get-WindowsFeature | Where Installed | Select Name
# does it need a desktop?
Get-Item C:\Windows\explorer.exe | Select Length
# silent-install first
msiexec /i app.msi /qn /l*v C:\temp\app.logInstall with a verbose log on a fresh snapshot and read the last 40 lines of the log, not the first error dialog. If the installer fails on a missing component, check whether that component is a Desktop Experience feature via Install-WindowsFeature Server-Media-Foundation,Desktop-Experience — on hosts that offer it, that single command converts most failures into successes.
When hosting the app is the wrong answer
If the app needs a GPU, a kernel driver, or exclusive access to a serial device, a VPS is the wrong shape. The alternatives are a dedicated server with passthrough, a desktop-as-a-service SKU that carries the right licensing, or splitting the workload so only the headless part runs on the server and the client keeps the UI.
Most teams that fail here failed in procurement rather than engineering: they bought a 2 vCPU / 4 GB box and discovered on day one that the app needs Desktop Experience plus 8 GB. Snapshot before installing, keep the baseline image, and check what each Windows VPS plan includes for Desktop Experience and RDS before you rebuild the second time.