Microsoft winapp CLI: Automation for Windows Development

TL;DR: Microsoft has released winapp, an open-source CLI that automates tedious Windows development tasks (SDKs, manifests, certificates, packaging). If you develop for Windows with Electron, .NET, C++, Rust, or Dart, this will save you hours of manual configuration.

What happened

Microsoft announced on January 22, 2026, the Windows App Development CLI (affectionately called winapp), an open-source command-line tool that promises to end the headache of configuring a Windows development environment.

The tool was created especially for developers working outside Visual Studio or MSBuild – think of web developers using Electron, C++ developers with CMake, or anyone working with .NET, Rust, or Dart. winapp consolidates tasks that previously required multiple manual steps into single, direct commands.

The project is already in public preview on GitHub, and Microsoft is actively seeking community feedback to guide the development of upcoming features.

Why this matters

If you've ever tried to develop a Windows app outside Visual Studio, you know the confusion of managing SDKs, creating giant XML manifests, generating development certificates, and dealing with MSIX packaging. It was a manual process, full of obscure details and prone to errors.

For you as a developer:

• Less manual configuration: Environment setup that used to take hours is now a single command

• Support for modern tools: Works with Electron, Rust, CMake, and other popular toolchains

• Easy access to Windows APIs: Use Windows AI, notifications, security without complications

• Simplified CI/CD: Ready-to-use GitHub Actions and Azure DevOps actions

The big difference:

Many modern Windows APIs (AI, notifications, MCP Hosts) require Package Identity - something that previously forced you to package and install the complete app just to test a feature. With winapp, you add identity to your development executable and continue using your normal workflow. This changes everything.

Technical Context

The winapp CLI abstracts several complexities specific to the Windows ecosystem:

The problem it solves

Traditional Windows development typically involves:

• Downloading and configuring the Windows SDK (and sometimes Windows App SDK)

• Manually creating appxmanifest.xml files

• Generating self-signed certificates for development

• Creating image assets in multiple sizes

• Configuring MSIX packaging

• Installing certificates into the system

Each step has scattered documentation, undocumented pitfalls, and different versions across SDKs.

How the CLI works

# Antes: 10+ passos manuais entre docs e ferramentas# Agora: um comando> winapp init

The init command does everything:

• Automatic download of the necessary SDK

• Generates projections (C++/WinRT initially)

• Creates a configured manifest

• Generates standard assets

• Creates a development certificate

• Configures dependencies

Package Identity without full packaging

This is the most interesting feature. Many modern Windows APIs check if your app has Package Identity. Previously, this meant:

1. Creating a full MSIX package

2. Installing it on the system

3. Running the installed version to test

4. Repeating with every change

Now with winapp:

> winapp create-debug-identity my-app.exe

This injects Package Identity directly into the executable, allowing you to continue using npm start, cargo run, or any normal development command while testing APIs that require identity.

What changes in practice

If you develop with Electron:

• ✅ Install via npm: npm install --save-dev @microsoft/winappcli

• ✅ Use winapp node add-electron-debug-identity for debugging with Windows AI

• ✅ Create pre-configured C++ or C# native addons with Windows SDK

• ✅ Access Windows AI APIs directly from Node.js with @microsoft/winapp-windows-ai

If you use .NET, C++, Rust, or Dart:

• ✅ Install via WinGet: winget install microsoft.winappcli

• ✅ Configure environment: winapp init

• ✅ Generate manifest: winapp manifest create

• ✅ Create dev certificate: winapp cert generate

• ✅ Final Package: winapp pack ./build-output --cert ./cert.pfx

If you work with CI/CD:

• ✅ Use GitHub/Azure DevOps action: setup-WinAppCli

• ✅ Automate packaging in the pipeline

• ✅ winapp restore recreates the exact environment on any machine

Timeline:

• Now: Public preview available - test and provide feedback

• Next months: More commands based on community feedback

• Future: Possible integration with more toolchains and frameworks

Main CLI commands

winapp init

Configures a complete workspace with SDK, projections, manifest, assets, and certificate.

# Na raiz do seu projeto> winapp init

winapp create-debug-identity

Adds Package Identity to an executable for debugging APIs that require identity.

> winapp create-debug-identity my-app.exe

winapp manifest update-assets

Updates all image assets in the manifest from a logo.

> winapp manifest update-assets C:\images\logo.png

winapp cert generate

Creates a self-signed certificate for development and optionally installs it on the system.

> winapp cert generate

winapp pack

Packages the application as MSIX, ready for distribution.

> winapp pack ./build-output --cert ./devcert.pfx

winapp restore

Recreates the development environment based on the project configuration (useful for CI/CD and new team developers).

> winapp restore

Special Integration with Electron

Microsoft created first-class integration with Electron via npm package:

Debugging with Package Identity:

# Injeta identity no processo Electron em execução> winapp node add-electron-debug-identity> npm start  # Agora com acesso a Windows AI APIs

Pre-configured native addons:

# Scaffolding de addon C++ ou C# com Windows SDK> winapp node create-addon

Windows AI directly from Node.js:

// Usando @microsoft/winapp-windows-aiconst { LanguageModel } = require('@microsoft/winapp-windows-ai');const model = await LanguageModel.create();const response = await model.generate('Explain quantum computing');

How to get started

General Installation (WinGet):

winget install microsoft.winappcli

Installation for Electron projects (npm):

npm install --save-dev @microsoft/winappcli

Quick start guides:

• Electron

• .NET

• C++/CMake

• Rust

Useful resources:

• GitHub Repository (complete documentation)

• Samples (ready-to-use examples)

• GitHub/Azure DevOps Action (for CI/CD)

Community opinion

The announcement was well-received, especially by developers working with cross-platform frameworks. The main historical complaint was the complexity of Windows configuration compared to macOS or Linux – winapp addresses exactly that.

Highlighted positive points:

• Open-source from the start (community can contribute)

• Focus on modern toolchains (not just Visual Studio)

• Package Identity for debugging solves a real problem

• Electron integration is well thought out

Concerns raised:

• Still in preview - may have bugs and breaking changes

• Limited scenario coverage (team is asking for feedback)

• Documentation still being expanded

What's next

Microsoft made it clear that winapp is in its early stages and asked for active community feedback. The roadmap will be driven by:

• Real-world use cases reported by developers

• Feature requests on GitHub

• Development scenarios not yet covered

The team is especially interested in:

• New useful commands

• Integrations with other toolchains

• Improvements in debugging experience

• Automation of more manual tasks

Credits: This article is based on the official announcement published by Nikola Metulev (Product Manager, Windows Platform & Developer) on the Microsoft Windows Developer Blog.

Sources:

• Official Announcement - Windows Developer Blog

• GitHub Repository - WinAppCli

• npm package - @microsoft/winappcli

• Setup GitHub Action

• Windows AI npm package

Related:

• Package Identity Documentation

• MSIX Packaging Guide

Conclusion

The winapp CLI is great news for anyone developing Windows apps outside the traditional Microsoft ecosystem. If you use Electron, Rust, or any modern toolchain, it's worth checking out.

It's especially useful if you want to experiment with Windows AI APIs, notifications, or other modern features without diving into packaging complexity.

The fact that it's open-source and in preview means there's a real opportunity to shape the tool through feedback. If you have specific pain points in Windows development, now is the time to report them.

Suggested next step: Install the CLI, run winapp init in a test project, and see how much time you save compared to manual setup. Then, share feedback on GitHub to help improve the tool.

Good luck, and less time configuring means more time coding! 🚀