Dockyard

The modern home for Windows software.

Dockyard is an open-source Windows package manager and software workspace built with C#, .NET, and WinUI 3.

It brings software discovery, installation, updates, and removal into one polished native application. Rather than replacing existing package managers, Dockyard aims to provide a unified interface across services such as WinGet, Chocolatey, and Scoop.

Think of it as Ninite on steroids, built to feel like a real part of Windows.

Note

Dockyard is currently under active development and is not yet ready for general use.

---

Features

Currently implemented

• Native Windows interface built with WinUI 3
• Installed application discovery
• Search and filtering for installed applications
• Application uninstall support
• Loading, empty, and error states
• Dependency injection-based service architecture
• Separation between application, domain, and infrastructure logic
• Native Windows styling and system backdrop support

Planned

• Unified package search across multiple providers
• WinGet integration
• Chocolatey integration
• Scoop integration
• GitHub Releases integration
• Package information and version details
• Install, update, and uninstall actions
• Bulk application installation
• Bulk update and removal tools
• Installed application management
• Update availability detection
• Import and export of application lists
• Backup and restore workflows
• Saved software collections
• Installation progress and activity history
• Package source and provider selection
• Smart search, categories, and filters
• Optional accounts and cloud synchronisation
• Improved developer-focused package workflows

---

Why Dockyard?

Windows has several capable package managers, but each has its own commands, package catalogue, and workflow.

Dockyard is designed to bring them together behind one consistent interface.

Instead of remembering separate commands or searching across several websites, users will be able to discover and manage software from one native Windows application.

Dockyard is being designed around:

• Simplicity — common software management tasks should be obvious.
• Native design — the application should look and behave like modern Windows software.
• Provider flexibility — users should not be locked into one package source.
• Transparency — Dockyard should clearly show which provider performs each action.
• Safety — destructive operations should require clear confirmation and report useful errors.
• Extensibility — additional providers and services should be possible without redesigning the entire application.

---

Technology

Dockyard is built using:

• C#
• .NET 10
• WinUI 3
• Windows App SDK
• XAML
• Microsoft.Extensions.DependencyInjection
• MVVM-inspired application architecture
• Provider-based package management services

Future infrastructure may also use:

• CommunityToolkit.Mvvm
• Entity Framework Core
• SQLite
• Serilog
• Supabase
• GitHub Actions
• MSIX packaging

---

Architecture

Dockyard uses a layered architecture to keep the interface, business logic, and external package manager integrations separate.

Dockyard
├── Dockyard.App
│   ├── Pages
│   ├── Models
│   ├── Services
│   ├── Controls
│   └── Assets
│
├── Dockyard.Domain
│   ├── Models
│   ├── Enums
│   └── Abstractions
│
├── Dockyard.Application
│   ├── Services
│   └── UseCases
│
├── Dockyard.Infrastructure
│   ├── Persistence
│   ├── Windows
│   └── Diagnostics
│
├── Dockyard.PackageManagers
│   ├── Winget
│   ├── Chocolatey
│   ├── Scoop
│   └── GitHub
│
├── Dockyard.Shared
└── Dockyard.Tests

The exact solution structure may evolve as the project grows.

---

Provider Model

Package managers are intended to be implemented behind shared abstractions.

Dockyard UI
    │
    ▼
Application Services
    │
    ▼
Package Provider Abstraction
    │
    ├── WinGet Provider
    ├── Chocolatey Provider
    ├── Scoop Provider
    └── GitHub Releases Provider

This allows Dockyard to support multiple package sources without coupling the interface directly to individual command-line tools.

---

Current Status

Dockyard is in its early development stage.

The project currently includes the core Windows application shell and the beginning of its installed software management workflow. Installed applications can be retrieved, displayed, searched, and passed to the uninstall service.

The immediate focus is on making the installed applications experience reliable before expanding into package discovery and installation.

---

Requirements

To build Dockyard, you will need:

• Windows 10 version 1809 or later
• Windows 11 (recommended)
• Visual Studio 2022 or newer
• .NET 10 SDK
• Windows App SDK development tools
• Desktop development with C++ workload
• .NET desktop development workload
• Developer Mode enabled in Windows

Some provider integrations may later require their corresponding package manager to be installed.

---

Building from Source

Clone the repository:

git clone <repository-url>
cd Dockyard

Restore dependencies:

dotnet restore

Build the solution:

dotnet build

The application can also be opened and launched directly through Visual Studio.

---

Running Tests

Run the complete test suite with:

dotnet test

---

Development Principles

Contributions should follow several core principles:

1. Keep package-manager-specific behaviour behind provider abstractions.
2. Avoid placing business logic directly inside XAML code-behind files.
3. Keep destructive actions explicit and confirmable.
4. Return useful errors rather than silently ignoring failures.
5. Preserve the native Windows experience.
6. Add tests for service and provider behaviour where practical.
7. Keep the application usable even when one provider is unavailable.

---

Roadmap

Phase 1 — Foundations

• Create the WinUI 3 application
• Configure dependency injection
• Build the initial application shell
• Add installed application discovery
• Add installed application search
• Add uninstall service integration
• Improve installed package metadata
• Add uninstall confirmation and result reporting
• Add automated tests for installed package services

Phase 2 — WinGet

• Search the WinGet catalogue
• View package details
• Install packages
• Detect available updates
• Update installed packages
• Display installation progress
• Handle provider and command errors

Phase 3 — Multiple Providers

• Add Chocolatey support
• Add Scoop support
• Add GitHub Releases support
• Merge and deduplicate search results
• Allow users to select a preferred provider
• Show package provenance clearly

Phase 4 — Advanced Workflows

• Bulk install, update, and removal
• Import and export software lists
• Backup and restore installed application selections
• Saved collections
• Installation history
• Package recommendations and discovery
• Optional account and synchronisation features

Phase 5 — Distribution

• MSIX packaging
• Signed release builds
• Automated GitHub Releases
• Installer and update workflow
• Public preview release

---

Contributing

Dockyard is in active development, so contributions, ideas, and bug reports are welcome.

Before submitting a pull request:

1. Create or reference an issue describing the change.
2. Keep the pull request focused on one feature or fix.
3. Build the complete solution.
4. Run the test suite.
5. Explain any architectural decisions that affect package providers or shared services.

For larger features, open a discussion or issue before implementation so the approach can be agreed upon first.

---

Reporting Bugs

When reporting a bug, include:

• Dockyard version or commit
• Windows version
• Steps to reproduce the problem
• Expected behaviour
• Actual behaviour
• Screenshots or logs where relevant
• The affected package provider, if applicable

Warning

Do not include passwords, access tokens, or other private information in logs or screenshots.

---

Security

Please avoid reporting security vulnerabilities through public issues.

Use the repository's private security reporting feature where available.

Dockyard executes software management operations on the user's computer, so package sources, command arguments, and elevated actions must always be handled carefully.

---

Licence

Dockyard is licensed under the Apache License 2.0.

See the LICENSE file for the complete licence text.

---

Disclaimer

Dockyard is an independent open-source project.

It is not affiliated with Microsoft, Chocolatey Software, Scoop, or the maintainers of packages surfaced through supported providers.

Package availability, metadata, and installation behaviour are controlled by their respective providers and package maintainers.

---

Built for Windows, with Windows.