InstallKit.Abstractions
0.1.0-preview.1
See the version list below for details.
dotnet add package InstallKit.Abstractions --version 0.1.0-preview.1
NuGet\Install-Package InstallKit.Abstractions -Version 0.1.0-preview.1
<PackageReference Include="InstallKit.Abstractions" Version="0.1.0-preview.1" />
<PackageVersion Include="InstallKit.Abstractions" Version="0.1.0-preview.1" />
<PackageReference Include="InstallKit.Abstractions" />
paket add InstallKit.Abstractions --version 0.1.0-preview.1
#r "nuget: InstallKit.Abstractions, 0.1.0-preview.1"
#:package InstallKit.Abstractions@0.1.0-preview.1
#addin nuget:?package=InstallKit.Abstractions&version=0.1.0-preview.1&prerelease
#tool nuget:?package=InstallKit.Abstractions&version=0.1.0-preview.1&prerelease
InstallKit
Build Windows installers (MSI and setup .exe bundles) with plain C# and dotnet build. InstallKit sits on top of WixSharp and the WiX Toolset, and adds a fluent API, an MSBuild SDK, a native modern installer UI, install-time C# handlers and ready-made Azure DevOps pipeline templates.
Status: early preview (0.1). The API may still change between releases. Feedback and issues are welcome.
Why InstallKit
- Installers as code: describe the product, services, shortcuts and prerequisites in C#, with validation errors that point at the problem before WiX runs.
- One command:
dotnet buildpublishes your app, then produces the MSI and, optionally, a singlesetup.exebundle. - Modern look without extra dependencies: branded native dialogs that need nothing on the target machine.
- Install-time code in C#: run static methods during install or uninstall, with no WixSharp types in your code.
- CI included: Azure DevOps templates that build, sign, smoke-test (install and uninstall) and publish.
- Two engines: WixSharp on .NET Framework 4.8, or a WixSharp.Core preview on .NET 10, with the same installer code.
Requirements
- Build machine: Windows and the .NET SDK. WiX is restored as a pinned local tool.
- Target machine: usually nothing beyond Windows. See What target machines need.
Example
using InstallKit;
return InstallerHost.Run(args, plan =>
{
var app = plan.Msi(MsiBuilder.Create("My App")
.WithManufacturer("Contoso")
.WithUpgradeCode("0b6f9a8e-3c1d-4e57-9a43-6d2f1c8b7e10")
.WithPayload("MyApp") // published output of <InstallerPayload>
.WithMainExecutable("MyApp.exe") // gets a Start menu shortcut
.WithDesktopShortcut());
plan.Bundle(BundleBuilder.Create("My App") // optional: one setup.exe with prerequisites
.WithUpgradeCode("5a2e7c41-9d83-4b6f-8e15-c3a09f4d2b77")
.WithNetFramework(NetFrameworkVersion.NetFx48)
.WithMsi(app));
});
<Project Sdk="InstallKit.Sdk/0.1.0">
<ItemGroup>
<InstallerPayload Include="..\MyApp\MyApp.csproj" PublishProperties="RuntimeIdentifier=win-x64;SelfContained=true" />
</ItemGroup>
</Project>
dotnet build -p:Version=1.2.3 publishes MyApp, then writes bin/installer/Release/MyApp.msi and MyAppSetup.exe.
Builders
The fluent builders are the preferred way to describe installers, and every example below uses them. MsiBuilder, BundleBuilder and ServiceBuilder are generated by BuilderGenerator:
- Generated: every settable property gets
WithX(value),WithX(() => value)andWithoutX()automatically, so a new model property needs no builder code. - Hand-written: only the "add one more" helpers in
src/InstallKit.Abstractions/Builders.cs, such asWithPayload,WithService,WithProperty, the shortcut toggles, the custom actions, and the bundle chain methods. - Start from
Create(...): a barenew MsiBuilder()has no defaults and would reset them (for exampleUior the Start menu shortcut).plan.Msi(...)rejects a builder without a name.
You can still set properties directly, with plan.Msi("My App", msi => { msi.Manufacturer = "Contoso"; ... }), for cases a builder method doesn't cover yet. Both produce the same MsiDefinition.
Layout
| Folder | What it is |
|---|---|
src/InstallKit.Abstractions |
Engine-neutral model: MsiDefinition, BundleDefinition, validation, InstallerHost. No WixSharp types. |
src/InstallKit.WixSharp |
The default engine: maps the model to WixSharp v2 on .NET Framework 4.8. |
src/InstallKit.WixSharp.Core |
Preview engine on WixSharp.Core (.NET 10). It compiles the same engine source. |
src/InstallKit.Sdk |
MSBuild SDK: publishes payloads, restores the pinned wix tool, runs the installer program. |
templates/ |
dotnet new installkit project template (generates the upgrade codes for you). |
pipelines/ |
Azure DevOps step, job and stage templates. |
samples/ |
A Windows service with an MSI and a bundle, plus an example azure-pipelines.yml. |
tests/ |
Unit tests for the model, version handling and validation. |
qa/ |
End-to-end QA: a demo installer that uses most features, plus Pester tests that install, upgrade, repair and uninstall it on a Windows agent. |
Getting started
InstallKit is not published to nuget.org yet. Until it is, build the packages from this repository and add them to a local NuGet feed:
git clone https://github.com/lucavoit/InstallKit
cd InstallKit
dotnet pack InstallKit.slnx -c Release # packages end up in artifacts/packages
dotnet nuget add source "$(pwd)/artifacts/packages" --name installkit-local
Then create and build an installer project:
dotnet new install InstallKit.Templates
dotnet new installkit -n MyApp.Installer --product "My App" --manufacturer Contoso --payload ../MyApp/MyApp.csproj --bundle
# add --engine WixSharpCore for the .NET 10 preview engine
# once per repository: pin the WiX toolset
dotnet new tool-manifest
# InstallKit needs the manifest at .config/dotnet-tools.json. The .NET 10 SDK creates dotnet-tools.json
# in the root instead, so if that happens, move it: create a .config folder and move the file into it.
dotnet tool install wix --version 6.0.2
dotnet build MyApp.Installer -p:Version=1.0.0
Building the MSI requires Windows (WiX and the .NET Framework engine). On other OSes the build stops with IK003. You can set InstallKitBuildOnBuild=false there, which still compiles the project.
Using your own build output
You don't need a monorepo, and you don't need InstallKit to build your application. If your pipeline already produces the files to ship (a dotnet publish folder, a build artifact, files downloaded from another job), leave out <InstallerPayload> and give the installer the folder's path:
using InstallKit;
// The pipeline that built the application passes the folder in.
var appDir = Environment.GetEnvironmentVariable("APP_PUBLISH_DIR")
?? throw new InvalidOperationException("Set APP_PUBLISH_DIR to the published application folder.");
return InstallerHost.Run(args, plan =>
{
plan.Msi(MsiBuilder.Create("My App")
.WithManufacturer("Contoso")
.WithUpgradeCode("0b6f9a8e-3c1d-4e57-9a43-6d2f1c8b7e10")
.WithDirectory(appDir) // every file in the folder, keeping its structure
.WithMainExecutable("MyApp.exe")); // relative to the folder; gets the Start menu shortcut
});
<Project Sdk="InstallKit.Sdk/0.1.0">
</Project>
APP_PUBLISH_DIR=/path/to/publish dotnet build MyApp.Installer -p:Version=1.2.3
- Any path works: absolute or relative, on any drive. A relative path is relative to the installer project folder, so prefer absolute paths from a pipeline.
- Checked before WiX runs: a folder that doesn't exist fails with
IK112, and an MSI with no files at all fails withIK110. - Mix and match: call
WithDirectoryseveral times, optionally with a target subfolder (.WithDirectory(docsDir, "docs")), and combine it withWithPayload. - Existing installers in a bundle:
WithMsi("path.msi")chains an MSI that was built elsewhere, andWithExe(path, ...)chains any other setup program. - Your pipeline: the build only needs a Windows agent, the .NET SDK and the pinned
wixtool (dotnet tool restore). The Azure DevOps templates inpipelines/are optional.
How it works
dotnet buildcompiles the installer project as a small .NET Framework console app.- The SDK runs
dotnet tool restoreso thewixversion in.config/dotnet-tools.jsonis used. WiX extensions are pinned to that same version, so newer extensions on NuGet can't silently break the build. - Each
<InstallerPayload>project is published intoobj/installkit/payload/<Name>/, starting from an empty folder each time. - The SDK runs the program.
InstallerHostvalidates the plan before WiX runs, then builds every MSI, then every bundle. - The built files end up in
@(InstallerOutput), and the generated.wxsis kept inobj/installkit/for review.
Validation errors use MSBuild's format (error IK101: ...), so they appear in Visual Studio's error list and in Azure DevOps annotations. Examples:
- A missing
UpgradeCode. The error suggests a newly generated one. - Upgrade codes shared between packages.
- An unknown payload name.
- A main executable that isn't in any payload.
- An
.exeprerequisite without aDetectCondition. - A version that doesn't fit MSI's
255.255.65535limit.
MSBuild properties
| Property | Default | |
|---|---|---|
Version / InstallKitVersion |
1.0.0 |
Prerelease and +metadata suffixes are dropped. |
InstallKitOutputDir |
bin/installer/$(Configuration)/ |
|
InstallKitBuildOnBuild |
true |
Set to false for fast inner-loop builds. |
InstallKitRestoreTools |
true |
Runs dotnet tool restore. |
InstallKitEmitSource |
true |
Keeps the generated .wxs. |
InstallKitSignCommand |
empty | See Signing. |
InstallKitAcceptWixEula |
empty | wix7 accepts the WiX 7 EULA. See WiX version and licence. |
InstallKitEngine |
WixSharp |
WixSharp or WixSharpCore. See Engines. |
To add your own steps, hook targets onto InstallKitBuild: BeforeTargets="InstallKitBuild" or AfterTargets="InstallKitBuild". @(InstallerOutput) holds the built files.
Escape hatch
Anything the model doesn't cover yet can be done with raw WixSharp:
using InstallKit.WixSharp;
MsiBuilder.Create("My App")
.ConfigureWixSharp(project => project.ControlPanelInfo.HelpLink = "https://contoso.com/support");
Code that uses this escape hatch is tied to the WixSharp engine, so move recurring needs into the model instead.
Custom actions
Code that runs on the target machine during the install:
MsiBuilder.Create("My App")
.OnAfterInstall(Setup.Configure, "MODE") // elevated, after files are copied
.OnBeforeInstall(Setup.CheckPrerequisites) // not elevated, before anything changes
.RunAfterInstall("MyApp.exe", "--init-db") // run a program (elevated by default)
.RunBeforeUninstall("MyApp.exe", "--unregister"); // real uninstall only, not upgrades
static class Setup
{
public static void Configure(InstallEvent e)
{
if (e.IsInstalling) File.WriteAllText(e.InstallDir + "mode.txt", e["MODE"] ?? "client");
}
public static void CheckPrerequisites(InstallEvent e)
{
if (!Environment.Is64BitOperatingSystem) e.Cancel("64-bit Windows is required.");
}
}
- Static methods only: pass a static method (
.OnAfterInstall(Setup.Configure)), which must beinternalorpublic. Lambdas, local functions and instance methods are rejected at compile time (IK160–IK162). - Reading properties after install: in
OnAfterInstall, only the properties you list (plusINSTALLDIR) can be read. - How they run: the InstallKit source generator, shipped with
InstallKit.Abstractions, emits one[CustomAction]entry point per handler in your installer assembly. The engine registers each one as an ordinary custom action, and nothing is looked up by reflection at install time. TheWixSharpengine embeds the entry points as managed code;WixSharpCorecompiles them to native code. - Upgrade-safe: handlers receive the engine-neutral
InstallEvent, never WixSharp types, so they keep working when the engine changes. - Advanced cases: use
ConfigureWixSharpwith WixSharp's ownManagedActionorElevatedManagedAction.
UI and branding
Ui |
Dialogs |
|---|---|
Minimal (default) |
Classic WiX: welcome/license, progress |
InstallDir, FeatureTree, ProgressOnly |
Classic WiX variants |
Modern |
Native, branded: one welcome page (license and accept box when set), progress, finish; repair/remove |
ModernInstallDir |
Modern with the install folder and a Browse button on the welcome page |
ModernWpf |
WPF dialogs, which allow custom XAML dialogs (WixSharp engine only) |
MsiBuilder.Create("My App")
.WithModernUi() // or WithModernUi(chooseInstallDir: true), or WithWpfUi()
.WithAccentColor("#0067C0")
.WithLogo("logo.png");
- Branded images: InstallKit generates the banner (493×58) and dialog (493×312) bitmaps in your accent colour with your logo, so even the classic dialogs look current. You can supply your own
.bmpfiles through theBannerImageandBackgroundImagesettings ofBranding. Bundles use the logo too. - Modern (native): the dialogs are built from MSI's own dialog tables, in Segoe UI on the branded background. The target machine needs nothing extra, and it works the same on both engines. The progress, error and repair/remove pages reuse WiX's dialogs, which pick up the same fonts and banner. Its texts are English for now.
- ModernWpf: needs .NET Framework 4.8 on the target machine and adds about 1 MB to the MSI. The
WixSharpCoreengine falls back toModernwith warningIK200. - Silent installs (
/qn) show no UI at all.
Your own dialog (ModernWpf): write a XAML UserControl that derives from WixSharp.UI.WPF.WpfDialog and implements IWpfDialog, and set <InstallKitUseWpf>true</InstallKitUseWpf> in the project. Then add it:
using InstallKit.WixSharp;
MsiBuilder.Create("My App")
.WithWpfUi()
.AddWpfDialog<ServerSettingsDialog>(after: ModernDialog.Welcome);
The dialog stores what the user enters in MSI properties, and your custom actions read them with e["SERVER"]. Custom dialogs are the one WixSharp-specific part of the UI, so keep them in a separate file.
Bundles
A bundle is a single setup .exe that installs its packages in chain order:
plan.Bundle(BundleBuilder.Create("My App")
.WithUpgradeCode("5a2e7c41-9d83-4b6f-8e15-c3a09f4d2b77")
.WithLogo("logo.png")
.WithNetFramework(NetFrameworkVersion.NetFx48)
.WithExe(@"prereqs\vc_redist.x64.exe", e => e.DetectCondition = "VCRedistInstalled") // a Burn variable you set with a search
.WithMsi(app));
WithMsi(app)is an MSI from the same plan. It is always built before the bundle.WithMsi("path.msi")is an existing MSI file.WithNetFramework(...)installs .NET Framework from the web when it is missing.WithExe(path, e => e.DetectCondition = ...)runs any other installer, such as the .NET runtime or VC++ redistributables. A detect condition is required so it is skipped when already installed.
The bundle has its own UpgradeCode, separate from its MSIs' codes.
Signing
InstallKit leaves the signing tool to you; it only decides when files get signed:
- Each MSI is signed right after it is built, before any bundle embeds it.
- For a bundle, the Burn engine is detached and signed, then reattached (
wix burn detach/reattach), and then the bundle itself is signed.
Signing a bundle .exe after the build would leave its engine and the MSIs inside it unsigned, which is why signing happens during the build. You can plug in your tool in either of two ways:
- Command: set
InstallKitSignCommand(or theINSTALLKIT_SIGN_COMMANDenvironment variable). It runs once per file, with{file}replaced by the quoted path:AzureSignTool sign -kvu https://my-vault.vault.azure.net -kvm -kvc my-cert -tr http://timestamp.digicert.com {file} - Code:
plan.UseSigner(new MySigner())with your ownIFileSigner.
Azure DevOps
The templates are layered so you can use a whole stage or individual steps:
pipelines/
steps/setup-tools.yml UseDotNet + dotnet tool restore
steps/build-installer.yml dotnet build with version, output dir and sign command
steps/smoke-test.yml msiexec install + uninstall every MSI, publish the logs
steps/publish-universal.yml publish a folder to Azure Artifacts as a Universal Package
jobs/build-installer.yml Windows job: tools → preBuildSteps → build → postBuildSteps → smoke test → artifact
stages/installer.yml Build stage + Publish stage (skipped for pull requests)
resources:
repositories:
- repository: installkit
type: github
name: lucavoit/InstallKit
endpoint: github
ref: refs/tags/installkit-v0.1.0
stages:
- template: pipelines/stages/installer.yml@installkit
parameters:
setupProject: src/MyApp.Installer/MyApp.Installer.csproj
version: 1.2.$(Build.BuildId)
feed: MyProject/installers # Azure Artifacts feed
packageName: my-app
preBuildSteps: # optional: your signing setup
- task: AzureCLI@2
inputs: { ... }
signCommand: AzureSignTool sign ... {file}
Download a published installer with az artifacts universal download --feed installers --name my-app --version 1.2.345 --path ..
These templates are for your own pipelines. InstallKit itself is built with GitHub Actions; see Contributing.
What target machines need
The installer project only runs on your build machine. A target machine needs:
| Installer uses | Target machine needs |
|---|---|
| Plain MSI (classic UI, services, shortcuts, run commands) | Nothing beyond Windows: Windows Installer is built in |
| Modern UI (native) | Nothing |
Install events (OnAfterInstall, ...), WixSharp engine |
.NET Framework 4.8 (included in Windows 10 1903+, Windows 11 and Windows Server 2022+; install it on older systems) |
Install events, WixSharpCore engine |
Nothing: they are compiled to native code |
ModernWpf UI |
.NET Framework 4.8 |
Bundle (setup .exe) |
Nothing: the bundle engine and its standard UI are native code |
| Your application itself | Whatever it needs. Publish it self-contained (SelfContained=true, as in the sample) or chain its runtime into a bundle |
- No InstallKit or WixSharp at install time: neither is installed on the target machine. Custom-action code is embedded in the MSI and runs during installation only.
Engines
An installer project uses one engine, chosen with a single property. Your installer code stays the same either way:
<PropertyGroup>
<InstallKitEngine>WixSharpCore</InstallKitEngine>
</PropertyGroup>
WixSharp (default) |
WixSharpCore (preview) |
|
|---|---|---|
| Package | InstallKit.WixSharp → WixSharp_wix4 |
InstallKit.WixSharp.Core → WixSharp.Core |
| Installer project targets | .NET Framework 4.8 | .NET 10 (net10.0-windows); WixSharp.Core itself ships for .NET 8 and runs on 10 |
| MSIs, services, shortcuts, run commands, branding, bundles, signing | ✓ | ✓ |
Install events (OnAfterInstall, ...) |
✓ (managed custom actions) | ✓ (compiled to native code; the build machine needs the C++ build tools) |
| Modern UI (native) | ✓ | ✓ |
ModernWpf, custom WPF dialogs |
✓ | not yet: falls back to Modern (IK200) |
Build agent requirements: either engine needs only Windows and the .NET SDK. The SDK pulls in just the engine package you chose, so the other engine is never restored or built. The .NET Framework 4.8 reference assemblies come from NuGet, so the WixSharp engine needs no targeting pack. The pipeline templates are the same for both.
Code shared by both:
- One engine source:
InstallKit.WixSharp.Corecompiles the same engine source asInstallKit.WixSharp, withINSTALLKIT_COREdefined, so the two engines can't drift apart. - Same names: both use the same namespace and type names, so
using InstallKit.WixSharp;andConfigureWixSharpwork with either. WixSharp.Core mirrors WixSharp's API, so most raw WixSharp code carries over too. - Adapting your installer code: the SDK defines
INSTALLKIT_ENGINE_WIXSHARPorINSTALLKIT_ENGINE_WIXSHARPCORE. The sample uses this to register its install event only on the .NET Framework engine.
Core engine notes:
- Native compilation: WixSharp.Core compiles the installer assembly's custom actions to a native DLL with NativeAOT. That needs the C++ build tools ("Desktop development with C++") on the build machine, which Microsoft-hosted Windows agents have. It also adds roughly 10–60 seconds per build.
- Remaining gap: the WPF dialogs. WixSharp.Core needs them in a separate .NET Framework UI project; the native
ModernUI covers the default look without it.
samples/HelloService.Installer.Core builds the same sample with the Core engine. CI builds both.
WiX version and licence
InstallKit uses whichever wix version is pinned in .config/dotnet-tools.json; the default is 6.0.2, the version WixSharp recommends. WiX extensions are pinned to the same version automatically.
| WiX | Licence of the official binaries | Fee | Acceptance |
|---|---|---|---|
| 5.0.2 and older | MS-RL (open source) | None | Not needed |
| 6.0.x | MS-RL source + Open Source Maintenance Fee EULA | Owed by users who generate revenue with WiX | Not enforced by the build |
| 7.x | MS-RL source + OSMF EULA | Owed by revenue-generating users with ≥ US$10,000 annual gross revenue | Required: the build fails with IK004 until you set InstallKitAcceptWixEula |
In every version the source code stays MS-RL. The fee applies only to the official binaries, and binaries you build from source yourself are not covered by it. This summarises the EULA files shipped in the wix NuGet packages; it is not legal advice.
Changing the WiX version
Run this in the folder that contains .config/:
dotnet tool update wix --version 5.0.2 --allow-downgrade # or 6.0.2 / 7.0.1
That is the only change needed: local builds and the pipeline templates both run dotnet tool restore. For WiX 7 or later, also accept its EULA in the installer project:
<PropertyGroup>
<InstallKitAcceptWixEula>wix7</InstallKitAcceptWixEula>
</PropertyGroup>
Only WiX 6 and 7 are confirmed to work with WixSharp 2.14.2; test 5.0.2 before you rely on it.
Contributing
Issues and pull requests are welcome. Please open an issue first for larger changes. CI runs on every pull request and push to main: unit tests, packing, both sample installers and the end-to-end QA. Run the unit tests locally with:
dotnet test tests/InstallKit.Abstractions.Tests -c Release
QA
The qa jobs in .github/workflows/ci.yml build the QA demo installer as 1.0.0 and 1.1.0 with each engine, then run qa/tests/Installer.Tests.ps1 on a GitHub-hosted Windows runner. It checks:
- Install: the Add/Remove Programs entry, payload and extra files, Start menu and desktop shortcuts, the running service, the
OnAfterInstallhandler andRunAfterInstallcommand, and a property passed on the command line. - Upgrade: 1.1.0 replaces 1.0.0, and
RunBeforeUninstalldoes not run. - Repair: a deleted file is restored.
- Uninstall:
RunBeforeUninstallruns, and the service, files, shortcuts and Add/Remove Programs entry are removed. - Bundle:
QaDemoSetup.exeinstalls and uninstalls the same product.
A separate consumer job checks the route a user without a monorepo takes. qa/consumer/Build-Consumer.ps1 creates an installer project outside this repository from the packed NuGet packages and the dotnet new installkit template, points it at a folder of prebuilt files, and builds an MSI and a bundle. qa/tests/Consumer.Tests.ps1 then installs and removes it. This is the test that proves the packages work without this repository.
The tests change the machine, so only run them on a disposable one. Locally, from an elevated PowerShell:
dotnet build qa/QaDemo.Installer -c Release -p:InstallKitVersion=1.0.0 -p:InstallKitOutputDir=$PWD/out/1.0.0/
dotnet build qa/QaDemo.Installer -c Release -p:InstallKitVersion=1.1.0 -p:InstallKitOutputDir=$PWD/out/1.1.0/
./qa/tests/Invoke-Qa.ps1 -V1 out/1.0.0 -V2 out/1.1.0
License
InstallKit is released under the MIT License. WixSharp and the WiX Toolset have their own licences; see WiX version and licence.
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net5.0 was computed. net5.0-windows was computed. net6.0 was computed. net6.0-android was computed. net6.0-ios was computed. net6.0-maccatalyst was computed. net6.0-macos was computed. net6.0-tvos was computed. net6.0-windows was computed. net7.0 was computed. net7.0-android was computed. net7.0-ios was computed. net7.0-maccatalyst was computed. net7.0-macos was computed. net7.0-tvos was computed. net7.0-windows was computed. net8.0 was computed. net8.0-android was computed. net8.0-browser was computed. net8.0-ios was computed. net8.0-maccatalyst was computed. net8.0-macos was computed. net8.0-tvos was computed. net8.0-windows was computed. net9.0 was computed. net9.0-android was computed. net9.0-browser was computed. net9.0-ios was computed. net9.0-maccatalyst was computed. net9.0-macos was computed. net9.0-tvos was computed. net9.0-windows was computed. net10.0 was computed. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. |
| .NET Core | netcoreapp2.0 was computed. netcoreapp2.1 was computed. netcoreapp2.2 was computed. netcoreapp3.0 was computed. netcoreapp3.1 was computed. |
| .NET Standard | netstandard2.0 is compatible. netstandard2.1 was computed. |
| .NET Framework | net461 was computed. net462 was computed. net463 was computed. net47 was computed. net471 was computed. net472 was computed. net48 was computed. net481 was computed. |
| MonoAndroid | monoandroid was computed. |
| MonoMac | monomac was computed. |
| MonoTouch | monotouch was computed. |
| Tizen | tizen40 was computed. tizen60 was computed. |
| Xamarin.iOS | xamarinios was computed. |
| Xamarin.Mac | xamarinmac was computed. |
| Xamarin.TVOS | xamarintvos was computed. |
| Xamarin.WatchOS | xamarinwatchos was computed. |
-
.NETStandard 2.0
- BuilderGenerator (>= 3.1.0)
NuGet packages (2)
Showing the top 2 NuGet packages that depend on InstallKit.Abstractions:
| Package | Downloads |
|---|---|
|
InstallKit.WixSharp.Core
WixSharp.Core (WiX 4+, .NET 10) engine for InstallKit. Preview. |
|
|
InstallKit.WixSharp
WixSharp (WiX 4+, .NET Framework) engine for InstallKit. |
GitHub repositories
This package is not used by any popular GitHub repositories.
| Version | Downloads | Last Updated |
|---|---|---|
| 1.0.0-rc.2 | 49 | 11/17/2026 |
| 1.0.0-rc.1 | 84 | 11/15/2026 |
| 0.1.0-preview.1 | 116 | 11/14/2026 |