Convert image to thumbnail

2025-11-17 09:06 UTC gpt-5-1 Open in ChatGPT ↗

You don’t actually need a Windows Service for this (and in most cases you shouldn’t use one).
What you want is:

A small console/WinForms/WPF app (or CLI) that:
- Takes an image path as an argument
- Resizes/crops it to 512×512
- Saves it as WEBP
A context menu entry (“Convert to website thumbnail”) that calls that app and passes the selected file path.

I’ll walk you through a clean C# solution.

1. Overall architecture

Project 1: Converter app (C#, .NET 6+ console app)
- Input: file path (from command-line args)
- Output: <original-name>_thumb.webp in the same folder (or wherever you like)
Context menu integration via registry:
- Add a key under HKEY_CLASSES_ROOT\SystemFileAssociations\.jpg\shell\... etc.
- Command: "C:\Path\To\ConvertThumb.exe" "%1"

You could also create a Windows service that watches a queue or folder, but that’s unnecessary overhead unless you have heavy or async workloads.

2. C# converter app (512×512 WEBP)

You have a few choices for generating WEBP. The easiest modern way is to use ImageSharp + ImageSharp.WebP NuGet packages or SkiaSharp. I’ll show an example using SixLabors.ImageSharp because it’s pure managed code and easy to deploy.

2.1 Create the project

In a terminal:

dotnet new console -n ImageToWebpThumb
cd ImageToWebpThumb

dotnet add package SixLabors.ImageSharp
dotnet add package SixLabors.ImageSharp.Webp

2.2 Program.cs example

This program:

Takes one argument (image path)
Loads the image
Creates a square 512×512 thumbnail by:
- Cropping to a square (center) then resizing
  or
- Resizing and padding with transparent/white background
  (I’ll implement a center crop so it fills the square nicely)
Saves as originalname_thumb.webp in the same folder.

using System;
using System.IO;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats.Webp;
using SixLabors.ImageSharp.Processing;

class Program
{
    static int Main(string[] args)
    {
        if (args.Length == 0)
        {
            Console.WriteLine("Usage: ImageToWebpThumb.exe <image-path>");
            return 1;
        }

        var inputPath = args[0];

        if (!File.Exists(inputPath))
        {
            Console.WriteLine($"File not found: {inputPath}");
            return 1;
        }

        try
        {
            CreateThumbnail(inputPath);
            return 0;
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error while converting image:");
            Console.WriteLine(ex);
            return 1;
        }
    }

    private static void CreateThumbnail(string inputPath)
    {
        const int size = 512;

        using var image = Image.Load(inputPath);

        // 1. Crop to square (center)
        int minSide = Math.Min(image.Width, image.Height);
        int x = (image.Width - minSide) / 2;
        int y = (image.Height - minSide) / 2;

        image.Mutate(ctx =>
        {
            ctx.Crop(new Rectangle(x, y, minSide, minSide));
            ctx.Resize(new ResizeOptions
            {
                Size = new Size(size, size),
                Mode = ResizeMode.Stretch
            });
        });

        // 2. Build output path
        var dir = Path.GetDirectoryName(inputPath)!;
        var filenameWithoutExt = Path.GetFileNameWithoutExtension(inputPath);
        var outputPath = Path.Combine(dir, filenameWithoutExt + "_thumb.webp");

        // 3. Save as WEBP
        var encoder = new WebpEncoder
        {
            Quality = 80 // adjust as needed (0–100)
        };

        image.Save(outputPath, encoder);

        Console.WriteLine($"Thumbnail created: {outputPath}");
    }
}

Build it:

dotnet publish -c Release -r win-x64 --self-contained false

You’ll get an EXE under bin/Release/netX.X/win-x64/publish/ImageToWebpThumb.exe.
Pick that path for the next step.

We’ll make Windows call that EXE when you right-click an image file.

You can do this in a .reg file or via a small installer. Let’s do the simple .reg example.

3.1 Decide which file types

Common image extensions: .jpg, .jpeg, .png, .gif, .bmp, .tif, .tiff, .webp etc.

You can:

Either register on each extension, or
Use SystemFileAssociations\image (Windows 10/11) to cover “image” type generically.

I’ll show both; choose what you like.

Option A: Generic for all images

Create a file AddImageThumbnailContext.reg with this content
(replace C:\\Path\\To\\ImageToWebpThumb.exe with your actual path, double backslashes required):

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\SystemFileAssociations\image\shell\ConvertToWebsiteThumbnail]
@="Convert to website thumbnail"
"Icon"="C:\\Path\\To\\ImageToWebpThumb.exe"

[HKEY_CLASSES_ROOT\SystemFileAssociations\image\shell\ConvertToWebsiteThumbnail\command]
@="\"C:\\Path\\To\\ImageToWebpThumb.exe\" \"%1\""

Double-click the .reg file and accept the changes.

Now when you right-click any image-type file you should see “Convert to website thumbnail”.

Option B: Specific extensions

If you prefer explicit control (for example only JPG/PNG):

Windows Registry Editor Version 5.00

; JPG
[HKEY_CLASSES_ROOT\SystemFileAssociations\.jpg\shell\ConvertToWebsiteThumbnail]
@="Convert to website thumbnail"
"Icon"="C:\\Path\\To\\ImageToWebpThumb.exe"

[HKEY_CLASSES_ROOT\SystemFileAssociations\.jpg\shell\ConvertToWebsiteThumbnail\command]
@="\"C:\\Path\\To\\ImageToWebpThumb.exe\" \"%1\""

; PNG
[HKEY_CLASSES_ROOT\SystemFileAssociations\.png\shell\ConvertToWebsiteThumbnail]
@="Convert to website thumbnail"
"Icon"="C:\\Path\\To\\ImageToWebpThumb.exe"

[HKEY_CLASSES_ROOT\SystemFileAssociations\.png\shell\ConvertToWebsiteThumbnail\command]
@="\"C:\\Path\\To\\ImageToWebpThumb.exe\" \"%1\""

Add more blocks for other extensions if needed.

4. Optional: Make it behave more “service-like”

If you really want a “service-style” experience:

Keep the simple EXE as is.
You can:
- Log to a file or Windows Event Log.
- Show a small toast notification when done (via a helper library or PowerShell).
But I’d still avoid an actual Windows Service unless you’re processing in the background without user interaction.

5. Variations / Enhancements

Some ideas you can add later:

Overwrite original instead of creating _thumb.webp:
- Just save to Path.ChangeExtension(inputPath, ".webp") (and maybe back up original).
Transparent padding instead of crop:
- Resize longest edge to 512, pad the rest with transparent color.
Batch mode:
- Accept multiple file paths as args (args array) and loop.
Custom output folder:
- e.g., always store in Thumbnails subfolder.

If you tell me:

Whether you want crop or pad,
And if you want to overwrite or create a new file,

I can tweak the code to exactly match your preferred behavior.

Yes – there are open-source neural nets that do exactly “pick the best crop for a given aspect ratio”, including 1:1 squares.

If you want something that’s both neat and reasonably battle-tested, the best fit right now is:

1. GAIC: Grid-Anchor-based Image Cropping (+ AutoCrop wrapper)

GAIC / Grid-Anchor-based Image Cropping

What it is:
A deep model that scores lots of candidate crops and picks the most aesthetic/content-preserving ones. It was proposed in “Grid Anchor based Image Cropping: A New Benchmark and An Efficient Model” and has an official PyTorch implementation. citeturn1search3turn1search18

Code:

Official PyTorch impl: Grid-Anchor-based-Image-Cropping-Pytorch (MIT licensed) citeturn1search3
There’s also an unofficial implementation GAIC-PyTorch with demo code that directly outputs the best crops for particular aspect ratios (1:1, 4:3, 16:9, or arbitrary). citeturn1search6turn1search21

Why it fits your “best square region” use case:

It takes an aspect ratio as a parameter, so you can ask it specifically for 1:1 crops.
It’s designed for thumbnailing / composition tasks, not just saliency maps.
The model is relatively lightweight and runs in real time on GPU and decently on CPU for single images.

How you’d use it conceptually:

Convert your image to whatever format the repo expects (usually RGB numpy/PyTorch tensor).
Ask GAIC to generate candidate crops for ratio 1:1.
Get back the best scoring bounding box [x_min, y_min, x_max, y_max].
Crop to that region and then resize to 512×512 and encode as WEBP.

If you don’t want to wire GAIC directly, there’s an even more turnkey wrapper:

`auto-crop` toolbox (built on GAIC + face detection)

The auto-crop project is a Python toolbox that:

Uses GAIC under the hood
Optionally uses a face detector to avoid cutting off faces
Lets you request any aspect ratio, including 1:1 citeturn2search0turn2search24

Example from its README:

You create an AutoCropper that loads pre-trained GAIC weights.
Call .crop(img, topK=1, crop_height=1, crop_width=1, ...) and it returns one or more bounding boxes for square crops.

For your Windows context-menu tool you could:

Keep your .NET thumbnail app as-is.
Have it call a small Python script that:
- Runs auto-crop to get the best 1:1 region.
- Prints the bounding box.
Your .NET app then crops/encodes using ImageSharp or similar.

2. Other neural-net croppers (if you need something more specific)

If your images are mostly people:

Human-Centric Image Cropping – official PyTorch implementation from an ECCV 2022 paper focusing on portraits/human-centric scenes. citeturn1search1turn1search7turn1search22
- It’s tuned explicitly to keep humans nicely framed.

For general UGC / modern researchy stuff:

S2CNet – Spatial-Semantic Collaborative Cropping (AAAI 2024) – PyTorch implementation focusing on user-generated content, trying to balance aesthetics and content integrity. citeturn1search12

These are more “research code” than plug-and-play tools, but they are open source with trained models.

3. Pragmatic alternative: Smartcrop (NOT a neural net, but very usable in .NET)

Since you’re building a Windows tool, it’s worth mentioning the practical non-NN option:

smartcrop.js – classic content-aware cropper (edges, skin tones, rule-of-thirds heuristics). citeturn0search0turn0search27
smartcrop.net – .NET Standard port of smartcrop.js, available as a NuGet package (Smartcrop.net), with usage examples and a blog post from the authors. citeturn1search2turn1search17turn1search23

You can literally do:

using (var stream = File.OpenRead(pathToImage))
{
    var crop = new ImageCrop(512, 512).Crop(stream);
    // crop.Area gives you the best 512x512 region
}

Then you resize/encode to WEBP. No Python, no separate model files.

So:

If you strictly want a neural net → GAIC / auto-crop is your best bet.
If you mostly care about a robust, easy integration for a Windows context-menu tool → Smartcrop.net is massively simpler and still gives good “smart thumbnail” crops, even though it isn’t a neural net.

If you tell me whether you’re okay with pulling in Python, or you want to stay 100% in .NET, I can sketch out a minimal pipeline around either auto-crop (GAIC) or Smartcrop.net that outputs your 512×512 WEBP thumbnails.

Here’s a full .NET 8 solution that uses Smartcrop.net to pick the best square region, then crops + resizes with ImageSharp and saves as 512×512 WebP – wired up to a Windows right-click “Convert to website thumbnail” menu.

1. Project setup (Console app, .NET 8)

Create the project:

dotnet new console -n WebsiteThumbnailer -f net8.0
cd WebsiteThumbnailer

Add NuGet packages:

dotnet add package Smartcrop.net --version 1.0.4
dotnet add package SixLabors.ImageSharp --version 3.1.12

Smartcrop.net is a .NET Standard port of smartcrop.js, and works on modern .NET, using SkiaSharp internally.citeturn0view0turn0search1 ImageSharp 3.x supports WebP out of the box.citeturn1view0turn0search6

Replace WebsiteThumbnailer.csproj with:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>

    <!-- Optional: good defaults for a fast, deployable tool -->
    <PublishSingleFile>true</PublishSingleFile>
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
    <TrimMode>link</TrimMode>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.12" />
    <PackageReference Include="Smartcrop.net" Version="1.0.4" />
  </ItemGroup>
</Project>

2. SmartCrop + ImageSharp implementation

Replace Program.cs with this:

using System;
using System.IO;
using Smartcrop;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;
using SixLabors.ImageSharp.Formats.Webp;

const int ThumbSize = 512;

if (args.Length < 1)
{
    Console.Error.WriteLine("Usage: WebsiteThumbnailer <imagePath>");
    return;
}

var inputPath = args[0];

if (!File.Exists(inputPath))
{
    Console.Error.WriteLine($"File not found: {inputPath}");
    return;
}

try
{
    // Where to save the thumbnail: same folder, name + _thumb.webp
    var directory = Path.GetDirectoryName(inputPath) ?? "";
    var baseName = Path.GetFileNameWithoutExtension(inputPath);
    var outputPath = Path.Combine(directory, baseName + "_thumb.webp");

    Console.WriteLine($"Input : {inputPath}");
    Console.WriteLine($"Output: {outputPath}");

    // 1) Ask Smartcrop.net for the best square crop region (512x512)
    //    It just needs a stream to analyze; it doesn't modify the file.
    Console.WriteLine("Running SmartCrop...");
    using var analysisStream = File.OpenRead(inputPath);

    var cropper = new ImageCrop(ThumbSize, ThumbSize);
    var result = cropper.Crop(analysisStream);

    if (result?.Area == null)
    {
        Console.Error.WriteLine("SmartCrop did not return a crop area; falling back to full image.");
    }

    // 2) Load image with ImageSharp
    using Image<Rgba32> image = Image.Load<Rgba32>(inputPath);

    // 3) Build a rectangle for ImageSharp from Smartcrop’s area
    //    Smartcrop Area is typically with X/Y/Width/Height (float or int).
    SixLabors.ImageSharp.Rectangle cropRect;

    if (result?.Area != null)
    {
        // Defensive clamping, in case SmartCrop returns a slightly out-of-bounds area
        int x = Math.Max(0, (int)Math.Floor(result.Area.X));
        int y = Math.Max(0, (int)Math.Floor(result.Area.Y));
        int w = (int)Math.Ceiling(result.Area.Width);
        int h = (int)Math.Ceiling(result.Area.Height);

        if (w <= 0 || h <= 0)
        {
            // Fallback: center-crop the largest square
            Console.Error.WriteLine("SmartCrop area had non-positive size; using center square instead.");
            cropRect = BuildCenterSquare(image.Width, image.Height);
        }
        else
        {
            // Clamp to image bounds
            if (x + w > image.Width) w = image.Width - x;
            if (y + h > image.Height) h = image.Height - y;

            cropRect = new SixLabors.ImageSharp.Rectangle(x, y, w, h);
        }
    }
    else
    {
        // Fallback: center square
        cropRect = BuildCenterSquare(image.Width, image.Height);
    }

    Console.WriteLine($"Crop area: X={cropRect.X}, Y={cropRect.Y}, W={cropRect.Width}, H={cropRect.Height}");

    // 4) Crop to that region, then resize exactly to 512x512
    image.Mutate(ctx =>
    {
        ctx.Crop(cropRect)
           .Resize(new Size(ThumbSize, ThumbSize));
    });

    // 5) Save as WebP
    var encoder = new WebpEncoder
    {
        Quality = 80 // adjust if you want smaller/larger files
    };

    image.Save(outputPath, encoder);

    Console.WriteLine("Done.");
}
catch (Exception ex)
{
    Console.Error.WriteLine("Error while converting image:");
    Console.Error.WriteLine(ex.ToString());
}

// Helper: build a centered square region inside the image
static SixLabors.ImageSharp.Rectangle BuildCenterSquare(int width, int height)
{
    int side = Math.Min(width, height);
    int x = (width - side) / 2;
    int y = (height - side) / 2;
    return new SixLabors.ImageSharp.Rectangle(x, y, side, side);
}

What this does:

Smartcrop.net analyzes the image stream and returns result.Area = “best crop” region for a 512×512 square.citeturn0search0turn0search1
ImageSharp loads the file, crops to that rectangle, resizes to 512×512, then encodes as WebP using WebpEncoder.citeturn1view0turn0search5
Output file name: originalname_thumb.webp in the same folder.

3. Build & publish

From the project folder:

dotnet publish -c Release -r win-x64

You’ll get something like:

bin\Release\net8.0\win-x64\publish\WebsiteThumbnailer.exe

Copy that somewhere stable, e.g.:

C:\Program Files\WebsiteThumbnailer\WebsiteThumbnailer.exe

Create a file called AddWebsiteThumbnailContextMenu.reg with this content
(adjust the Program Files path if you chose a different location):

Windows Registry Editor Version 5.00

; JPG
[HKEY_CLASSES_ROOT\SystemFileAssociations\.jpg\shell\ConvertToWebsiteThumbnail]
@="Convert to website thumbnail"
"Icon"="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\""

[HKEY_CLASSES_ROOT\SystemFileAssociations\.jpg\shell\ConvertToWebsiteThumbnail\command]
@="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\" \"%1\""

; JPEG
[HKEY_CLASSES_ROOT\SystemFileAssociations\.jpeg\shell\ConvertToWebsiteThumbnail]
@="Convert to website thumbnail"
"Icon"="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\""

[HKEY_CLASSES_ROOT\SystemFileAssociations\.jpeg\shell\ConvertToWebsiteThumbnail\command]
@="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\" \"%1\""

; PNG
[HKEY_CLASSES_ROOT\SystemFileAssociations\.png\shell\ConvertToWebsiteThumbnail]
@="Convert to website thumbnail"
"Icon"="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\""

[HKEY_CLASSES_ROOT\SystemFileAssociations\.png\shell\ConvertToWebsiteThumbnail\command]
@="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\" \"%1\""

; (Optional) add more extensions if you like:
; .bmp, .gif, .webp, etc.

Then:

Double-click the .reg file.
Accept the UAC prompt and registry warning.

Now when you right-click a JPG/PNG in Explorer you should see
“Convert to website thumbnail”.

When you click it:

WebsiteThumbnailer.exe is called with the image path.
A 512×512 WebP thumbnail appears as filename_thumb.webp beside the original.

5. Notes / tweaks you might want

Overwrite instead of _thumb: change the outputPath to reuse the original name + .webp.
Quality / size trade-off: adjust WebpEncoder.Quality (0–100).
More formats in context menu: copy the registry block for .webp, .bmp, .tif, etc.
“Real” Windows service: if you truly want a background Windows Service, you’d typically:
- Run a service that listens on a named pipe/IPC.
- Have this small EXE send the file path to the service instead of doing the work itself.

But for a simple, fast “right-click → thumbnail” flow, this standalone EXE + registry hook is usually enough.

If you’d like, next step I can add:

logging to a file,
or a tiny tray app that shows progress/last error.

Yeah, that’s the “fun” part of Smartcrop.net: it pulls in SkiaSharp, which has native binaries, and those can be awkward with single-file publishing if not configured right.

You’ve basically got two realistic options:

Keep Smartcrop.net and fix your publish settings so SkiaSharp is bundled into the single EXE (internally extracted at runtime).
Drop Smartcrop.net and write a simple heuristic cropper using only ImageSharp (pure managed, easier for true single-file).

I’ll show you Option 1 first (what you asked for), then briefly mention Option 2.

1. Making Smartcrop.net + SkiaSharp work as a single EXE

Key points:

Use Self-contained + PublishSingleFile.
Do NOT trim (trimming tends to break SkiaSharp / Smartcrop).
Enable IncludeNativeLibrariesForSelfExtract so native libs are embedded in the EXE and extracted to a temp folder at runtime (but you still ship one file).

Updated `WebsiteThumbnailer.csproj`

Use this:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>

    <!-- Single-file, self-contained, with native libs embedded -->
    <PublishSingleFile>true</PublishSingleFile>
    <SelfContained>true</SelfContained>
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
    <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>

    <!-- IMPORTANT: avoid trimming, it can remove SkiaSharp bits -->
    <PublishTrimmed>false</PublishTrimmed>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.12" />
    <PackageReference Include="Smartcrop.net" Version="1.0.4" />
  </ItemGroup>
</Project>

Then publish like this:

dotnet publish -c Release

Because you set RuntimeIdentifier and SelfContained, dotnet knows you want a self-contained single-file app for win-x64.

Output will be something like:

bin\Release\net8.0\win-x64\publish\WebsiteThumbnailer.exe

You should only need to ship that one EXE.
At runtime, .NET will extract the SkiaSharp native bits to a temp folder, but the user doesn’t have to see extra files in your install directory.

If you were previously using TrimMode=link or PublishTrimmed=true, that’s probably why SkiaSharp.dll was effectively missing at runtime.

Program.cs stays the same

You can keep the Smartcrop + ImageSharp pipeline I gave you before unchanged.

Recap of the important parts:

using Smartcrop;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;
using SixLabors.ImageSharp.Formats.Webp;

// ...

const int ThumbSize = 512;

// ... check args, etc ...

using var analysisStream = File.OpenRead(inputPath);
var cropper = new ImageCrop(ThumbSize, ThumbSize);
var result = cropper.Crop(analysisStream);

// ... load with ImageSharp, build cropRect from result.Area,
// crop, resize to 512x512, then:

var encoder = new WebpEncoder { Quality = 80 };
image.Save(outputPath, encoder);

No changes needed there for the single EXE issue.

2. If you really hate native libs: ImageSharp-only “smart” crop

If at some point you decide you don’t want any Skia/native stuff at all:

Remove Smartcrop.net.
Stick with just ImageSharp and implement a simple content-aware crop:
- Downscale the image.
- Compute an edge/contrast/saliency map.
- Slide a 1:1 window and pick the region with maximum “energy.”
That can be 100% managed code, so single-file with trimming is easier.

But that’s more custom work; Smartcrop.net gives you good results “for free,” and with the csproj tweaks above you still distribute a single EXE, which sounds like what you’re aiming for.

If you tell me exactly what error or behavior you were seeing (e.g., “FileNotFoundException: SkiaSharp.dll”), I can tailor the csproj a bit more (e.g., adding an AssemblyMetadata or specific trimming exclusions), but in most cases the configuration above fixes the missing-SkiaSharp-in-single-file problem.

Yeah, 80 MB for “right-click → make a thumbnail” is… a bit much 😄

The big size comes from self-contained + SkiaSharp + .NET runtime. If you want a small single EXE, the simplest fix is:

Drop Smartcrop/SkiaSharp
Use only ImageSharp (pure managed, supports WebP)
Framework-dependent, single-file publish (requires .NET 8 runtime installed, but EXE is just a few MB)

You lose the fancy Smartcrop heuristics, but for website thumbnails a good center square crop is usually fine.

Below is a complete solution:

1. Project setup (.NET 8, small single EXE)

Create the project:

dotnet new console -n WebsiteThumbnailer -f net8.0
cd WebsiteThumbnailer

dotnet add package SixLabors.ImageSharp --version 3.1.12

`WebsiteThumbnailer.csproj`

Use this (note: not self-contained, but single-file):

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>

    <!-- Single-file, framework-dependent: small EXE, requires .NET 8 runtime -->
    <PublishSingleFile>true</PublishSingleFile>
    <SelfContained>false</SelfContained>
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>

    <!-- You can try trimming; omit if you hit issues -->
    <PublishTrimmed>false</PublishTrimmed>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.12" />
  </ItemGroup>
</Project>

This will give you one EXE that’s only your code + ImageSharp, not the whole runtime.

2. Program: center square crop → 512×512 WebP

Replace Program.cs with:

using System;
using System.IO;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;
using SixLabors.ImageSharp.Formats.Webp;

const int ThumbSize = 512;

if (args.Length < 1)
{
    Console.Error.WriteLine("Usage: WebsiteThumbnailer <imagePath>");
    return;
}

var inputPath = args[0];

if (!File.Exists(inputPath))
{
    Console.Error.WriteLine($"File not found: {inputPath}");
    return;
}

try
{
    var directory = Path.GetDirectoryName(inputPath) ?? "";
    var baseName = Path.GetFileNameWithoutExtension(inputPath);
    var outputPath = Path.Combine(directory, baseName + "_thumb.webp");

    Console.WriteLine($"Input : {inputPath}");
    Console.WriteLine($"Output: {outputPath}");

    using Image<Rgba32> image = Image.Load<Rgba32>(inputPath);

    // Build centered square crop
    var cropRect = BuildCenterSquare(image.Width, image.Height);
    Console.WriteLine($"Crop: X={cropRect.X}, Y={cropRect.Y}, W={cropRect.Width}, H={cropRect.Height}");

    image.Mutate(ctx =>
    {
        ctx.Crop(cropRect)
           .Resize(new Size(ThumbSize, ThumbSize));
    });

    var encoder = new WebpEncoder
    {
        Quality = 80 // tweak if you want smaller/larger files
    };

    image.Save(outputPath, encoder);

    Console.WriteLine("Done.");
}
catch (Exception ex)
{
    Console.Error.WriteLine("Error while converting image:");
    Console.Error.WriteLine(ex.ToString());
}

static SixLabors.ImageSharp.Rectangle BuildCenterSquare(int width, int height)
{
    int side = Math.Min(width, height);
    int x = (width - side) / 2;
    int y = (height - side) / 2;
    return new SixLabors.ImageSharp.Rectangle(x, y, side, side);
}

This is dead simple:

Takes the largest centered square.
Resizes it to 512×512.
Saves as <name>_thumb.webp beside the original.

No native deps, no SkiaSharp, no Smartcrop — just ImageSharp.

3. Publish (small, single file)

From the project folder:

dotnet publish -c Release

You’ll get something like:

bin\Release\net8.0\win-x64\publish\WebsiteThumbnailer.exe

That’s your one EXE.
Size should be in the low MBs, not 80 MB.
It just requires the .NET 8 Desktop Runtime on the machine.

Same idea as before, just point to this new EXE.

Create AddWebsiteThumbnailContextMenu.reg:

Windows Registry Editor Version 5.00

; JPG
[HKEY_CLASSES_ROOT\SystemFileAssociations\.jpg\shell\ConvertToWebsiteThumbnail]
@="Convert to website thumbnail"
"Icon"="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\""

[HKEY_CLASSES_ROOT\SystemFileAssociations\.jpg\shell\ConvertToWebsiteThumbnail\command]
@="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\" \"%1\""

; JPEG
[HKEY_CLASSES_ROOT\SystemFileAssociations\.jpeg\shell\ConvertToWebsiteThumbnail]
@="Convert to website thumbnail"
"Icon"="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\""

[HKEY_CLASSES_ROOT\SystemFileAssociations\.jpeg\shell\ConvertToWebsiteThumbnail\command]
@="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\" \"%1\""

; PNG
[HKEY_CLASSES_ROOT\SystemFileAssociations\.png\shell\ConvertToWebsiteThumbnail]
@="Convert to website thumbnail"
"Icon"="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\""

[HKEY_CLASSES_ROOT\SystemFileAssociations\.png\shell\ConvertToWebsiteThumbnail\command]
@="\"C:\\Program Files\\WebsiteThumbnailer\\WebsiteThumbnailer.exe\" \"%1\""

Adjust the path if you install the EXE somewhere else, then double-click the .reg file.

5. Quick summary of trade-offs

Before: Smartcrop + SkiaSharp + self-contained runtime ⇒ ~80 MB, very “smart”, but heavy.
Now: Center-crop + ImageSharp, framework-dependent ⇒ single EXE, a few MB.
Requires .NET 8 runtime on target machines, but no extra DLLs next to your app.

If you really want both tiny size and a more “intelligent” crop, we could add a lightweight heuristic (like scanning for the highest contrast region) entirely in ImageSharp with no extra dependencies — but center crop is often good enough for website thumbnails.

Short answer: no, there isn’t a DeepGaze-style, plug-and-play visual saliency library that’s truly .NET-native in the same sense. Everything serious in this space is Python-first, and on .NET you mainly have to host those models rather than use a ready-made saliency package.

Here’s the landscape and what is realistic:

1. What exists in .NET?

ML.NET

ML.NET has something called a “saliency map”… but it’s for time-series anomaly detection, not image saliency. The DetectAnomalyBySrCnn API talks about a saliency map per datapoint in a time series, not per-pixel visual saliency.citeturn0search19

So: ML.NET has no built-in image saliency / DeepGaze-like model.

ONNX Runtime C# (the usual route)

The standard way to do “DeepGaze, but from C#” is:

Use a pretrained saliency model in PyTorch/TensorFlow (e.g. DeepGaze II/III, ML-Net, MSI-Net, etc.).citeturn0search3turn0search9
Export it to ONNX.
Load and run that ONNX model from .NET via ONNX Runtime C# API (Microsoft.ML.OnnxRuntime) or a helper wrapper like OnnxStack.citeturn0search17turn1search1

There’s even an open issue in DeepGaze asking about exporting to ONNX, which tells you it’s not natively packaged that way yet.citeturn1search0

But once you have an ONNX model, the .NET side is just:

Preprocess image → tensor
Run inference
Get saliency heatmap → pick best 512×512 region

This is the closest thing to “.NET ML saliency library” you’ll get right now.

2. So, if you want saliency today in your thumbnail tool

You’ve basically got three options, each with trade-offs:

Heuristic crop only (what you have now)
- Pure ImageSharp, tiny EXE, very simple.
- Center crop, maybe plus cheap heuristics (edge density, brightness) if you want to get fancy.
.NET + ONNX Runtime + exported saliency model
- Use ONNX Runtime C# to run something like ML-Net, MSI-Net, or a DeepGaze variant that you or someone else has exported to ONNX.citeturn0search6turn0search3turn0search9
- You stay in C#, but you’re still shipping a sizeable model + ONNXRuntime native bits; not “tiny”, and more complex than your current tool.
Call out to Python
- Keep your .NET EXE thin.
- Shell out to a Python script that runs DeepGaze (or similar) and prints the bounding box / heatmap, then crop in C#.
- Easiest path to “real” saliency but needs Python installed and kills the “single tiny exe” dream.

3. Direct answer to your question

is there a .net based ML library for saliency like deepgaze?

There’s no dedicated, widely-used .NET visual saliency library comparable to DeepGaze.
The realistic .NET approach is:
- OnnxRuntime / OnnxStack + an ONNX saliency model, or
- Interoperating with Python.

Given how much you care about binary size and simplicity, my honest suggestion is:

Stick with ImageSharp center-crop (maybe with some cheap heuristics),
Or, if you really want proper saliency, accept a heavier dependency and go the ONNX Runtime route for a specific model you like.

If you want, I can sketch what the C# side would look like for “load saliency.onnx, run it, produce a crop box” so you can see how painful (or not) that part would be.

Short version: No, there’s no built-in .NET SDK API that will just Save("foo.webp") without a third-party lib.

A bit more detail, focused on your options:

1. What’s in .NET itself?

`System.Drawing`

Only supports BMP, PNG, JPEG, GIF, TIFF, etc.
No WebP encoder/decoder.
On non-Windows it’s even “legacy” / Windows-only.

`System.Windows.Media.Imaging` (WPF), `Windows.Media.Imaging` (UWP/WinUI)

Same story: PNG/JPEG/TIFF/GIF/BMP/ICO.
No WebP encoder.

WIC (Windows Imaging Component)

Windows itself has some WebP support via codecs/WIC on newer builds, but:
- There’s no nice managed .NET function for Bitmap.SaveAsWebp().
- You’d be writing COM interop / P/Invoke to IWICBitmapEncoder for WebP – effectively hand-rolling what ImageSharp or libwebp-based wrappers already do for you.

So: the .NET Base Class Library does not have built-in WebP encode APIs. You either:

Use a third-party managed library (ImageSharp, SkiaSharp, Magick.NET, etc.), or
P/Invoke native codecs (libwebp, WIC, GDI+ extensions, etc.).

2. What’s smallest / simplest for you?

Given your constraints:

You want:
- A small EXE
- Single file if possible
- Just “take image → make 512×512 WebP”

Your realistic options are:

ImageSharp (what you’re already using)
- Pure managed, supports WebP encoding.
- Framework-dependent single-file EXE can still be just a few MB.
- Easiest and cleanest code-wise.
P/Invoke libwebp yourself
- You ship libwebp.dll + your EXE, or embed and extract it.
- You manually wrap the native calls.
- Likely more painful than just using ImageSharp.
Use Windows’ WIC WebP codec via COM
- Requires Windows 10+ with appropriate codec.
- You write a bunch of COM interop code.
- Still not “just a .NET SDK function”.

So if your main concern is avoiding heavy dependencies, I’d honestly keep:

Image loading + cropping + WebP encoding all in ImageSharp,
Publish as framework-dependent single-file (so the .NET runtime is not baked in),
Accept a ~ couple MB EXE as the sweet spot between simplicity and size.

If you’d like, I can show a minimal version that:

Uses only ImageSharp,
Does a center square crop → 512×512,
And is structured to be as small as reasonably possible (no logging, no LINQ, etc.) to keep IL size down.

Yup, totally doable. Easiest + least painful way is:

Put the “copy + registry” logic in a PowerShell script in your project.
Call that script from a post-build target in your .csproj.

This keeps your MSBuild XML readable and makes tweaking the behavior easy.

Below is a complete setup.

1. PowerShell deploy script

Create a file in your project root called DeployWebsiteThumbnailer.ps1 with this content:

param(
    [Parameter(Mandatory = $true)]
    [string]$ExePath
)

# 1) Copy EXE to "C:\Program Files\Uncharted Limbo Collective"
$installDir = Join-Path $env:ProgramFiles "Uncharted Limbo Collective"

if (-not (Test-Path $installDir)) {
    New-Item -ItemType Directory -Path $installDir -Force | Out-Null
}

$exeName = [System.IO.Path]::GetFileName($ExePath)
$destExe = Join-Path $installDir $exeName

Copy-Item -Path $ExePath -Destination $destExe -Force

Write-Host "Copied $ExePath -> $destExe"

# 2) Create context menu registry entries
#    for .jpg, .jpeg, .png (add more if you want)
$extensions = @(".jpg", ".jpeg", ".png")

foreach ($ext in $extensions) {
    $baseKey = "Registry::HKEY_CLASSES_ROOT\SystemFileAssociations\$ext\shell\ConvertToWebsiteThumbnail"

    if (-not (Test-Path $baseKey)) {
        New-Item -Path $baseKey -Force | Out-Null
    }

    # Menu text
    Set-ItemProperty -Path $baseKey -Name '(default)' -Value 'Convert to website thumbnail'

    # Icon = our EXE
    Set-ItemProperty -Path $baseKey -Name 'Icon' -Value "`"$destExe`""

    # Command key
    $commandKey = Join-Path $baseKey "command"
    if (-not (Test-Path $commandKey)) {
        New-Item -Path $commandKey -Force | Out-Null
    }

    # "%1" = selected file path
    $commandValue = "`"$destExe`" `"%1`""
    Set-ItemProperty -Path $commandKey -Name '(default)' -Value $commandValue

    Write-Host "Registered context menu for $ext -> $commandValue"
}

Write-Host "Deployment complete."

⚠️ This script needs to run elevated (admin) to write to Program Files and HKEY_CLASSES_ROOT. So either run Visual Studio as admin, or run the script manually as admin if you test it outside the build.

You can test it once by hand:

powershell -NoProfile -ExecutionPolicy Bypass -File .\DeployWebsiteThumbnailer.ps1 -ExePath "C:\path\to\your\bin\Release\net8.0\win-x64\WebsiteThumbnailer.exe"

2. Call the script from the .csproj (post-build)

Open your project file (e.g. WebsiteThumbnailer.csproj) and add this Target near the bottom, inside the <Project> element:

  <Target Name="PostBuildDeploy" AfterTargets="Build" Condition="'$(Configuration)'=='Release'">
    <Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(ProjectDir)DeployWebsiteThumbnailer.ps1&quot; -ExePath &quot;$(TargetPath)&quot;" />
  </Target>
</Project>

Key bits:

AfterTargets="Build" → runs after every Release build.
Condition="'$(Configuration)'=='Release'" → only for Release (so Debug builds don’t spam your Program Files / registry).
$(TargetPath) → the full path to the just-built EXE.
$(ProjectDir) → where your .csproj and DeployWebsiteThumbnailer.ps1 live.

Now every time you do a Release build:

The EXE is copied to:
C:\Program Files\Uncharted Limbo Collective\WebsiteThumbnailer.exe
Registry entries are created/updated so that right-clicking .jpg, .jpeg, or .png shows “Convert to website thumbnail” which calls that EXE.

3. Tweaks you might want

More file types: just add to $extensions in the PS script: .bmp, .gif, .webp, etc.
Different install folder: change "Uncharted Limbo Collective" in the script.
Different menu text: change 'Convert to website thumbnail' in the script.

If you paste your current .csproj here, I can merge this target into it for you so you can just drop it in.

You’re right to be annoyed — “remember to run VS as admin” is exactly the kind of thing future-you will forget 😅

There’s no way for MSBuild itself to pop a UAC prompt, but we can make the PowerShell script self-elevate:

Build runs as normal (non-admin).
Post-build calls the script.
Script detects “I’m not admin”, re-launches itself with -Verb RunAs (UAC prompt).
Elevated instance does the copy + registry changes.
VS doesn’t need to be run as admin.

Below is a drop-in update.

1. Self-elevating PowerShell script

Replace your DeployWebsiteThumbnailer.ps1 with this:

param(
    [Parameter(Mandatory = $true)]
    [string]$ExePath,

    # Internal flag to prevent infinite elevation loops
    [switch]$NoElevate
)

function Test-IsAdmin {
    $currentUser = New-Object Security.Principal.WindowsPrincipal(
        [Security.Principal.WindowsIdentity]::GetCurrent()
    )
    return $currentUser.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
}

# 0) Elevation check
if (-not $NoElevate -and -not (Test-IsAdmin)) {
    Write-Host "Not running as administrator. Requesting elevation..."

    # Build argument list for the elevated process
    $escapedExePath = $ExePath.Replace('"', '""')
    $scriptPath = $PSCommandPath

    $args = "-NoProfile -ExecutionPolicy Bypass -File `"$scriptPath`" -ExePath `"$escapedExePath`" -NoElevate"

    Start-Process powershell -ArgumentList $args -Verb RunAs -Wait

    # After elevated script finishes, just exit this (non-elevated) instance
    exit 0
}

Write-Host "Running with administrative privileges."

# 1) Copy EXE to "C:\Program Files\Uncharted Limbo Collective"
$installDir = Join-Path $env:ProgramFiles "Uncharted Limbo Collective"

if (-not (Test-Path $installDir)) {
    New-Item -ItemType Directory -Path $installDir -Force | Out-Null
}

$exeName = [System.IO.Path]::GetFileName($ExePath)
$destExe = Join-Path $installDir $exeName

Copy-Item -Path $ExePath -Destination $destExe -Force

Write-Host "Copied $ExePath -> $destExe"

# 2) Create context menu registry entries for .jpg, .jpeg, .png
$extensions = @(".jpg", ".jpeg", ".png")

foreach ($ext in $extensions) {
    $baseKey = "Registry::HKEY_CLASSES_ROOT\SystemFileAssociations\$ext\shell\ConvertToWebsiteThumbnail"

    if (-not (Test-Path $baseKey)) {
        New-Item -Path $baseKey -Force | Out-Null
    }

    # Menu text
    Set-ItemProperty -Path $baseKey -Name '(default)' -Value 'Convert to website thumbnail'

    # Icon = our EXE
    Set-ItemProperty -Path $baseKey -Name 'Icon' -Value "`"$destExe`""

    # Command key
    $commandKey = Join-Path $baseKey "command"
    if (-not (Test-Path $commandKey)) {
        New-Item -Path $commandKey -Force | Out-Null
    }

    # "%1" = selected file path
    $commandValue = "`"$destExe`" `"%1`""
    Set-ItemProperty -Path $commandKey -Name '(default)' -Value $commandValue

    Write-Host "Registered context menu for $ext -> $commandValue"
}

Write-Host "Deployment complete."

What this does:

If not admin and -NoElevate isn’t set:
- It relaunches itself as admin with the same -ExePath and adds -NoElevate.
- Waits for the elevated instance to complete.
- Exits.
The elevated instance sees -NoElevate and skips the UAC part, going straight to:
- Copy EXE to C:\Program Files\Uncharted Limbo Collective\
- Write the registry keys.

2. MSBuild post-build stays almost the same

Your .csproj target can remain like this:

  <Target Name="PostBuildDeploy" AfterTargets="Build" Condition="'$(Configuration)'=='Release'">
    <Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(ProjectDir)DeployWebsiteThumbnailer.ps1&quot; -ExePath &quot;$(TargetPath)&quot;" />
  </Target>
</Project>

Now the flow is:

You hit Build → Release in VS (non-admin).
Build finishes, MSBuild runs the script.
Script sees it’s non-admin ⇒ prompts with UAC.
Elevated copy of the script runs deployment logic.
You end up with:
- EXE in Program Files\Uncharted Limbo Collective\
- Context menu entries updated.

No need to remember to run VS as admin.

If you later add more tools under “Uncharted Limbo Collective” or more extensions, you just tweak the $extensions list or folder name in that one script.

Yeah, that behavior actually makes sense (in a very annoying way).

What’s happening:

Your MSBuild target is passing $(TargetPath) to the script.
In your current build setup, $(TargetPath) is the DLL, not an EXE.
- That happens if:
  - You’re not publishing (just building), and/or
  - UseAppHost is false, so .NET builds a DLL and uses dotnet your.dll to run it.

So the script obediently copies whatever you gave it → the DLL.

Let’s fix it properly.

Option A – Make the build output an EXE again (recommended)

Tell .NET to generate a native app host (EXE) for your console app, and keep the MSBuild target simple.

In your .csproj, inside <PropertyGroup> add:

  <OutputType>Exe</OutputType>
  <TargetFramework>net8.0</TargetFramework>
  <ImplicitUsings>enable</ImplicitUsings>
  <Nullable>enable</Nullable>

  <!-- IMPORTANT: this forces an .exe host instead of just a .dll -->
  <UseAppHost>true</UseAppHost>

Full minimal example:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>

    <UseAppHost>true</UseAppHost>

    <!-- Optional single-file or whatever else you like -->
    <!--
    <PublishSingleFile>true</PublishSingleFile>
    <SelfContained>false</SelfContained>
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
    -->
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.12" />
  </ItemGroup>

  <Target Name="PostBuildDeploy" AfterTargets="Build" Condition="'$(Configuration)'=='Release'">
    <Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(ProjectDir)DeployWebsiteThumbnailer.ps1&quot; -ExePath &quot;$(TargetPath)&quot;" />
  </Target>
</Project>

With UseAppHost=true, Release build should produce:

bin\Release\net8.0\WebsiteThumbnailer.exe

$(TargetPath) now points to that EXE, and the script will copy the right thing.

Option B – Make the script “fix” a DLL path into an EXE path

If you do want to keep building as a DLL (e.g. you run with dotnet WebsiteThumbnailer.dll) but still want the deploy step to install an EXE from somewhere else (like a publish folder), you can hack it inside the script.

A simple “best effort” fix inside DeployWebsiteThumbnailer.ps1:

param(
    [Parameter(Mandatory = $true)]
    [string]$ExePath,
    [switch]$NoElevate
)

# If the path we got is a DLL, try to guess the EXE next to it
if ([System.IO.Path]::GetExtension($ExePath) -ieq ".dll") {
    $possibleExe = [System.IO.Path]::ChangeExtension($ExePath, ".exe")
    if (Test-Path $possibleExe) {
        Write-Host "TargetPath is a DLL, using sibling EXE instead: $possibleExe"
        $ExePath = $possibleExe
    } else {
        Write-Host "TargetPath is DLL and no sibling EXE found. Still using: $ExePath"
    }
}

Drop that near the top of the script (after param), before the elevation logic.

But honestly: if this is a console app you intend to double-click / context-menu call, you really want UseAppHost=true and an actual .exe. That avoids ambiguity.

Quick sanity checklist

Check your build output (Release):
- Do you see WebsiteThumbnailer.exe in bin\Release\net8.0\ (or win-x64\ etc.)?
Make sure your csproj has:
- <OutputType>Exe</OutputType>
- <UseAppHost>true</UseAppHost>
Make sure the post-build target passes $(TargetPath) exactly as we wrote.

Once those are lined up, your script should start copying the EXE instead of the DLL, and the registry will point to the right file.

If you paste your current .csproj (minus any sensitive paths), I can patch it exactly so it behaves the way you expect.

Right, so you’ve run into two separate-but-related gremlins:

MSBuild target runs too early → it’s grabbing the wrong file (pre-link / pre-publish).
The installed EXE blows up from the context menu → because what you copied isn’t the final, runnable single-file app (or trimming/runtime is messed up).

Let’s fix both by:

Hooking into Publish, not Build.
Copying the published EXE in publish\, not the build output.
Turning off trimming and making sure you get a proper EXE.
Keeping your self-elevating PowerShell script.

1. Fix the build flow: deploy after Publish, not Build

The IL linker and single-file bundling run during dotnet publish (or VS Publish), not during a normal Build.

So:

AfterTargets="Build" → the script runs on the raw build output (DLL or partially prepared app).
You then copy that into Program Files, which is why the runtime is then whining about System / missing stuff.

Instead, hook into Publish and grab the EXE from the publish directory.

Updated `.csproj` (core bits)

Something like this:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>

    <!-- We want a real .exe host -->
    <UseAppHost>true</UseAppHost>

    <!-- Framework-dependent single-file: smaller EXE, needs .NET 8 runtime installed -->
    <PublishSingleFile>true</PublishSingleFile>
    <SelfContained>false</SelfContained>
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>

    <!-- IMPORTANT: avoid trimming here, it can break complex libs -->
    <PublishTrimmed>false</PublishTrimmed>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.12" />
  </ItemGroup>

  <!-- Run deploy script AFTER publish has finished and the EXE is ready -->
  <Target Name="AfterPublishDeploy" AfterTargets="Publish" Condition="'$(Configuration)'=='Release'">
    <Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(ProjectDir)DeployWebsiteThumbnailer.ps1&quot; -ExePath &quot;$(PublishDir)$(AssemblyName).exe&quot;" />
  </Target>
</Project>

Key points:

AfterTargets="Publish" → your script no longer races the ILLinker/single-file bundler.
$(PublishDir)$(AssemblyName).exe → this is the final published EXE (single-file), not the raw build DLL.

Now you should:

Use dotnet publish -c Release
or
Use Visual Studio’s Publish profile (which invokes the Publish target).

Either way, after publish finishes, MSBuild will run your script with the correct EXE path.

2. Keep the self-elevating PowerShell script (just confirm it uses ExePath)

From earlier, your DeployWebsiteThumbnailer.ps1 should look roughly like this at the top:

param(
    [Parameter(Mandatory = $true)]
    [string]$ExePath,

    [switch]$NoElevate
)

function Test-IsAdmin {
    $currentUser = New-Object Security.Principal.WindowsPrincipal(
        [Security.Principal.WindowsIdentity]::GetCurrent()
    )
    return $currentUser.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
}

# Optional: if ExePath ever came in as .dll, we can auto-fix it
if ([System.IO.Path]::GetExtension($ExePath) -ieq ".dll") {
    $possibleExe = [System.IO.Path]::ChangeExtension($ExePath, ".exe")
    if (Test-Path $possibleExe) {
        Write-Host "TargetPath is a DLL, using sibling EXE instead: $possibleExe"
        $ExePath = $possibleExe
    }
}

# Elevation dance
if (-not $NoElevate -and -not (Test-IsAdmin)) {
    Write-Host "Not running as administrator. Requesting elevation..."

    $escapedExePath = $ExePath.Replace('"', '""')
    $scriptPath = $PSCommandPath

    $args = "-NoProfile -ExecutionPolicy Bypass -File `"$scriptPath`" -ExePath `"$escapedExePath`" -NoElevate"

    Start-Process powershell -ArgumentList $args -Verb RunAs -Wait
    exit 0
}

Write-Host "Running with administrative privileges."

# ... then do copy to Program Files\Uncharted Limbo Collective and registry setup ...

And in the “copy + registry” part, you’re still:

Copying $ExePath to C:\Program Files\Uncharted Limbo Collective\WebsiteThumbnailer.exe
Writing the command like:

$commandValue = "`"$destExe`" `"%1`""
Set-ItemProperty -Path $commandKey -Name '(default)' -Value $commandValue

That part is fine.

3. Why “could not find file for System” happens

That error is almost certainly not because Explorer is passing “System” as the file path; it’s usually because:

The EXE you installed in Program Files is not the complete published app, and
When .NET starts it, it cannot find some required assembly (System.*) or resource, so something ends up trying to open a file named System and you see that message.

By:

Publishing first,
Copying the published single-file EXE,
Disabling trimming,

you avoid that whole mess:

All required runtime bits are either:
- Provided by the system (.NET 8 shared runtime), or
- Embedded correctly in your single file and extracted to a temp directory by the host.

So the context menu should now just work.

4. Quick sanity check list

After you change the .csproj:

Run:
Terminal window
```
dotnet publish -c Release
```
Check bin\Release\net8.0\win-x64\publish\:
- There should be a YourAppName.exe only (or almost only, depending on config).
After publish finishes, you should see the script’s console output (copy + registry).
Right-click an image → “Convert to website thumbnail”:
- No more “could not find file for System”.
- A _thumb.webp appears next to the original.

If you still see the weird “System” thing, the very next thing I’d do is add:

Console.WriteLine("ARGS: " + string.Join(" | ", args));

at the top of Main to see exactly what arguments Explorer is passing in when launched via the context menu. But in practice, once you’re copying the actual publish output, that error usually disappears.

Gotcha — let’s fix both things cleanly:

Always use the .exe in Program Files + registry (never the DLL).
No console window and fast startup when called from the context menu.

1. Force everything to use the `.exe`

We’ll do this in two places so it’s bullet-proof:

The csproj will pass the published exe path.
The PowerShell script will normalize any .dll path to .exe before using it.

Updated `.csproj`

Use this pattern (fill in your package versions if needed):

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <!-- GUI-style app: no console window -->
    <OutputType>WinExe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>

    <!-- Make sure we get an .exe host -->
    <UseAppHost>true</UseAppHost>

    <!-- Publish settings: single file, framework-dependent for smaller size & faster startup -->
    <PublishSingleFile>true</PublishSingleFile>
    <SelfContained>false</SelfContained>
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
    <PublishTrimmed>false</PublishTrimmed>

    <!-- Optional: AOT-ish optimizations for faster startup -->
    <PublishReadyToRun>true</PublishReadyToRun>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.12" />
  </ItemGroup>

  <!-- Deploy AFTER publish so we use the final single-file exe -->
  <Target Name="AfterPublishDeploy" AfterTargets="Publish" Condition="'$(Configuration)'=='Release'">
    <Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(ProjectDir)DeployWebsiteThumbnailer.ps1&quot; -ExePath &quot;$(PublishDir)$(AssemblyName).exe&quot;" />
  </Target>
</Project>

Key bits:

OutputType>WinExe</OutputType> → no console window.
AfterTargets="Publish" → script runs only after the single-file EXE is fully produced.
$(PublishDir)$(AssemblyName).exe → we explicitly pass the exe, not the dll.

You now run:

dotnet publish -c Release

(or VS “Publish”) and the deploy will run after that.

2. Strongly force `.exe` in the PowerShell script

Here’s a revised DeployWebsiteThumbnailer.ps1 that:

Self-elevates (UAC prompt).
Normalizes any input (dll/exe) to an exe path.
Copies that exe.
Uses that exe in the registry entries.

param(
    [Parameter(Mandatory = $true)]
    [string]$ExePath,

    # internal flag to avoid infinite elevation
    [switch]$NoElevate
)

function Test-IsAdmin {
    $currentUser = New-Object Security.Principal.WindowsPrincipal(
        [Security.Principal.WindowsIdentity]::GetCurrent()
    )
    return $currentUser.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
}

# --- Normalize to .exe ---

# If we were given a .dll, or anything else, try to map it to an .exe next to it
$dir  = [System.IO.Path]::GetDirectoryName($ExePath)
$base = [System.IO.Path]::GetFileNameWithoutExtension($ExePath)
$exeCandidate = Join-Path $dir ($base + ".exe")

if (Test-Path $exeCandidate) {
    Write-Host "Normalizing path to exe: $exeCandidate"
    $ExePath = $exeCandidate
} else {
    Write-Host "Using given path as-is: $ExePath"
}

# --- Elevation dance ---
if (-not $NoElevate -and -not (Test-IsAdmin)) {
    Write-Host "Not running as administrator. Requesting elevation..."

    $escapedExePath = $ExePath.Replace('"', '""')
    $scriptPath = $PSCommandPath

    $args = "-NoProfile -ExecutionPolicy Bypass -File `"$scriptPath`" -ExePath `"$escapedExePath`" -NoElevate"

    Start-Process powershell -ArgumentList $args -Verb RunAs -Wait
    exit 0
}

Write-Host "Running with administrative privileges."

# --- 1) Copy EXE to Program Files\Uncharted Limbo Collective ---

$installDir = Join-Path $env:ProgramFiles "Uncharted Limbo Collective"

if (-not (Test-Path $installDir)) {
    New-Item -ItemType Directory -Path $installDir -Force | Out-Null
}

$exeName = [System.IO.Path]::GetFileNameWithoutExtension($ExePath) + ".exe"
$destExe = Join-Path $installDir $exeName

Copy-Item -Path $ExePath -Destination $destExe -Force

Write-Host "Copied $ExePath -> $destExe"

# --- 2) Registry: always point to the EXE in Program Files ---

$extensions = @(".jpg", ".jpeg", ".png")   # add more if you like

foreach ($ext in $extensions) {
    $baseKey = "Registry::HKEY_CLASSES_ROOT\SystemFileAssociations\$ext\shell\ConvertToWebsiteThumbnail"

    if (-not (Test-Path $baseKey)) {
        New-Item -Path $baseKey -Force | Out-Null
    }

    # Text in the context menu
    Set-ItemProperty -Path $baseKey -Name '(default)' -Value 'Convert to website thumbnail'

    # Icon = our EXE
    Set-ItemProperty -Path $baseKey -Name 'Icon' -Value "`"$destExe`""

    # Command subkey
    $commandKey = Join-Path $baseKey "command"
    if (-not (Test-Path $commandKey)) {
        New-Item -Path $commandKey -Force | Out-Null
    }

    # "%1" = selected file
    $commandValue = "`"$destExe`" `"%1`""
    Set-ItemProperty -Path $commandKey -Name '(default)' -Value $commandValue

    Write-Host "Registered context menu for $ext -> $commandValue"
}

Write-Host "Deployment complete."

This guarantees:

Whatever MSBuild passes, registry always ends up with something.exe in Program Files\Uncharted Limbo Collective\....
You no longer get accidental .dll paths in the registry.

3. Hide the console & keep startup snappy

You’ve already got most of it with the csproj changes:

OutputType=WinExe → no console/terminal window flashes.
PublishReadyToRun=true → slightly faster startup (JIT work pre-done).
Framework-dependent (not self-contained) → smaller EXE, faster process spin-up.

Just make sure your Program.cs doesn’t rely on console I/O (since it won’t be visible). A minimal version might look like:

using System;
using System.IO;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;
using SixLabors.ImageSharp.Formats.Webp;

internal static class Program
{
    private const int ThumbSize = 512;

    [STAThread]
    private static void Main(string[] args)
    {
        if (args.Length < 1)
            return; // no file passed, just exit immediately

        var inputPath = args[0];

        if (!File.Exists(inputPath))
            return;

        try
        {
            var directory = Path.GetDirectoryName(inputPath) ?? "";
            var baseName  = Path.GetFileNameWithoutExtension(inputPath);
            var outputPath = Path.Combine(directory, baseName + "_thumb.webp");

            using Image<Rgba32> image = Image.Load<Rgba32>(inputPath);

            var cropRect = BuildCenterSquare(image.Width, image.Height);

            image.Mutate(ctx =>
            {
                ctx.Crop(cropRect)
                   .Resize(new Size(ThumbSize, ThumbSize));
            });

            var encoder = new WebpEncoder { Quality = 80 };
            image.Save(outputPath, encoder);
        }
        catch
        {
            // swallow errors in shell context; or log to a file if you want
        }
    }

    private static SixLabors.ImageSharp.Rectangle BuildCenterSquare(int width, int height)
    {
        int side = Math.Min(width, height);
        int x = (width - side) / 2;
        int y = (height - side) / 2;
        return new SixLabors.ImageSharp.Rectangle(x, y, side, side);
    }
}

No Console.WriteLine → nothing tries to talk to a nonexistent console.
If invoked from Explorer, it just runs, writes _thumb.webp, and exits. Very “tool-like”.

TL;DR

Registry pointing to DLL: fixed by
- Passing $(PublishDir)$(AssemblyName).exe, and
- Script normalizing to .exe and always using $destExe with .exe.
No console window: OutputType=WinExe + remove console writes.
Fast startup: framework-dependent, single-file, PublishReadyToRun=true, minimal code.

If you paste your current .csproj and script, I can diff them against the above so you can see exactly what changed line-by-line.

Sure — the cleanest, safest way is:

Only pause after deployment is complete
But only in the elevated session, not in the MSBuild-launched non-admin instance
And only when running inside a normal console (so the pause doesn’t confuse an automated build)

Here is the improved ending for your DeployWebsiteThumbnailer.ps1:

Write-Host "Deployment complete."

# --- Optional pause for inspection (only if elevated) ---
if (Test-IsAdmin) {
    Write-Host ""
    Write-Host "Press Ctrl+C to exit immediately, or wait 5 seconds..."
    Start-Sleep -Seconds 5
}

Why this is the best approach

✔ Only pauses the elevated window (the one that shows real output)
✔ Does NOT block MSBuild (since the un-elevated instance exits immediately)
✔ Gives you a few seconds to read “Copied …”, “Registered…” lines
✔ Avoids hanging the build pipeline

Full snippet you can paste at the end of the script

Just replace the last line of your DeployWebsiteThumbnailer.ps1 with this block:

Write-Host "Deployment complete."

# Wait a few seconds so you can read the output
if (Test-IsAdmin) {
    Write-Host ""
    Write-Host "Done. Keeping this PowerShell window open for 5 seconds..."
    Start-Sleep -Seconds 5
}

If you want longer, just change 5 to whatever you want (10, 20, etc.).

If you want it to stay open until you press a key, I can give you a keypress-based solution too.

Great question, and yeah, this one is confusing until you know how the SDK-style projects work.

Why `$(TargetPath)` keeps pointing to the .dll

In SDK-style .NET (Core/5/6/7/8) projects:

The primary build output is the managed assembly → a .dll
The EXE “host” (the thing you double-click) is a separate file called the apphost, and MSBuild does not treat that as the TargetPath.

So:

In classic .NET Framework, TargetPath → MyApp.exe.
In modern SDK-style .NET, TargetPath → MyApp.dll, even if you have an exe sitting next to it.

This is by design: dotnet run and tools primarily work with the assembly (dll), not the apphost EXE.

That’s why your line:

-ExePath &quot;$(TargetPath)&quot;

keeps giving you the DLL — because MSBuild is doing exactly what it’s supposed to for SDK-style projects.

What you should use instead

For what you’re doing (deploying the real EXE):

Don’t use $(TargetPath) at all.
Use the published EXE after dotnet publish:

<Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(ProjectDir)DeployWebsiteThumbnailer.ps1&quot; -ExePath &quot;$(PublishDir)$(AssemblyName).exe&quot;" />

Key bits:

$(PublishDir) → folder where dotnet publish puts final output (single-file if you configured it).
$(AssemblyName).exe → the actual EXE host we want to install and put in the registry.

And make sure your target is tied to Publish, not Build:

<Target Name="AfterPublishDeploy" AfterTargets="Publish" Condition="'$(Configuration)'=='Release'">
    <Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(ProjectDir)DeployWebsiteThumbnailer.ps1&quot; -ExePath &quot;$(PublishDir)$(AssemblyName).exe&quot;" />
</Target>

If you really insist on build-time (not publish)

Then you can work around the DLL by:

Forcing an apphost:
```
<UseAppHost>true</UseAppHost>
```

And in the script, converting any .dll to .exe:

$dir  = [System.IO.Path]::GetDirectoryName($ExePath)
$base = [System.IO.Path]::GetFileNameWithoutExtension($ExePath)
$exeCandidate = Join-Path $dir ($base + ".exe")

if (Test-Path $exeCandidate) {
    $ExePath = $exeCandidate
}

But honestly, routing everything through Publish + $(PublishDir)$(AssemblyName).exe is cleaner and less magical.

So the direct answer:

why does this -ExePath "$(TargetPath)" keep referencing the .dll ?

Because in SDK-style .NET projects, TargetPath is defined as the built assembly (.dll), not the apphost .exe. If you want the exe, you either:

Construct the path yourself (change .dll → .exe), or
Point at the published exe with $(PublishDir)$(AssemblyName).exe, which is what you want for your context-menu tool.

OK cleanup the script and accept a size as argument. Then create multiple entries at the context menu, under

Uncharted Limbo Tools > Thumbnail Generator > Make 512x512 Website Thumbnail Uncharted Limbo Tools > Thumbnail Generator > Make 256x256 Website Logo

using System; using System.IO; using Smartcrop; using SixLabors.ImageSharp; using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.Processing; using SixLabors.ImageSharp.Formats.Webp;

const int thumbSize = 512; const int quality = 70;

/if (args.Length < 1) { Console.Error.WriteLine(“Usage: WebsiteThumbnailer ”); return; }/

var inputPath = args[0];

if (!File.Exists(inputPath)) { /* Console.Error.WriteLine($“File not found: {inputPath}”); */ return; }

try { // Where to save the thumbnail: same folder, name + _thumb.webp var directory = Path.GetDirectoryName(inputPath) ?? ""; var baseName = Path.GetFileNameWithoutExtension(inputPath); var outputPath = Path.Combine(directory, baseName + “_thumbnail.webp”);

/*
Console.WriteLine($"Input : {inputPath}");
Console.WriteLine($"Output: {outputPath}");
*/

// 1) Ask Smartcrop.net for the best square crop region (512x512)
//    It just needs a stream to analyze; it doesn't modify the file.
/*
Console.WriteLine("Running SmartCrop...");
*/
using var analysisStream = File.OpenRead(inputPath);

var cropper = new ImageCrop(thumbSize, thumbSize)
{
        Options =
        {
                RuleOfThirds = true
        }
};

var result = cropper.Crop(analysisStream);

if (result?.Area == null)
{
    /*
    Console.Error.WriteLine("SmartCrop did not return a crop area; falling back to full image.");
*/

}

// 2) Load image with ImageSharp
using var image = Image.Load<Rgba32>(inputPath);

// 3) Build a rectangle for ImageSharp from Smartcrop’s area
//    Smartcrop Area is typically with X/Y/Width/Height (float or int).
SixLabors.ImageSharp.Rectangle cropRect;

if (result?.Area != null)
{
    // Defensive clamping, in case SmartCrop returns a slightly out-of-bounds area
    int x = Math.Max(0, (int)Math.Floor((double)result.Area.X));
    int y = Math.Max(0, (int)Math.Floor((double)result.Area.Y));
    int w = (int)Math.Ceiling((double)result.Area.Width);
    int h = (int)Math.Ceiling((double)result.Area.Height);

    if (w <= 0 || h <= 0)
    {
        // Fallback: center-crop the largest square
        Console.Error.WriteLine("SmartCrop area had non-positive size; using center square instead.");
        cropRect = BuildCenterSquare(image.Width, image.Height);
    }
    else
    {
        // Clamp to image bounds
        if (x + w > image.Width) w = image.Width - x;
        if (y + h > image.Height) h = image.Height - y;

        cropRect = new SixLabors.ImageSharp.Rectangle(x, y, w, h);
    }
}
else
{
    // Fallback: center square
    cropRect = BuildCenterSquare(image.Width, image.Height);
}

/*
Console.WriteLine($"Crop area: X={cropRect.X}, Y={cropRect.Y}, W={cropRect.Width}, H={cropRect.Height}");
*/

// 4) Crop to that region, then resize exactly to 512x512
image.Mutate(ctx =>
{
    ctx.Crop(cropRect)
       .Resize(new Size(thumbSize, thumbSize));
});

// 5) Save as WebP
var encoder = new WebpEncoder
{
    Quality = quality // adjust if you want smaller/larger files
};

image.Save(outputPath, encoder);

/*
Console.WriteLine("Done.");

*/ } catch (Exception ex) { /Console.Error.WriteLine(“Error while converting image:”); Console.Error.WriteLine(ex.ToString());/ }

return;

// Helper: build a centered square region inside the image static SixLabors.ImageSharp.Rectangle BuildCenterSquare(int width, int height) { int side = Math.Min(width, height); int x = (width - side) / 2; int y = (height - side) / 2; return new SixLabors.ImageSharp.Rectangle(x, y, side, side); }

Nice, this is getting pretty slick 😄
Let’s wire everything together properly:

The EXE accepts a size argument (512 or 256).
The PowerShell deploy script is cleaned up, self-elevating, and always uses the EXE.
Context menu gets a nested structure:

Uncharted Limbo Tools → Thumbnail Generator → Make 512x512 Website Thumbnail
Uncharted Limbo Tools → Thumbnail Generator → Make 256x256 Website Logo

1. Updated `Program.cs` (size as argument, Smartcrop + WebP)

This version:

Arg0 = size (int)
Arg1 = input path
Uses Smartcrop for that size
Writes different suffixes for 512 vs 256
- 512 → _thumbnail.webp
- 256 → _logo.webp
- fallback → _thumb{size}.webp
No console window interaction (so it’s fine as WinExe)

using System;
using System.IO;
using Smartcrop;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;
using SixLabors.ImageSharp.Formats.Webp;

internal static class Program
{
    private const int Quality = 70;

    private static void Main(string[] args)
    {
        // Expect: [0] = size, [1] = image path
        if (args.Length < 2)
            return;

        if (!int.TryParse(args[0], out var thumbSize) || thumbSize <= 0)
            return;

        var inputPath = args[1];
        if (!File.Exists(inputPath))
            return;

        try
        {
            var directory = Path.GetDirectoryName(inputPath) ?? "";
            var baseName = Path.GetFileNameWithoutExtension(inputPath);

            string suffix = thumbSize switch
            {
                512 => "_thumbnail",
                256 => "_logo",
                _   => "_thumb" + thumbSize
            };

            var outputPath = Path.Combine(directory, baseName + suffix + ".webp");

            // Smartcrop analysis
            using var analysisStream = File.OpenRead(inputPath);

            var cropper = new ImageCrop(thumbSize, thumbSize)
            {
                Options =
                {
                    RuleOfThirds = true
                }
            };

            var result = cropper.Crop(analysisStream);

            using var image = Image.Load<Rgba32>(inputPath);

            var cropRect = result?.Area != null
                ? BuildCropRectFromSmartCrop(result.Area, image.Width, image.Height)
                : BuildCenterSquare(image.Width, image.Height);

            image.Mutate(ctx =>
            {
                ctx.Crop(cropRect)
                   .Resize(new Size(thumbSize, thumbSize));
            });

            var encoder = new WebpEncoder
            {
                Quality = Quality
            };

            image.Save(outputPath, encoder);
        }
        catch
        {
            // Swallow in shell context; optionally log somewhere if you want
        }
    }

    private static SixLabors.ImageSharp.Rectangle BuildCropRectFromSmartCrop(Smartcrop.Models.CropRectangle area, int width, int height)
    {
        int x = Math.Max(0, (int)Math.Floor((double)area.X));
        int y = Math.Max(0, (int)Math.Floor((double)area.Y));
        int w = (int)Math.Ceiling((double)area.Width);
        int h = (int)Math.Ceiling((double)area.Height);

        if (w <= 0 || h <= 0)
        {
            return BuildCenterSquare(width, height);
        }

        if (x + w > width) w = width - x;
        if (y + h > height) h = height - y;

        return new SixLabors.ImageSharp.Rectangle(x, y, w, h);
    }

    // Helper: build a centered square region inside the image
    private static SixLabors.ImageSharp.Rectangle BuildCenterSquare(int width, int height)
    {
        int side = Math.Min(width, height);
        int x = (width - side) / 2;
        int y = (height - side) / 2;
        return new SixLabors.ImageSharp.Rectangle(x, y, side, side);
    }
}

2. Cleaned `DeployWebsiteThumbnailer.ps1`

This script:

Takes -ExePath (the published EXE path).
Self-elevates via UAC if needed.
Normalizes to an .exe.
Copies it to:
C:\Program Files\Uncharted Limbo Collective\ThumbnailGenerator.exe
Creates nested context menu entries for several image extensions.
Pauses 5 seconds at the end so you can inspect the output.

param(
    [Parameter(Mandatory = $true)]
    [string]$ExePath,

    # internal flag to avoid infinite elevation loop
    [switch]$NoElevate
)

function Test-IsAdmin {
    $currentUser = New-Object Security.Principal.WindowsPrincipal(
        [Security.Principal.WindowsIdentity]::GetCurrent()
    )
    return $currentUser.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
}

# --- Normalize to .exe ---
$dir  = [System.IO.Path]::GetDirectoryName($ExePath)
$base = [System.IO.Path]::GetFileNameWithoutExtension($ExePath)
$exeCandidate = Join-Path $dir ($base + ".exe")

if (Test-Path $exeCandidate) {
    Write-Host "Normalizing path to exe: $exeCandidate"
    $ExePath = $exeCandidate
} else {
    Write-Host "Using given path as-is: $ExePath"
}

# --- Elevation dance ---
if (-not $NoElevate -and -not (Test-IsAdmin)) {
    Write-Host "Not running as administrator. Requesting elevation..."

    $escapedExePath = $ExePath.Replace('"', '""')
    $scriptPath = $PSCommandPath

    $args = "-NoProfile -ExecutionPolicy Bypass -File `"$scriptPath`" -ExePath `"$escapedExePath`" -NoElevate"

    Start-Process powershell -ArgumentList $args -Verb RunAs -Wait
    exit 0
}

Write-Host "Running with administrative privileges."

# --- 1) Copy EXE to Program Files\Uncharted Limbo Collective ---

$installDir = Join-Path $env:ProgramFiles "Uncharted Limbo Collective"

if (-not (Test-Path $installDir)) {
    New-Item -ItemType Directory -Path $installDir -Force | Out-Null
}

$exeName = "ThumbnailGenerator.exe"
$destExe = Join-Path $installDir $exeName

Copy-Item -Path $ExePath -Destination $destExe -Force

Write-Host "Copied $ExePath -> $destExe"

# --- 2) Registry: create nested context menu entries ---

# File types you want this for
$extensions = @(".jpg", ".jpeg", ".png", ".bmp", ".gif", ".webp")

foreach ($ext in $extensions) {
    # Root: Uncharted Limbo Tools
    $rootKey = "Registry::HKEY_CLASSES_ROOT\SystemFileAssociations\$ext\shell\UnchartedLimboTools"

    if (-not (Test-Path $rootKey)) {
        New-Item -Path $rootKey -Force | Out-Null
    }

    Set-ItemProperty -Path $rootKey -Name 'MUIVerb' -Value 'Uncharted Limbo Tools'
    # optional: show as cascading menu
    Set-ItemProperty -Path $rootKey -Name 'SubCommands' -Value ''

    # Child: Thumbnail Generator
    $thumbGenKey = Join-Path $rootKey "shell\ThumbnailGenerator"
    if (-not (Test-Path $thumbGenKey)) {
        New-Item -Path $thumbGenKey -Force | Out-Null
    }
    Set-ItemProperty -Path $thumbGenKey -Name 'MUIVerb' -Value 'Thumbnail Generator'

    # --- 512x512 Website Thumbnail ---
    $make512Key = Join-Path $thumbGenKey "shell\Make512"
    if (-not (Test-Path $make512Key)) {
        New-Item -Path $make512Key -Force | Out-Null
    }
    Set-ItemProperty -Path $make512Key -Name 'MUIVerb' -Value 'Make 512x512 Website Thumbnail'

    $cmd512Key = Join-Path $make512Key "command"
    if (-not (Test-Path $cmd512Key)) {
        New-Item -Path $cmd512Key -Force | Out-Null
    }
    $cmd512 = "`"$destExe`" 512 `"%1`""
    Set-ItemProperty -Path $cmd512Key -Name '(default)' -Value $cmd512

    # --- 256x256 Website Logo ---
    $make256Key = Join-Path $thumbGenKey "shell\Make256"
    if (-not (Test-Path $make256Key)) {
        New-Item -Path $make256Key -Force | Out-Null
    }
    Set-ItemProperty -Path $make256Key -Name 'MUIVerb' -Value 'Make 256x256 Website Logo'

    $cmd256Key = Join-Path $make256Key "command"
    if (-not (Test-Path $cmd256Key)) {
        New-Item -Path $cmd256Key -Force | Out-Null
    }
    $cmd256 = "`"$destExe`" 256 `"%1`""
    Set-ItemProperty -Path $cmd256Key -Name '(default)' -Value $cmd256

    Write-Host "Registered menu for $ext"
}

Write-Host "Deployment complete."

# Small pause so you can see the output in the elevated window
if (Test-IsAdmin) {
    Write-Host ""
    Write-Host "Done. Keeping this PowerShell window open for 5 seconds..."
    Start-Sleep -Seconds 5
}

3. MSBuild hook (if you want it automated after Publish)

In your .csproj, hook this script to Publish and pass in the published exe:

<Target Name="AfterPublishDeploy" AfterTargets="Publish" Condition="'$(Configuration)'=='Release'">
  <Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(ProjectDir)DeployWebsiteThumbnailer.ps1&quot; -ExePath &quot;$(PublishDir)$(AssemblyName).exe&quot;" />
</Target>

And make sure your PropertyGroup is something like:

<PropertyGroup>
  <OutputType>WinExe</OutputType>
  <TargetFramework>net8.0</TargetFramework>
  <ImplicitUsings>enable</ImplicitUsings>
  <Nullable>enable</Nullable>

  <UseAppHost>true</UseAppHost>
  <PublishSingleFile>true</PublishSingleFile>
  <SelfContained>false</SelfContained>
  <RuntimeIdentifier>win-x64</RuntimeIdentifier>
  <PublishTrimmed>false</PublishTrimmed>
  <PublishReadyToRun>true</PublishReadyToRun>
</PropertyGroup>

Then:

dotnet publish -c Release
Script runs, UAC prompts, installs the EXE and registry entries.
Right-click an image →
Uncharted Limbo Tools → Thumbnail Generator → Make 512x512 Website Thumbnail / Make 256x256 Website Logo

Should all hang together nicely.

Yeah, that’s because Windows only treats a key as a cascading submenu if it has SubCommands set.

We set SubCommands on Uncharted Limbo Tools, but not on Thumbnail Generator, so Windows shows “Thumbnail Generator” as a dead item with no submenu – your Make 512 / Make 256 entries are sitting under shell, but Explorer doesn’t know to display them.

We just need to add one property.

Fix: mark `ThumbnailGenerator` as a cascading menu

In your DeployWebsiteThumbnailer.ps1, inside the foreach ($ext in $extensions) loop, find this part:

# Child: Thumbnail Generator
$thumbGenKey = Join-Path $rootKey "shell\ThumbnailGenerator"
if (-not (Test-Path $thumbGenKey)) {
    New-Item -Path $thumbGenKey -Force | Out-Null
}
Set-ItemProperty -Path $thumbGenKey -Name 'MUIVerb' -Value 'Thumbnail Generator'

Change it to:

# Child: Thumbnail Generator (cascading submenu)
$thumbGenKey = Join-Path $rootKey "shell\ThumbnailGenerator"
if (-not (Test-Path $thumbGenKey)) {
    New-Item -Path $thumbGenKey -Force | Out-Null
}

# Text for the submenu
Set-ItemProperty -Path $thumbGenKey -Name 'MUIVerb' -Value 'Thumbnail Generator'

# IMPORTANT: make this a cascading menu that uses its 'shell' subkeys
Set-ItemProperty -Path $thumbGenKey -Name 'SubCommands' -Value ''

Leave the rest (Make512 / Make256) as you already have:

# --- 512x512 Website Thumbnail ---
$make512Key = Join-Path $thumbGenKey "shell\Make512"
...
$cmd512Key = Join-Path $make512Key "command"
...
$cmd512 = "`"$destExe`" 512 `"%1`""

# --- 256x256 Website Logo ---
$make256Key = Join-Path $thumbGenKey "shell\Make256"
...
$cmd256Key = Join-Path $make256Key "command"
...
$cmd256 = "`"$destExe`" 256 `"%1`""

Now the structure per extension looks like:

SystemFileAssociations\.ext\shell\UnchartedLimboTools
- MUIVerb = "Uncharted Limbo Tools"
- SubCommands = "" → use its shell children
- shell\ThumbnailGenerator
  - MUIVerb = "Thumbnail Generator"
  - SubCommands = "" → use its shell children
  - shell\Make512
    - MUIVerb = "Make 512x512 Website Thumbnail"
    - command\@ = "<exe> 512 \"%1\""
  - shell\Make256
    - MUIVerb = "Make 256x256 Website Logo"
    - command\@ = "<exe> 256 \"%1\""

That’s exactly:

Uncharted Limbo Tools → Thumbnail Generator → Make 512x512 Website Thumbnail / Make 256x256 Website Logo

After changing the script

Run your publish again (so the post-publish script runs), or run the PS script manually with -ExePath pointing to your published exe.
Right-click an image:
- You should now see the full nested menus with both “Make 512…” and “Make 256…”.

If the old broken keys linger, you can also nuke them once:

Remove-Item "Registry::HKEY_CLASSES_ROOT\SystemFileAssociations\.jpg\shell\UnchartedLimboTools" -Recurse -Force
# repeat for .jpeg, .png, etc.

then rerun the script.

Totally fine to change direction 🙂
Let’s flip it back to a console app that:

Opens a console window when run from the context menu
Prints what it’s doing + any errors
Waits for a key press before closing so you can inspect things

Your PowerShell deployment script and registry commands can stay as they are (they just call the EXE). We only need to:

Make the project a console app again.
Update Program.cs to log + pause.

1. Make it a console app (show console window)

In your .csproj, change:

<OutputType>WinExe</OutputType>

to:

<OutputType>Exe</OutputType>

Leave all the other stuff (ImageSharp, single-file, PublishReadyToRun, etc.) as you like.

So your PropertyGroup should look roughly like:

<PropertyGroup>
  <OutputType>Exe</OutputType>
  <TargetFramework>net8.0</TargetFramework>
  <ImplicitUsings>enable</ImplicitUsings>
  <Nullable>enable</Nullable>

  <UseAppHost>true</UseAppHost>
  <PublishSingleFile>true</PublishSingleFile>
  <SelfContained>false</SelfContained>
  <RuntimeIdentifier>win-x64</RuntimeIdentifier>
  <PublishTrimmed>false</PublishTrimmed>
  <PublishReadyToRun>true</PublishReadyToRun>
</PropertyGroup>

That’s enough for a console window to appear when the EXE runs (including from the context menu).

2. Updated `Program.cs` – logs + keeps console open

Here’s a version of your Smartcrop-based code that:

Expects:
arg0 = size (e.g. 512 or 256)
arg1 = image path
Logs clearly what it’s doing.
On any exit path, prompts: “Press any key to exit…” and waits.

using System;
using System.IO;
using Smartcrop;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;
using SixLabors.ImageSharp.Formats.Webp;

internal static class Program
{
    private const int Quality = 70;

    private static void Main(string[] args)
    {
        try
        {
            if (args.Length < 2)
            {
                Console.Error.WriteLine("Usage: ThumbnailGenerator <size> <imagePath>");
                PauseAndExit();
                return;
            }

            if (!int.TryParse(args[0], out var thumbSize) || thumbSize <= 0)
            {
                Console.Error.WriteLine($"Invalid size argument: '{args[0]}'");
                PauseAndExit();
                return;
            }

            var inputPath = args[1];

            Console.WriteLine($"Size      : {thumbSize}x{thumbSize}");
            Console.WriteLine($"Input path: {inputPath}");

            if (!File.Exists(inputPath))
            {
                Console.Error.WriteLine($"File not found: {inputPath}");
                PauseAndExit();
                return;
            }

            var directory = Path.GetDirectoryName(inputPath) ?? "";
            var baseName = Path.GetFileNameWithoutExtension(inputPath);

            string suffix = thumbSize switch
            {
                512 => "_thumbnail",
                256 => "_logo",
                _   => "_thumb" + thumbSize
            };

            var outputPath = Path.Combine(directory, baseName + suffix + ".webp");
            Console.WriteLine($"Output path: {outputPath}");
            Console.WriteLine();

            // 1) Smartcrop analysis
            Console.WriteLine("Running SmartCrop analysis...");
            using var analysisStream = File.OpenRead(inputPath);

            var cropper = new ImageCrop(thumbSize, thumbSize)
            {
                Options =
                {
                    RuleOfThirds = true
                }
            };

            var result = cropper.Crop(analysisStream);

            // 2) Load with ImageSharp
            using var image = Image.Load<Rgba32>(inputPath);

            SixLabors.ImageSharp.Rectangle cropRect;
            if (result?.Area != null)
            {
                cropRect = BuildCropRectFromSmartCrop(result.Area, image.Width, image.Height);
                Console.WriteLine($"Smartcrop area: X={cropRect.X}, Y={cropRect.Y}, W={cropRect.Width}, H={cropRect.Height}");
            }
            else
            {
                Console.WriteLine("SmartCrop did not return an area; falling back to center square.");
                cropRect = BuildCenterSquare(image.Width, image.Height);
            }

            // 3) Crop + resize
            Console.WriteLine("Cropping and resizing...");
            image.Mutate(ctx =>
            {
                ctx.Crop(cropRect)
                   .Resize(new Size(thumbSize, thumbSize));
            });

            // 4) Save as WebP
            Console.WriteLine("Saving WebP...");
            var encoder = new WebpEncoder { Quality = Quality };
            image.Save(outputPath, encoder);

            Console.WriteLine("Done.");
            PauseAndExit();
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine("Unhandled error while converting image:");
            Console.Error.WriteLine(ex);
            PauseAndExit();
        }
    }

    private static SixLabors.ImageSharp.Rectangle BuildCropRectFromSmartCrop(Smartcrop.Models.CropRectangle area, int width, int height)
    {
        int x = Math.Max(0, (int)Math.Floor((double)area.X));
        int y = Math.Max(0, (int)Math.Floor((double)area.Y));
        int w = (int)Math.Ceiling((double)area.Width);
        int h = (int)Math.Ceiling((double)area.Height);

        if (w <= 0 || h <= 0)
        {
            Console.Error.WriteLine("SmartCrop area had non-positive size; using center square instead.");
            return BuildCenterSquare(width, height);
        }

        if (x + w > width) w = width - x;
        if (y + h > height) h = height - y;

        return new SixLabors.ImageSharp.Rectangle(x, y, w, h);
    }

    private static SixLabors.ImageSharp.Rectangle BuildCenterSquare(int width, int height)
    {
        int side = Math.Min(width, height);
        int x = (width - side) / 2;
        int y = (height - side) / 2;
        return new SixLabors.ImageSharp.Rectangle(x, y, side, side);
    }

    private static void PauseAndExit()
    {
        Console.WriteLine();
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey(true);
    }
}

Now, when you run via context menu:

A console window opens.
You see:
- Size
- Input path
- Output path
- Any Smartcrop issues
- Any exception details
Window stays open until you press a key.

3. Registry / PS script – no change needed

Your registry entries that call the app like:

"...\ThumbnailGenerator.exe" 512 "%1"
"...\ThumbnailGenerator.exe" 256 "%1"

are still correct.

The PowerShell deployment script doesn’t care whether the app is console or GUI; it just copies the EXE and writes those commands.

So you only need to:

Switch OutputType back to Exe.
Replace Program.cs with the version above.
Re-publish (so the script updates Program Files + registry).

And you’ll get the “debuggable” behavior you want.

Gotcha — you want the script itself to grab the published EXE from:

bin\Release\net9.0\win-x64\publish

instead of being passed -ExePath.

Let’s make the script self-contained:

It figures out the EXE path based on the script’s own location.
It still self-elevates.
It still sets up the nested context menu with 512 and 256.
It still pauses 5 seconds at the end.

1. Updated PowerShell script (no `-ExePath` needed)

Save this as DeployWebsiteThumbnailer.ps1 next to your .csproj:

param(
    # internal flag to avoid infinite elevation loop
    [switch]$NoElevate
)

function Test-IsAdmin {
    $currentUser = New-Object Security.Principal.WindowsPrincipal(
        [Security.Principal.WindowsIdentity]::GetCurrent()
    )
    return $currentUser.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
}

# --- Locate the published EXE in bin\Release\net9.0\win-x64\publish ---

$scriptDir = Split-Path $PSCommandPath -Parent
$exePath   = Join-Path $scriptDir "bin\Release\net9.0\win-x64\publish\ThumbnailGenerator.exe"

if (-not (Test-Path $exePath)) {
    Write-Host "ERROR: Could not find published EXE at:"
    Write-Host "  $exePath"
    Write-Host "Make sure you've run: dotnet publish -c Release -r win-x64"
    Start-Sleep -Seconds 5
    exit 1
}

Write-Host "Found EXE: $exePath"

# --- Elevation dance ---
if (-not $NoElevate -and -not (Test-IsAdmin)) {
    Write-Host "Not running as administrator. Requesting elevation..."

    $scriptPath = $PSCommandPath
    $args = "-NoProfile -ExecutionPolicy Bypass -File `"$scriptPath`" -NoElevate"

    Start-Process powershell -ArgumentList $args -Verb RunAs -Wait
    exit 0
}

Write-Host "Running with administrative privileges."

# --- 1) Copy EXE to Program Files\Uncharted Limbo Collective ---

$installDir = Join-Path $env:ProgramFiles "Uncharted Limbo Collective"

if (-not (Test-Path $installDir)) {
    New-Item -ItemType Directory -Path $installDir -Force | Out-Null
}

$exeName = "ThumbnailGenerator.exe"
$destExe = Join-Path $installDir $exeName

Copy-Item -Path $exePath -Destination $destExe -Force

Write-Host "Copied $exePath -> $destExe"

# --- 2) Registry: create nested context menu entries ---

# File types you want this for
$extensions = @(".jpg", ".jpeg", ".png", ".bmp", ".gif", ".webp")

foreach ($ext in $extensions) {
    # Root: Uncharted Limbo Tools (cascading)
    $rootKey = "Registry::HKEY_CLASSES_ROOT\SystemFileAssociations\$ext\shell\UnchartedLimboTools"

    if (-not (Test-Path $rootKey)) {
        New-Item -Path $rootKey -Force | Out-Null
    }

    Set-ItemProperty -Path $rootKey -Name 'MUIVerb' -Value 'Uncharted Limbo Tools'
    Set-ItemProperty -Path $rootKey -Name 'SubCommands' -Value ''

    # Child: Thumbnail Generator (cascading)
    $thumbGenKey = Join-Path $rootKey "shell\ThumbnailGenerator"
    if (-not (Test-Path $thumbGenKey)) {
        New-Item -Path $thumbGenKey -Force | Out-Null
    }

    Set-ItemProperty -Path $thumbGenKey -Name 'MUIVerb' -Value 'Thumbnail Generator'
    Set-ItemProperty -Path $thumbGenKey -Name 'SubCommands' -Value ''

    # --- 512x512 Website Thumbnail ---
    $make512Key = Join-Path $thumbGenKey "shell\Make512"
    if (-not (Test-Path $make512Key)) {
        New-Item -Path $make512Key -Force | Out-Null
    }
    Set-ItemProperty -Path $make512Key -Name 'MUIVerb' -Value 'Make 512x512 Website Thumbnail'

    $cmd512Key = Join-Path $make512Key "command"
    if (-not (Test-Path $cmd512Key)) {
        New-Item -Path $cmd512Key -Force | Out-Null
    }
    $cmd512 = "`"$destExe`" 512 `"%1`""
    Set-ItemProperty -Path $cmd512Key -Name '(default)' -Value $cmd512

    # --- 256x256 Website Logo ---
    $make256Key = Join-Path $thumbGenKey "shell\Make256"
    if (-not (Test-Path $make256Key)) {
        New-Item -Path $make256Key -Force | Out-Null
    }
    Set-ItemProperty -Path $make256Key -Name 'MUIVerb' -Value 'Make 256x256 Website Logo'

    $cmd256Key = Join-Path $make256Key "command"
    if (-not (Test-Path $cmd256Key)) {
        New-Item -Path $cmd256Key -Force | Out-Null
    }
    $cmd256 = "`"$destExe`" 256 `"%1`""
    Set-ItemProperty -Path $cmd256Key -Name '(default)' -Value $cmd256

    Write-Host "Registered menu for $ext"
}

Write-Host "Deployment complete."

# Small pause so you can see the output in the elevated window
if (Test-IsAdmin) {
    Write-Host ""
    Write-Host "Done. Keeping this PowerShell window open for 5 seconds..."
    Start-Sleep -Seconds 5
}

How it works now

Script finds:
$(ProjectDir)\bin\Release\net9.0\win-x64\publish\ThumbnailGenerator.exe
If it’s missing, it yells at you and waits 5s so you can read the error.
If present, it elevates (if needed), copies that EXE to Program Files, and writes the context menu entries you wanted.

You can run it manually:

cd path\to\your\project
powershell -NoProfile -ExecutionPolicy Bypass -File .\DeployWebsiteThumbnailer.ps1

(As normal user; it will trigger UAC itself.)

2. Optional: hook it into MSBuild / Publish

If you still want it to run automatically after dotnet publish, your .csproj target becomes very simple now, since the script doesn’t need arguments:

<Target Name="AfterPublishDeploy" AfterTargets="Publish" Condition="'$(Configuration)'=='Release'">
  <Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(ProjectDir)DeployWebsiteThumbnailer.ps1&quot;" />
</Target>

And that’s it: the script always copies the EXE from bin\Release\net9.0\win-x64\publish.

Nice, let’s make this thing bullet-proof and flexible.

We’ll do two things:

Main C# app
- Works both as console and WinExe.
- Keeps all Console.WriteLine calls.
- Only “press any key to exit” when we know we have a console (via conditional compilation).
PowerShell deploy script
- Automatically finds the published EXE by scanning bin\Release\
  (no hard-coded net9.0 or win-x64).
- Still self-elevates and sets up the nested context menu with 512/256 options.

1. Program.cs with conditional “pause” (console vs WinExe)

We’ll keep all Console.WriteLine calls so you can see logs when a console exists.
We’ll use a compile symbol HAS_CONSOLE only to control the pause at the end.

Program.cs

using System;
using System.IO;
using Smartcrop;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;
using SixLabors.ImageSharp.Formats.Webp;

internal static class Program
{
    private const int Quality = 70;

    private static void Main(string[] args)
    {
        try
        {
            if (args.Length < 2)
            {
                Console.Error.WriteLine("Usage: ThumbnailGenerator <size> <imagePath>");
                PauseAndExit();
                return;
            }

            if (!int.TryParse(args[0], out var thumbSize) || thumbSize <= 0)
            {
                Console.Error.WriteLine($"Invalid size argument: '{args[0]}'");
                PauseAndExit();
                return;
            }

            var inputPath = args[1];

            Console.WriteLine($"Size      : {thumbSize}x{thumbSize}");
            Console.WriteLine($"Input path: {inputPath}");

            if (!File.Exists(inputPath))
            {
                Console.Error.WriteLine($"File not found: {inputPath}");
                PauseAndExit();
                return;
            }

            var directory = Path.GetDirectoryName(inputPath) ?? "";
            var baseName  = Path.GetFileNameWithoutExtension(inputPath);

            string suffix = thumbSize switch
            {
                512 => "_thumbnail",
                256 => "_logo",
                _   => "_thumb" + thumbSize
            };

            var outputPath = Path.Combine(directory, baseName + suffix + ".webp");
            Console.WriteLine($"Output path: {outputPath}");
            Console.WriteLine();

            // 1) Smartcrop analysis
            Console.WriteLine("Running SmartCrop analysis...");
            using var analysisStream = File.OpenRead(inputPath);

            var cropper = new ImageCrop(thumbSize, thumbSize)
            {
                Options =
                {
                    RuleOfThirds = true
                }
            };

            var result = cropper.Crop(analysisStream);

            // 2) Load with ImageSharp
            using var image = Image.Load<Rgba32>(inputPath);

            SixLabors.ImageSharp.Rectangle cropRect;
            if (result?.Area != null)
            {
                cropRect = BuildCropRectFromSmartCrop(result.Area, image.Width, image.Height);
                Console.WriteLine($"Smartcrop area: X={cropRect.X}, Y={cropRect.Y}, W={cropRect.Width}, H={cropRect.Height}");
            }
            else
            {
                Console.WriteLine("SmartCrop did not return an area; falling back to center square.");
                cropRect = BuildCenterSquare(image.Width, image.Height);
            }

            // 3) Crop + resize
            Console.WriteLine("Cropping and resizing...");
            image.Mutate(ctx =>
            {
                ctx.Crop(cropRect)
                   .Resize(new Size(thumbSize, thumbSize));
            });

            // 4) Save as WebP
            Console.WriteLine("Saving WebP...");
            var encoder = new WebpEncoder { Quality = Quality };
            image.Save(outputPath, encoder);

            Console.WriteLine("Done.");
            PauseAndExit();
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine("Unhandled error while converting image:");
            Console.Error.WriteLine(ex);
            PauseAndExit();
        }
    }

    private static SixLabors.ImageSharp.Rectangle BuildCropRectFromSmartCrop(Smartcrop.Models.CropRectangle area, int width, int height)
    {
        int x = Math.Max(0, (int)Math.Floor((double)area.X));
        int y = Math.Max(0, (int)Math.Floor((double)area.Y));
        int w = (int)Math.Ceiling((double)area.Width);
        int h = (int)Math.Ceiling((double)area.Height);

        if (w <= 0 || h <= 0)
        {
            Console.Error.WriteLine("SmartCrop area had non-positive size; using center square instead.");
            return BuildCenterSquare(width, height);
        }

        if (x + w > width) w = width - x;
        if (y + h > height) h = height - y;

        return new SixLabors.ImageSharp.Rectangle(x, y, w, h);
    }

    private static SixLabors.ImageSharp.Rectangle BuildCenterSquare(int width, int height)
    {
        int side = Math.Min(width, height);
        int x = (width - side) / 2;
        int y = (height - side) / 2;
        return new SixLabors.ImageSharp.Rectangle(x, y, side, side);
    }

    private static void PauseAndExit()
    {
#if HAS_CONSOLE
        try
        {
            // Try to only wait when a console is reasonably available
            if (!Console.IsOutputRedirected)
            {
                Console.WriteLine();
                Console.WriteLine("Press any key to exit...");
                Console.ReadKey(true);
            }
        }
        catch
        {
            // If there's no console (WinExe), ignore
        }
#endif
    }
}

How to use this:

Console build (you want the pause):

In .csproj set:

<OutputType>Exe</OutputType>
<DefineConstants>$(DefineConstants);HAS_CONSOLE</DefineConstants>

WinExe build (no console / no pause):
- In that config, don’t define HAS_CONSOLE.
- Console.WriteLine calls will still compile and run, they just print to nowhere.

You can even do this per configuration:

<PropertyGroup Condition="'$(Configuration)'=='Debug'">
  <OutputType>Exe</OutputType>
  <DefineConstants>$(DefineConstants);HAS_CONSOLE</DefineConstants>
</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)'=='Release'">
  <OutputType>WinExe</OutputType>
  <!-- No HAS_CONSOLE here -->
</PropertyGroup>

So:

Debug → console app, logging + “press any key”.
Release → WinExe, still logs internally but doesn’t pause or show a console.

2. Robust PowerShell deploy script (auto TFM + RID)

Now let’s make the deploy script stop hardcoding net9.0 / win-x64.

Idea:

Starting from the project folder, look under bin\Release.
Detect the latest TFM directory (e.g. net8.0, net9.0).
Inside that, detect the latest RID directory (e.g. win-x64, win-arm64).
Inside that, use publish\*.exe (latest).

DeployWebsiteThumbnailer.ps1

param(
    # internal flag to avoid infinite elevation loop
    [switch]$NoElevate
)

function Test-IsAdmin {
    $currentUser = New-Object Security.Principal.WindowsPrincipal(
        [Security.Principal.WindowsIdentity]::GetCurrent()
    )
    return $currentUser.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
}

# --- Locate the published EXE under bin\Release\{TFM}\{RID}\publish ---

$scriptDir = Split-Path $PSCommandPath -Parent
$releaseRoot = Join-Path $scriptDir "bin\Release"

if (-not (Test-Path $releaseRoot)) {
    Write-Host "ERROR: Release build folder not found at:"
    Write-Host "  $releaseRoot"
    Write-Host "Run: dotnet publish -c Release"
    Start-Sleep -Seconds 5
    exit 1
}

# Pick latest TFM directory (netX.X)
$tfmDirs = Get-ChildItem $releaseRoot -Directory | Sort-Object Name
if ($tfmDirs.Count -eq 0) {
    Write-Host "ERROR: No TFM directories found under:"
    Write-Host "  $releaseRoot"
    Start-Sleep -Seconds 5
    exit 1
}

$latestTfmDir = $tfmDirs[-1]
Write-Host "Selected TFM: $($latestTfmDir.Name)"

# Inside that, pick latest RID directory (win-x64, win-arm64, etc.)
$ridDirs = Get-ChildItem $latestTfmDir.FullName -Directory | Sort-Object Name
if ($ridDirs.Count -eq 0) {
    Write-Host "ERROR: No RID directories found under:"
    Write-Host "  $($latestTfmDir.FullName)"
    Start-Sleep -Seconds 5
    exit 1
}

$latestRidDir = $ridDirs[-1]
Write-Host "Selected RID: $($latestRidDir.Name)"

$publishDir = Join-Path $latestRidDir.FullName "publish"
if (-not (Test-Path $publishDir)) {
    Write-Host "ERROR: Publish folder not found:"
    Write-Host "  $publishDir"
    Write-Host "Run: dotnet publish -c Release -r $($latestRidDir.Name)"
    Start-Sleep -Seconds 5
    exit 1
}

$exeCandidate = Get-ChildItem $publishDir -Filter "*.exe" | Sort-Object LastWriteTime | Select-Object -Last 1

if (-not $exeCandidate) {
    Write-Host "ERROR: No .exe found in:"
    Write-Host "  $publishDir"
    Start-Sleep -Seconds 5
    exit 1
}

$exePath = $exeCandidate.FullName
Write-Host "Using EXE: $exePath"

# --- Elevation dance ---
if (-not $NoElevate -and -not (Test-IsAdmin)) {
    Write-Host "Not running as administrator. Requesting elevation..."

    $scriptPath = $PSCommandPath
    $args = "-NoProfile -ExecutionPolicy Bypass -File `"$scriptPath`" -NoElevate"

    Start-Process powershell -ArgumentList $args -Verb RunAs -Wait
    exit 0
}

Write-Host "Running with administrative privileges."

# --- 1) Copy EXE to Program Files\Uncharted Limbo Collective ---

$installDir = Join-Path $env:ProgramFiles "Uncharted Limbo Collective"

if (-not (Test-Path $installDir)) {
    New-Item -ItemType Directory -Path $installDir -Force | Out-Null
}

$exeName = "ThumbnailGenerator.exe"
$destExe = Join-Path $installDir $exeName

Copy-Item -Path $exePath -Destination $destExe -Force

Write-Host "Copied $exePath -> $destExe"

# --- 2) Registry: create nested context menu entries ---

$extensions = @(".jpg", ".jpeg", ".png", ".bmp", ".gif", ".webp")

foreach ($ext in $extensions) {
    # Root: Uncharted Limbo Tools (cascading)
    $rootKey = "Registry::HKEY_CLASSES_ROOT\SystemFileAssociations\$ext\shell\UnchartedLimboTools"

    if (-not (Test-Path $rootKey)) {
        New-Item -Path $rootKey -Force | Out-Null
    }

    Set-ItemProperty -Path $rootKey -Name 'MUIVerb' -Value 'Uncharted Limbo Tools'
    Set-ItemProperty -Path $rootKey -Name 'SubCommands' -Value ''

    # Child: Thumbnail Generator (cascading)
    $thumbGenKey = Join-Path $rootKey "shell\ThumbnailGenerator"
    if (-not (Test-Path $thumbGenKey)) {
        New-Item -Path $thumbGenKey -Force | Out-Null
    }

    Set-ItemProperty -Path $thumbGenKey -Name 'MUIVerb' -Value 'Thumbnail Generator'
    Set-ItemProperty -Path $thumbGenKey -Name 'SubCommands' -Value ''

    # --- 512x512 Website Thumbnail ---
    $make512Key = Join-Path $thumbGenKey "shell\Make512"
    if (-not (Test-Path $make512Key)) {
        New-Item -Path $make512Key -Force | Out-Null
    }
    Set-ItemProperty -Path $make512Key -Name 'MUIVerb' -Value 'Make 512x512 Website Thumbnail'

    $cmd512Key = Join-Path $make512Key "command"
    if (-not (Test-Path $cmd512Key)) {
        New-Item -Path $cmd512Key -Force | Out-Null
    }
    $cmd512 = "`"$destExe`" 512 `"%1`""
    Set-ItemProperty -Path $cmd512Key -Name '(default)' -Value $cmd512

    # --- 256x256 Website Logo ---
    $make256Key = Join-Path $thumbGenKey "shell\Make256"
    if (-not (Test-Path $make256Key)) {
        New-Item -Path $make256Key -Force | Out-Null
    }
    Set-ItemProperty -Path $make256Key -Name 'MUIVerb' -Value 'Make 256x256 Website Logo'

    $cmd256Key = Join-Path $make256Key "command"
    if (-not (Test-Path $cmd256Key)) {
        New-Item -Path $cmd256Key -Force | Out-Null
    }
    $cmd256 = "`"$destExe`" 256 `"%1`""
    Set-ItemProperty -Path $cmd256Key -Name '(default)' -Value $cmd256

    Write-Host "Registered menu for $ext"
}

Write-Host "Deployment complete."

# Small pause so you can see the output in the elevated window
if (Test-IsAdmin) {
    Write-Host ""
    Write-Host "Done. Keeping this PowerShell window open for 5 seconds..."
    Start-Sleep -Seconds 5
}

Usage

From the project root:

dotnet publish -c Release -r win-x64   # or any RID, the script finds it
powershell -NoProfile -ExecutionPolicy Bypass -File .\DeployWebsiteThumbnailer.ps1

It’ll:

Find the latest netX.X\{rid}\publish\*.exe.
Copy it to C:\Program Files\Uncharted Limbo Collective\ThumbnailGenerator.exe.
Add nested context menu:

Uncharted Limbo Tools → Thumbnail Generator → Make 512x512 Website Thumbnail
Uncharted Limbo Tools → Thumbnail Generator → Make 256x256 Website Logo

…and keep the elevated PowerShell window open for 5 seconds so you can eyeball any issues.

If you want, you can still hook it into MSBuild’s AfterTargets="Publish" with:

<Target Name="AfterPublishDeploy" AfterTargets="Publish" Condition="'$(Configuration)'=='Release'">
  <Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(ProjectDir)DeployWebsiteThumbnailer.ps1&quot;" />
</Target>

But it’s now robust regardless of TFM/RID.

Good question — this is one of those “sounds obscure, actually super important” MSBuild knobs.

Big picture

In an SDK-style .NET project, the real output is always a .dll (the managed assembly).
UseAppHost controls whether MSBuild also creates a platform-specific .exe launcher for that .dll.

When `UseAppHost = true`

Build output (for an app project) looks like:
- MyApp.dll
- MyApp.exe ← the app host
- plus other deps

The .exe is a tiny native launcher that internally does:

“Load the right .NET runtime”
“Run MyApp.dll’s entry point”

What this means:

You (and Explorer / context menu) can just run:
```
MyApp.exe
```
instead of:
Terminal window
```
dotnet MyApp.dll
```
On publish:
- For single-file publish, the app host is what becomes the single file.
- So for:
```
<PublishSingleFile>true</PublishSingleFile>
```
  you effectively need UseAppHost=true.
It’s platform-specific:
- On win-x64, you get a Windows .exe
- On linux-x64, you get an ELF binary launcher
- etc.

For your use case (right-click shell extension):

You want this. Explorer can only run ThumbnailGenerator.exe directly; it doesn’t know about dotnet ThumbnailGenerator.dll.

When `UseAppHost = false`

Build output:
- MyApp.dll ← only this is the “app”
- No MyApp.exe generated.

What that means:

To run your app, you must use:
Terminal window
```
dotnet MyApp.dll
```
It’s more “portable” in the sense that:
- The same dll can run on any OS/arch that has a compatible .NET runtime installed.
- But you always need the dotnet host.
For single-file publish, disabling UseAppHost doesn’t make much sense:
- Single-file needs an actual executable host to bundle the runtime/assembly.
- In practice, single-file scenarios use an app host under the hood.

For your context menu integration:

If UseAppHost=false, your build output is a DLL and your registry will end up pointing to the dll (or your script has to “guess” an exe that doesn’t exist).
Windows shell handlers cannot run dotnet MyApp.dll automatically; they just try to launch the path as an executable, and you get errors.

TL;DR in your context

You want UseAppHost=true:
- So ThumbnailGenerator.exe exists.
- Your registry entries can call:
```
"C:\Program Files\Uncharted Limbo Collective\ThumbnailGenerator.exe" 512 "%1"
```
- Single-file publish works as expected (that exe becomes the single file).
UseAppHost=false:
- Only ThumbnailGenerator.dll is produced as the app.
- Good for “library-like” command-line tools you always call via dotnet or in container scenarios.
- Bad for “double-clickable” / shell-integrated tools.

If you tell me your final desired behavior (pure console always, or WinExe in Release, etc.), I can sketch the exact PropertyGroup you should keep in the .csproj so you don’t have to think about this again.