Quick Start Guide: Windows Template Studio for Modern UWP Apps

This guide walks through installing and using Windows Template Studio, explains generated project structure and patterns, shows how to add features and customize code, and offers tips for taking the scaffolded app into production.

Who this guide is for

Developers new to UWP who want a practical, structured starting point.
Experienced .NET/UWP devs who want to accelerate project setup.
Teams that want consistent app scaffolds and architecture across projects.

1. Install prerequisites

Before using Windows Template Studio, make sure you have:

Visual Studio 2019 or later with the “Universal Windows Platform development” workload installed.
UWP SDK (Windows 10 SDK) appropriate for your target Windows version.
The app must target a supported Windows ⁄₁₁ SDK — check project properties after scaffolding.

To add Windows Template Studio:

Open Visual Studio.
Use Extensions > Manage Extensions and search for “Windows Template Studio”.
Install the extension and restart Visual Studio.

2. Create a new project with Windows Template Studio

In Visual Studio: File > New > Project.
Search for and select “Windows Template Studio” (the template name may appear as “Windows Template Studio (UWP)”).
Click Next, name your project, choose location and solution options, then click Create.
The WinTS wizard opens. It guides you through app configuration in a few steps:
- Project Type and Framework (e.g., Navigation Pane, Blank, or Split; framework options like MVVM Toolkit or Reactive)
- Features (pages, services, background tasks, settings, authentication)
- Controls and Extensions (e.g., specific UI controls or patterns)
- Finalize and generate

Choose options based on your app needs; you can always add or remove features later, but starting with the right structure saves refactors.

3. Understand the generated project structure

WinTS scaffolds a well-organized solution. Typical folders and files:

App.xaml / App.xaml.cs — Application entry, lifecycle, and root Frame initialization.
Views/ — XAML pages and their code-behind (e.g., MainPage.xaml).
ViewModels/ — ViewModel classes following MVVM (when chosen).
Services/ — Interfaces and implementations for data access, dialogs, telemetry, etc.
Models/ — Plain data models and DTOs.
Helpers/Utilities/ — Common utilities, converters, and extensions.
Assets/ — Images, icons, and app resources.
Features/ — If using a feature-based structure, grouped feature folders.
Services/NavigationService, DialogService, and DispatcherService — standard infrastructure for navigation, user prompts, and threading.

Key patterns and decisions you’ll see:

Dependency injection or a simplified service locator pattern to resolve services.
MVVM architecture for separation of UI and logic (common choices: MVVM Toolkit, Prism, ReactiveUI).
Shell/Navigation structure (Hamburger menu, Tabbed, or Top navigation).
Unit-testable code boundaries with interfaces for services.

4. Explore core generated code

App.xaml.cs: registers services and configures navigation. Look for a ConfigureServices or RegisterServices method where DI container entries are added.
MainViewModel and MainPage: show how commands and navigation are wired. Commands are typically implemented via RelayCommand/DelegateCommand.
NavigationService: abstracts navigation to make ViewModels testable without direct Frame dependency.
DataService / IDataService: example implementation for data access; swap it for real backends or mock versions for tests.
SettingsService and ThemeSelectorService: show best practices for persisting user preferences and switching themes.

Reading these files is essential to understand how the pieces interact before extending the app.

5. Add or remove features

You can customize the scaffold after generation:

To add pages or services manually, follow the project’s existing patterns: create View + ViewModel pairs, register services in the same DI entry point, and add navigation routes via NavigationService.
To remove features, delete associated files and registrations, and update navigation and menu items.
For more features, rerun a new WinTS project to compare configurations, or use community templates/extensions compatible with the generated structure.

6. Styling and UI customization

WinTS provides a base theme and resources. Customize safely:

Edit ResourceDictionaries (Themes/Generic.xaml or ThemeResources) to override colors, fonts, and styles.
Use the Fluent design principles: AcrylicBrush, Reveal, and adaptive layout (VisualStateManager with AdaptiveTriggers).
Keep styles centralized to maintain consistent look and to make theme switching easier.

7. Data access and offline support

Replace the placeholder DataService with a concrete implementation:

For REST APIs: use HttpClient with typed clients and resilience policies (e.g., Polly) for retries and timeouts.
For local caching: use SQLite (e.g., Microsoft.Data.Sqlite) or Windows.Storage.ApplicationData for small data sets.
Implement repository patterns and abstract caching logic behind interfaces to keep ViewModels agnostic to data sources.

8. Background tasks, notifications, and lifecycle

WinTS can scaffold background tasks and notifications. When adding these:

Register background tasks in the Package.appxmanifest and request permissions where necessary.
Respect app lifecycle: save state in Suspending, restore in Resuming/OnLaunched using the SuspensionManager pattern.
Use ToastNotificationManager for user notifications and BackgroundTaskBuilder for tasks like time-triggered or push notifications.

9. Testing and CI

Unit tests: create tests for ViewModels and services by mocking IDataService, INavigationService, etc. Use MSTest, NUnit, or xUnit.
UI tests: use WinAppDriver or Appium for end-to-end tests of UI flows.
CI: build UWP apps in Azure DevOps or GitHub Actions. Use Hosted Windows runners to compile and run tests. Sign packages and produce MSIX for deployment.

10. Packaging and deployment

Configure Package.appxmanifest: identity, capabilities, visual assets, and supported architectures.
For store distribution: create an MSIX package and follow Microsoft Store submission steps, including flighting and in-app purchasing config if needed.
For enterprise distribution: sign the package and distribute via Intune or side-loading methods.

11. Performance and diagnostics

Use Visual Studio Diagnostic Tools and Windows Performance Recorder to profile CPU, memory, and rendering.
Reduce UI thread work—use async/await and the Dispatcher for UI interactions.
Optimize images and assets; use .scale-XXX and efficient image formats.
Monitor telemetry with Application Insights or a lightweight custom telemetry service.

12. Migrating or extending beyond UWP

If you plan to reach multiple Windows platforms:

Consider migrating to WinUI 3 and Project Reunion (Windows App SDK) for modern desktop apps that decouple from OS releases.
Port View/ViewModel patterns and services; the scaffolding logic remains applicable, though project files and packaging differ.

13. Common pitfalls and tips

Don’t edit generated wiring (like automatic registrations) without understanding service location—breaks can be subtle.
Keep ViewModels testable: avoid direct UI references.
Version your target SDK explicitly to avoid build surprises on different machines.
Leverage community samples from the Windows Template Studio GitHub repo to see real-world examples.

Example: Add a new page and ViewModel (concise steps)

Add a new XAML Page (MyFeaturePage.xaml) and code-behind.
Add MyFeatureViewModel.cs in ViewModels; implement INotifyPropertyChanged or inherit from BaseViewModel.
Register ViewModel and any services in the same registration area used by other services.
Add a navigation entry (label/icon) to the Shell/Menu and map it in NavigationService.
Implement commands in the ViewModel and bind them in XAML.

Conclusion

Windows Template Studio accelerates UWP app development with a solid, opinionated scaffold, helping you adopt MVVM, dependency injection, and other best practices from the start. Use the generated structure as a guide, customize cautiously, and apply standard software engineering practices—testing, CI, and profiling—to deliver robust, maintainable apps.