[FEAT] Option to compile PowerShell Core code if user has the .NET SDK

[God-damnit-all]

I think it would be amazing if this project could support creating binaries using the .NET SDK in the same manner that dotnet-script does: https://github.com/dotnet-script/dotnet-script

Not only would we get the much-improved PowerShell Core edition updates and the better underlying framework, but it could potentially allow for creating Linux/Mac binaries as well.

[MScholtes]

Hello @God-damnit-all,

I can understand the idea and need of a .Net Core version of PS2EXE, but since the compiler API has changed comletely this would mean a rewrite of PS2EXE.
I do not intend to do this, this is a job for a new project. Maybe someone will take on this challenge.

Greetings

Markus

[FabienTschanz]

I'm currently working on the compilation to PowerShell Core and I already succeeded in doing so. At the same time, I "beautified" the module to implement some standards in variable naming etc.

@MScholtes If it's ok with you, I'll open a PR once I'm done with it (will still take some good time to complete, I currently only have the most basic build support without icons, manifest etc.). If you're interested, let me know.

Edit: If you have any kind of test suite with which you test the module and compilation, I'd love to have that to make sure everything works. There are a myriad of options available and I'm certainly not able to implement them all without overlooking at least one thing.

[MScholtes]

Hello @FabienTschanz,

great that you made PS2EXE compile using .Net Core.

However, as I mentioned above I am not interested in adding this functionality to the existing project. I see way too much maintenance tasks and compatibility issues between the two Powershell versions and C# versions when integrated in one tool - I have this already in my partner project PS2EXE-GUI (see here https://github.com/MScholtes/TechNet-Gallery) with .Net 3.5 and .Net 4.x compatibility.
It's a better way if you create a new project of your own with a .Net Core version, you might call it PS2EXE.Core or similiar. It can be refactored to modern conditions.

The existing code is not pretty, but it has been tested millions of times. As this is very valuable, I have only been making necessary changes for a long time. I have no test suite but a collection of virtual systems with different Windows versions to check compatibility.

Greetings

Markus

[FabienTschanz]

@MScholtes I got you, thank you for the quick reply. Then I'll fork and publish it with a new name. Of course there will be credits and mentions of you and the original creator. If you could send me a bit more information about the Windows systems you have, I'd really appreciate it. For a more direct contact approach, you can reach me on LinkedIn (if you want to).

[MScholtes]

Hello @FabienTschanz,

there's no mystery with the virtual machines. The script based PS2EXE version supported .Net 2 and .Net 3.5, and .Net 4 so I needed (virtual) computers running Windows Vista, 7, 8, 8.1 and 10 to check. In my tests I only compiled and ran the examples and looked if that worked.

But today only Windows 10 and Windows 11 are supported by Microsoft - and Windows 10 will be out in October. There is no need for those test machines anymore.

Greetings

Markus

[FabienTschanz]

@MScholtes Awesome, thank you for the insights, appreciate it!

[FabienTschanz]

@God-damnit-all I just released PS2EXE.Core over on the PowerShell gallery. Source code can be found here: https://github.com/FabienTschanz/PS2EXE.Core

[God-damnit-all]

@God-damnit-all I just released PS2EXE.Core over on the PowerShell gallery. Source code can be found here: https://github.com/FabienTschanz/PS2EXE.Core

Oh damn, awesome, I'll check it out! Thanks!

[MScholtes]

Hello @FabienTschanz,

good work, I successfully compiled a ‘Hello World’ script for testing purposes.
Two notes:

• I am using .Net 8.0 and needed the appropriate version parameters to create a runnable program. Is it possible to determine the .Net and Powershell version und use this as default?
• As a result, I got an executable file that can only be run with many DLLs. Is this supposed to be the case, or is there a ‘single file’ solution?

Greetings
Markus

[FabienTschanz]

@MScholtes Thank you for checking it out. To address your points:

I am using .Net 8.0 and needed the appropriate version parameters to create a runnable program. Is it possible to determine the .Net and Powershell version und use this as default?

I just opened FabienTschanz/PS2EXE.Core#5 where I track the progress of your request. Yes, that is possible and I will implement this behaviour when I have some time.

As a result, I got an executable file that can only be run with many DLLs. Is this supposed to be the case, or is there a ‘single file’ solution?

Yes, this is the default behaviour. You can use -PublishSingleFile, but single file publishing is currently broken and will most likely be fixed with PowerShell 7.6.0 (see PowerShell/PowerShell#13540) for more information. As soon as that is the case, I will update the module to use -PublishSingleFile as the default if it turns out to be working (finally).

Small edit for the second question: The many dlls are because it is a "normal" C# application and not integrated into the operating system as Windows PowerShell was with the .NET framework. The dlls required by PowerShell Core are shipped with the application, whereas the previous code provider didn't need to do that since all required dlls are shipped with Windows itself. I assume that some of the dlls can be omitted, but I don't know which. And if you were to build an application that contains even the PowerShell runtime (using -SelfContained), then the build process generates even more dlls, but that's to be expected.

[necrose99]

Round robbin of find .net or newer compilers dynamically... no matter if .net 12 drops whenever.... Hopefully this might add utility its a rather rough draft...

<#
.SYNOPSIS
Probes the local machine for .NET Framework / .NET (Core+) install state,
locates a usable C# compiler for PS2EXE, and (optionally) self-heals using
Microsoft's channel-based installer instead of a hardcoded zip/version URL.

.DESCRIPTION
The reason "update scripts" that pull a specific zip break every few months
is that they pin a version number or a release-specific URL. Microsoft's
own dotnet-install.ps1 supports -Channel LTS / -Channel STS, which are
maintained aliases that always resolve to whatever build is currently
supported. Pointing your tooling at the channel instead of a version number
means you stop chasing .NET's release cadence by hand.

PS2EXE (MScholtes/PS2EXE) compiles your script via PowerShell's Add-Type,
which in turn needs a C# compiler:
  - Windows PowerShell 5.1 (Desktop edition) -> legacy Framework csc.exe
  - PowerShell 7+ (Core edition)             -> Roslyn compiler shipped
                                                 inside an installed SDK

This script reports what's actually present and whether PS2EXE has what
it needs, rather than assuming a fixed install layout.

.PARAMETER Heal
If set, and no usable compiler is found, installs the latest SDK for the
given channel using the official dotnet-install.ps1 (no hardcoded version).

.PARAMETER HealChannel
Channel to install when -Heal triggers. LTS (default), STS, or latest.

.EXAMPLE
.\Probe-DotNetEnvironment.ps1

.EXAMPLE
.\Probe-DotNetEnvironment.ps1 -Heal -HealChannel STS
#>

[CmdletBinding()]
param(
[switch]$Heal,
[ValidateSet('LTS','STS','latest')]
[string]$HealChannel = 'LTS'
)

function Get-NetFrameworkVersions {
# Reads the NDP registry tree. Handles both legacy (<=4.0, Version property)
# and 4.5+ (Release ID -> friendly name mapping) detection styles.
$results = @()
$ndpPath = 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP'
if (-not (Test-Path $ndpPath)) { return $results }

$releaseMap = @{
    378389='4.5';   378675='4.5.1'; 378758='4.5.1'; 379893='4.5.2'
    393295='4.6';   393297='4.6';   394254='4.6.1'; 394271='4.6.1'
    394802='4.6.2'; 394806='4.6.2'; 460798='4.7';   460805='4.7'
    461308='4.7.1'; 461310='4.7.1'; 461808='4.7.2'; 461814='4.7.2'
    528040='4.8';   528049='4.8';   528372='4.8';   528449='4.8'
    533320='4.8.1'; 533325='4.8.1'
}

Get-ChildItem $ndpPath -Recurse -ErrorAction SilentlyContinue |
    Where-Object { $_.PSChildName -match '^(v|Full|Client)' } |
    ForEach-Object {
        $props = Get-ItemProperty $_.PSPath -ErrorAction SilentlyContinue
        if ($props.Version -or $props.Release) {
            $friendly = if ($props.Release) { $releaseMap[[int]$props.Release] } else { $null }
            $results += [pscustomobject]@{
                Version  = $props.Version
                Release  = $props.Release
                Friendly = $friendly
            }
        }
    }
return $results | Where-Object { $_.Version } | Sort-Object Version -Unique

}

function Get-DotNetSdksAndRuntimes {
$dotnet = Get-Command dotnet.exe -ErrorAction SilentlyContinue
if (-not $dotnet) { return $null }

[pscustomobject]@{
    DotnetPath = $dotnet.Source
    Sdks       = (& dotnet --list-sdks 2>$null)
    Runtimes   = (& dotnet --list-runtimes 2>$null)
}

}

function Find-CscCompiler {
$found = @()

# Legacy .NET Framework compiler (Windows PowerShell 5.1 Add-Type target)
foreach ($p in @(
    "$env:WINDIR\Microsoft.NET\Framework64\v*\csc.exe"
    "$env:WINDIR\Microsoft.NET\Framework\v*\csc.exe"
)) {
    Get-Item $p -ErrorAction SilentlyContinue | ForEach-Object {
        $found += [pscustomobject]@{ Type='Framework (legacy)'; Path=$_.FullName }
    }
}

# Roslyn compiler shipped inside an installed SDK (pwsh 7+ Add-Type target)
$sdkRoot = 'C:\Program Files\dotnet\sdk'
if (Test-Path $sdkRoot) {
    Get-ChildItem $sdkRoot -Directory -ErrorAction SilentlyContinue | ForEach-Object {
        $roslynCsc = Join-Path $_.FullName 'Roslyn\bincore\csc.dll'
        if (Test-Path $roslynCsc) {
            $found += [pscustomobject]@{ Type="Roslyn (SDK $($_.Name))"; Path=$roslynCsc }
        }
    }
}
return $found

}

function Get-PS2EXECompatibility {
$psEdition = $PSVersionTable.PSEdition
$csc = Find-CscCompiler

$usable = $false
if ($psEdition -eq 'Desktop' -and ($csc | Where-Object Type -like 'Framework*')) {
    $usable = $true
} elseif ($psEdition -eq 'Core' -and ($csc | Where-Object Type -like 'Roslyn*')) {
    $usable = $true
}

[pscustomobject]@{
    PSEdition      = $psEdition
    PSVersion      = $PSVersionTable.PSVersion
    CompilersFound = $csc
    PS2EXEReady    = $usable
}

}

function Invoke-SelfHeal {
param([string]$Channel)

Write-Host "No usable compiler found. Self-healing via channel-based installer (-Channel $Channel)..." -ForegroundColor Yellow

$installScript = Join-Path $env:TEMP 'dotnet-install.ps1'
Invoke-WebRequest -Uri 'https://dot.net/v1/dotnet-install.ps1' -OutFile $installScript -UseBasicParsing

# The fix for "busted every few months": never hardcode a version number
# or a release-specific zip URL. -Channel LTS/STS is a Microsoft-maintained
# alias that always resolves to whatever build is currently supported.
& $installScript -Channel $Channel -InstallDir "$env:LOCALAPPDATA\Microsoft\dotnet"

Write-Host "Installed. Open a new shell for PATH changes to take effect." -ForegroundColor Green

}

---- Run the probe ----

Write-Host "`n=== .NET Framework (legacy) ===" -ForegroundColor Cyan
Get-NetFrameworkVersions | Format-Table -AutoSize

Write-Host "`n=== .NET (Core/5+) SDKs & Runtimes ===" -ForegroundColor Cyan
$core = Get-DotNetSdksAndRuntimes
if ($core) {
Write-Host "dotnet.exe: $($core.DotnetPath)"
Write-Host "SDKs:"
$core.Sdks | ForEach-Object { Write-Host " $" }
Write-Host "Runtimes:"
$core.Runtimes | ForEach-Object { Write-Host " $" }
} else {
Write-Host "dotnet.exe not found on PATH." -ForegroundColor Yellow
}

Write-Host "`n=== C# Compiler Discovery (Add-Type / PS2EXE) ===" -ForegroundColor Cyan
$compat = Get-PS2EXECompatibility
$compat.CompilersFound | Format-Table -AutoSize
Write-Host "PowerShell edition: $($compat.PSEdition) Version: $($compat.PSVersion)"
$color = if ($compat.PS2EXEReady) { 'Green' } else { 'Red' }
Write-Host "PS2EXE-ready: $($compat.PS2EXEReady)" -ForegroundColor $color

if (-not $compat.PS2EXEReady -and $Heal) {
Invoke-SelfHeal -Channel $HealChannel
} elseif (-not $compat.PS2EXEReady) {
Write-Host "`nRe-run with -Heal to auto-install the missing SDK via the official channel-based installer." -ForegroundColor Yellow
}

[MScholtes]

Hello @necrose99,

as I have said elsewhere, I am not interested in porting PS2EXE to PowerShell.Core. I believe it is not a particularly good fit (the .NET Framework is native to Windows and is not subject to permanent changes).
I welcome a version of PS2EXE for .NET Core such as the one by Fabien Tschanz, but I do not maintain it.

Greetings

Markus