GitHub C# Daily Trending

Devolutions/UniGetUI

UniGetUI: The Graphical Interface for your package managers. Could be terribly described as a package manager manager to manage your package managers

WARNING: wingetui_•com and unigetui_•com are fake websites hosted by a third-party. please do NOT trust them

Devolutions UniGetUI

Important

Major announcement: UniGetUI has entered its next chapter with Devolutions. Read the blog post and the official press release.

UniGetUI is an intuitive GUI for the most common CLI package managers on Windows 10 and 11, including WinGet, Scoop, Chocolatey, pip, npm, .NET Tool, PowerShell Gallery, and more. With UniGetUI, you can discover, install, update, and uninstall software from multiple package managers through one interface.

View more screenshots here

Check out the Package Managers section for more details!

Disclaimer: UniGetUI is not affiliated with the package managers it integrates with. Packages are provided by third parties, so review sources and publishers before installation.

Caution

The official website for UniGetUI is https://devolutions.net/unigetui/.
The official source repository is https://github.com/Devolutions/UniGetUI.
Any other website should be considered unofficial, despite what they may say.

🔒 Found a security issue? Please report it via the Devolutions security page

Project stewardship

UniGetUI was created by Martí Climent and is now maintained by Devolutions. The project remains free, open source, and MIT-licensed. Devolutions' stewardship brings long-term investment, structured governance, stronger security processes, and a roadmap for broader enterprise readiness while keeping UniGetUI standalone and community-driven.

Read more in the Devolutions announcement and the official press release.

Installation

There are multiple ways to install UniGetUI — choose whichever one you prefer!

Microsoft Store installation (recommended)

Download UniGetUI installer:

Click here to download UniGetUI

Install UniGetUI via WinGet:

winget install --exact --id Devolutions.UniGetUI --source winget

Install UniGetUI via Scoop:

scoop bucket add extras
scoop install extras/unigetui

Install UniGetUI via Chocolatey:

choco install wingetui

Update UniGetUI

UniGetUI has a built-in autoupdater. However, it can also be updated like any other package within UniGetUI (since UniGetUI is available from WinGet, Scoop and Chocolatey).

Features

Install, update, and remove software from your system easily at one click: UniGetUI combines the packages from the most used package managers for windows: Winget, Chocolatey, Scoop, Pip, Npm and .NET Tool.
Discover new packages and filter them to easily find the package you want.
View detailed metadata about any package before installing it. Get the direct download URL or the name of the publisher, as well as the size of the download.
Easily bulk-install, update, or uninstall multiple packages at once selecting multiple packages before performing an operation
Automatically update packages, or be notified when updates become available. Skip versions or completely ignore updates on a per-package basis.
The system tray icon will also show the available updates and installed packages, to efficiently update a program or remove a package from your system.
Easily customize how and where packages are installed. Select different installation options and switches for each package. Install an older version or force to install a 32 bit architecture. [But don't worry, those options will be saved for future updates for this package*]
Share packages with your friends using generated package links.
Export custom lists of packages to then import them to another machine and install those packages with previously specified, custom installation parameters. Setting up machines or configuring a specific software setup has never been easier.
Backup your packages to a local file to easily recover your setup in a matter of seconds when migrating to a new machine*

Package Managers

NOTE: All package managers do support basic install, update, and uninstall processes, as well as checking for updates, finding new packages, and retrieving details from a package.

✅: Supported on UniGetUI
☑️: Not directly supported but can be easily achieved
⚠️: May not work in some cases
❌: Not supported by the Package Manager

Translations

UniGetUI translations are maintained directly in this repository. For the current language list, completion status, and per-language contributor attributions, see TRANSLATION.md. If you spot a translation issue or want to improve a locale, please open an issue or submit a pull request.

Screenshots

Contributions

UniGetUI continues to grow thanks to its community of contributors. Devolutions is grateful to everyone who contributes code, translations, documentation, testing, and feedback to the project.

Frequently asked questions

Q: I am unable to install or upgrade a specific Winget package! What should I do?

A: This is likely an issue with Winget rather than UniGetUI.

Please check if it's possible to install/upgrade the package through PowerShell or the Command Prompt by using the commands winget upgrade or winget install, depending on the situation (for example: winget upgrade --id Microsoft.PowerToys).

If this doesn't work, consider asking for help at Winget's project page.

Q: The name of a package is trimmed with ellipsis — how do I see its full name/id?

A: This is a known limitation of Winget.

For more details, see this issue: https://github.com/microsoft/winget-cli/issues/2603.

Q: My antivirus is telling me that UniGetUI is a virus! / My browser is blocking the download of UniGetUI!

A: A common reason apps (i.e., executables) get blocked and/or detected as a virus — even when there's nothing malicious about them, like in the case of UniGetUI — is because a relatively large amount of people are not using them.

Combine that with the fact that you might be downloading something recently released, and blocking unknown apps is in many cases a good precaution to take to prevent actual malware.

Since UniGetUI is open source and safe to use, whitelist the app in the settings of your antivirus/browser.

Q: Are Winget/Scoop packages safe?

A: UniGetUI, Microsoft, and Scoop aren't responsible for the packages available for download, which are provided by third parties and can theoretically be compromised.

Microsoft has implemented a few checks for the software available on Winget to mitigate the risks of downloading malware. Even so, it's recommended that you only download software from trusted publishers.

Check out the Wiki for more information!

Command-line parameters:

Check out the full list of parameters here

fullstackhero/dotnet-starter-kit

Production Grade Cloud-Ready .NET 10 Starter Kit (Web API + Blazor Client) with Multitenancy Support, and Clean/Modular Architecture that saves roughly 200+ Development Hours! All Batteries Included.

FullStackHero .NET 10 Starter Kit

An opinionated, production-first starter for building multi-tenant SaaS and enterprise APIs on .NET 10. You get ready-to-ship Identity, Multitenancy, Auditing, Webhooks, caching, mailing, jobs, storage, health, OpenAPI, and OpenTelemetry — wired through Minimal APIs, Mediator, and EF Core.

Quick Start

You get the complete source code — BuildingBlocks, Modules, and Playground — with full project references. No black-box NuGet packages; you own and can modify everything.

Option 1: FSH CLI (recommended)

dotnet tool install -g FullStackHero.CLI
fsh new MyApp
cd MyApp
dotnet run --project src/Playground/MyApp.AppHost

The interactive wizard lets you pick your database provider and whether to include Aspire. Run fsh doctor to verify your environment first.

Option 2: dotnet new template

dotnet new install FullStackHero.NET.StarterKit
dotnet new fsh -n MyApp
cd MyApp
dotnet run --project src/Playground/MyApp.AppHost

Option 3: Clone the repository

git clone https://github.com/fullstackhero/dotnet-starter-kit.git MyApp
cd MyApp
dotnet restore src/FSH.Starter.slnx
dotnet run --project src/Playground/FSH.Starter.AppHost

Option 4: GitHub Codespaces

Click "Use this template" on GitHub, or open in Codespaces for a zero-install experience with .NET 10, Docker, and Aspire pre-configured.

Prerequisites: .NET 10 SDK, Docker (for Postgres/Redis via Aspire)

FSH CLI Commands

Command	Description
`fsh new [name]`	Create a new project with interactive wizard
`fsh doctor`	Check your environment (SDK, Docker, Aspire, ports)
`fsh info`	Show CLI/template versions and available updates
`fsh update`	Update CLI tool and template to latest

# Non-interactive with options
fsh new MyApp --db sqlserver --no-aspire --no-git

# Dry run (preview without creating)
fsh new MyApp --dry-run

Why teams pick this

Modular vertical slices: drop Modules.Identity, Modules.Multitenancy, Modules.Auditing, Modules.Webhooks into any API and let the module loader wire endpoints.
Battle-tested building blocks: persistence + specifications, distributed caching, mailing, jobs via Hangfire, storage abstractions, and web host primitives (auth, rate limiting, versioning, CORS, exception handling).
Cloud-ready out of the box: Aspire AppHost spins up Postgres + Redis + the Playground API with OTLP tracing enabled.
Multi-tenant from day one: Finbuckle-powered tenancy across Identity and your module DbContexts; helpers to migrate and seed tenant databases on startup.
Observability baked in: OpenTelemetry traces/metrics/logs, structured logging, health checks, and security/exception auditing.

Stack highlights

.NET 10, C# latest, Minimal APIs, Mediator for commands/queries, FluentValidation.
EF Core 10 with domain events + specifications; Postgres by default, SQL Server ready.
ASP.NET Identity with JWT issuance/refresh, roles/permissions, rate-limited auth endpoints.
Hangfire for background jobs; Redis-backed distributed cache; pluggable storage.
API versioning, rate limiting, CORS, security headers, OpenAPI (Swagger) + Scalar docs.

Repository map

src/BuildingBlocks — Core abstractions (DDD primitives, exceptions), Persistence, Caching, Mailing, Jobs, Storage, Web host wiring.
src/Modules — Identity, Multitenancy, Auditing, Webhooks runtime + contracts projects.
src/Playground — Reference host (FSH.Starter.Api), Aspire app host (FSH.Starter.AppHost), Postgres migrations.
src/Tools/CLI — The fsh CLI tool source code.
src/Tests — Architecture tests that enforce layering and module boundaries.
deploy — Docker, Dokploy, and Terraform deployment scaffolding.

Run it now (Aspire)

Prereqs: .NET 10 SDK, Aspire workload, Docker running (for Postgres/Redis).

Restore: dotnet restore src/FSH.Starter.slnx
Start everything: dotnet run --project src/Playground/FSH.Starter.AppHost
- Aspire brings up Postgres + Redis containers, wires env vars, launches the Playground API, and enables OTLP export on https://localhost:4317.
Hit the API: https://localhost:5285 (Swagger/Scalar and module endpoints under /api/v1/...).

Run the API only

Set env vars or appsettings for DatabaseOptions__Provider, DatabaseOptions__ConnectionString, DatabaseOptions__MigrationsAssembly, CachingOptions__Redis, and JWT options.
Run: dotnet run --project src/Playground/FSH.Starter.Api
The host applies migrations/seeding via UseHeroMultiTenantDatabases() and maps module endpoints via UseHeroPlatform.

Bring the framework into your API

Reference the building block and module projects you need.
In Program.cs:
- Register Mediator with assemblies containing your commands/queries and module handlers.
- Call builder.AddHeroPlatform(...) to enable auth, OpenAPI, caching, mailing, jobs, health, OTel, rate limiting.
- Call builder.AddModules(moduleAssemblies) and app.UseHeroPlatform(p => p.MapModules = true);.
Configure connection strings, Redis, JWT, CORS, and OTel endpoints via configuration. Example wiring lives in src/Playground/FSH.Starter.Api/Program.cs.

Included modules

Identity — ASP.NET Identity + JWT issuance/refresh, user/role/permission management, profile image storage, login/refresh auditing, health checks.
Multitenancy — Tenant provisioning, migrations, status/upgrade APIs, tenant-aware EF Core contexts, health checks.
Auditing — Security/exception/activity auditing with queryable endpoints; plugs into global exception handling and Identity events.
Webhooks — Tenant-scoped webhook subscriptions with HMAC-signed delivery, retry policies, and delivery logs.

Development notes

Target framework: net10.0; nullable enabled; analyzers on.
Tests: dotnet test src/FSH.Starter.slnx (includes architecture guardrails).
Want the deeper story? Start with docs/framework/architecture.md and the developer cookbook in docs/framework/developer-cookbook.md.

Built and maintained by Mukesh Murugan for teams that want to ship faster without sacrificing architecture discipline.

kgrzybek/modular-monolith-with-ddd

Full Modular Monolith application with Domain-Driven Design approach.

Modular Monolith with DDD

Full Modular Monolith .NET application with Domain-Driven Design approach.

Announcement

Learn, use and benefit from this project only if:

You condemn Russia and its military aggression against Ukraine
You recognize that Russia is an occupant that unlawfully invaded a sovereign state
You support Ukraine's territorial integrity, including its claims over temporarily occupied territories of Crimea and Donbas
You reject false narratives perpetuated by Russian state propaganda

Otherwise, leave this project immediately and educate yourself.

Putin, idi nachuj.

CI

FrontEnd application

FrontEnd application : Modular Monolith With DDD: FrontEnd React application

1. Introduction

1.1 Purpose of this Repository

3.2 Module Level View

3.3 API and Module Communication

3.4 Module Requests Processing via CQRS

3.5 Domain Model Principles and Attributes

3.6 Cross-Cutting Concerns

3.7 Modules Integration

3.8 Internal Processing

3.9 Security

3.10 Unit Tests

3.11 Architecture Decision Log

3.12 Architecture Unit Tests

3.13 Integration Tests

3.14 System Integration Testing

3.15 Event Sourcing

3.16 Database change management

3.17 Continuous Integration

3.18 Static code analysis

3.19 System Under Test SUT

3.20 Mutation Testing

10. Inspirations and Recommendations

1. Introduction

1.1 Purpose of this Repository

This is a list of the main goals of this repository:

Showing how you can implement a monolith application in a modular way
Presentation of the full implementation of an application
- This is not another simple application
- This is not another proof of concept (PoC)
- The goal is to present the implementation of an application that would be ready to run in production
Showing the application of best practices and object-oriented programming principles
Presentation of the use of design patterns. When, how and why they can be used
Presentation of some architectural considerations, decisions, approaches
Presentation of the implementation using Domain-Driven Design approach (tactical patterns)
Presentation of the implementation of Unit Tests for Domain Model (Testable Design in mind)
Presentation of the implementation of Integration Tests
Presentation of the implementation of Event Sourcing
Presentation of C4 Model
Presentation of diagram as text approach

1.2 Out of Scope

This is a list of subjects which are out of scope for this repository:

Business requirements gathering and analysis
System analysis
Domain exploration
Domain distillation
Domain-Driven Design strategic patterns
Architecture evaluation, quality attributes analysis
Integration, system tests
Project management
Infrastructure
Containerization
Software engineering process
Deployment process
Maintenance
Documentation

1.3 Reason

The reason for creating this repository is the lack of something similar. Most sample applications on GitHub have at least one of the following issues:

Very, very simple - few entities and use cases implemented
Not finished (for example there is no authentication, logging, etc..)
Poorly designed (in my opinion)
Poorly implemented (in my opinion)
Not well described
Assumptions and decisions are not clearly explained
Implements "Orders" domain - yes, everyone knows this domain, but something different is needed
Implemented in old technology
Not maintained

To sum up, there are some very good examples, but there are far too few of them. This repository has the task of filling this gap at some level.

1.4 Disclaimer

Software architecture should always be created to resolve specific business problems. Software architecture always supports some quality attributes and at the same time does not support others. A lot of other factors influence your software architecture - your team, opinions, preferences, experiences, technical constraints, time, budget, etc.

Always functional requirements, quality attributes, technical constraints and other factors should be considered before an architectural decision is made.

Because of the above, the architecture and implementation presented in this repository is one of the many ways to solve some problems. Take from this repository as much as you want, use it as you like but remember to always pick the best solution which is appropriate to the problem class you have.

1.5 Give a Star

My primary focus in this project is on quality. Creating a good quality product involves a lot of analysis, research and work. It takes a lot of time. If you like this project, learned something or you are using it in your applications, please give it a star ⭐. This is the best motivation for me to continue this work. Thanks!

1.6 Share It

There are very few really good examples of this type of application. If you think this repository makes a difference and is worth it, please share it with your friends and on social networks. I will be extremely grateful.

2. Domain

2.1 Description

Definition:

Domain - A sphere of knowledge, influence, or activity. The subject area to which the user applies a program is the domain of the software. Domain-Driven Design Reference, Eric Evans

The Meeting Groups domain was selected for the purposes of this project based on the Meetup.com system.

Main reasons for selecting this domain:

It is common, a lot of people use the Meetup site to organize or attend meetings
There is a system for it, so everyone can check this implementation against a working site which supports this domain
It is not complex so it is easy to understand
It is not trivial - there are some business rules and logic and it is not just CRUD operations
You don't need much specific domain knowledge unlike other domains like financing, banking, medical
It is not big so it is easier to implement

Meetings

The main business entities are Member, Meeting Group and Meeting. A Member can create a Meeting Group, be part of a Meeting Group or can attend a Meeting.

A Meeting Group Member can be an Organizer of this group or a normal Member.

Only an Organizer of a Meeting Group can create a new Meeting.

A Meeting has attendees, not attendees (Members which declare they will not attend the Meeting) and Members on the Waitlist.

A Meeting can have an attendee limit. If the limit is reached, Members can only sign up to the Waitlist.

A Meeting Attendee can bring guests to the Meeting. The number of guests allowed is an attribute of the Meeting. Bringing guests can be unallowed.

A Meeting Attendee can have one of two roles: Attendee or Host. A Meeting must have at least one Host. The Host is a special role which grants permission to edit Meeting information or change the attendees list.

A Member can comment Meetings. A Member can reply to, like other Comments. Organizer manages commenting of Meeting by Meeting Commenting Configuration. Organizer can delete any Comment.

Each Meeting Group must have an organizer with active Subscription. One organizer can cover 3 Meeting Groups by his Subscription.

Additionally, Meeting organizer can set an Event Fee. Each Meeting Attendee is obliged to pay the fee. All guests should be paid by Meeting Attendee too.

Administration

To create a new Meeting Group, a Member needs to propose the group. A Meeting Group Proposal is sent to Administrators. An Administrator can accept or reject a Meeting Group Proposal. If a Meeting Group Proposal is accepted, a Meeting Group is created.

Payments

Each Member who is the Payer can buy the Subscription. He needs to pay the Subscription Payment. Subscription can expire so Subscription Renewal is required (by Subscription Renewal Payment payment to keep Subscription active).

When the Meeting fee is required, the Payer needs to pay Meeting Fee (through Meeting Fee Payment).

Users

Each Administrator, Member and Payer is a User. To be a User, User Registration is required and confirmed.

Each User is assigned one or more User Role.

Each User Role has set of Permissions. A Permission defines whether User can invoke a particular action.

2.2 Conceptual Model

Definition:

Conceptual Model - A conceptual model is a representation of a system, made of the composition of concepts that are used to help people know, understand, or simulate a subject the model represents. Wikipedia - Conceptual model

Conceptual Model

PlantUML version:

VisualParadigm version (not maintained, only for demonstration):

Conceptual Model of commenting feature

2.3 Event Storming

While a Conceptual Model focuses on structures and relationships between them, behavior and events that occur in our domain are more important.

There are many ways to show behavior and events. One of them is a light technique called Event Storming which is becoming more popular. Below are presented 3 main business processes using this technique: user registration, meeting group creation and meeting organization.

Note: Event Storming is a light, live workshop. One of the possible outputs of this workshop is presented here. Even if you are not doing Event Storming workshops, this type of process presentation can be very valuable to you and your stakeholders.

User Registration process

Meeting Group creation

Meeting organization

Payments Download high resolution file

3. Architecture

3.0 C4 Model

C4 model is a lean graphical notation technique for modelling the architecture of software systems.

As can be found on the website of the author of this model (Simon Brown): The C4 model was created as a way to help software development teams describe and communicate software architecture, both during up-front design sessions and when retrospectively documenting an existing codebase

Model C4 defines 4 levels (views) of the system architecture: System Context, Container, Component and Code. Below are examples of each of these levels that describe the architecture of this system.

Note: The PlantUML (diagram as text) component was used to describe all C4 model levels. Additionally, for levels C1-C3, a C4-PlantUML plug-in connecting PlantUML with the C4 model was used.

3.0.1 C1 System Context

3.0.2 C2 Container

3.0.3 C3 Component (high-level)

3.0.4 C3 Component (module-level)

3.0.5 C4 Code (meeting group aggregate)

3.1 High Level View

Module descriptions:

API - Very thin ASP.NET MVC Core REST API application. Main responsibilities are:
1. Accept request
2. Authenticate and authorize request (using User Access module)
3. Delegate work to specific module sending Command or Query
4. Return response
User Access - responsible for user authentication and authorization
Registrations - responsible for user registration
Meetings - implements Meetings Bounded Context: creating meeting groups, meetings
Administration - implements Administration Bounded Context: implements administrative tasks like meeting group proposal verification
Payments - implements Payments Bounded Context: implements all functionalities associated with payments
In Memory Events Bus - Publish/Subscribe implementation to asynchronously integrate all modules using events (Event Driven Architecture).

Key assumptions:

API contains no application logic
API communicates with Modules using a small interface to send Queries and Commands
Each Module has its own interface which is used by API
Modules communicate each other only asynchronously using Events Bus - direct method calls are not allowed
Each Module has it's own data in a separate schema - shared data is not allowed
- Module data could be moved into separate databases if desired
Modules can only have a dependency on the integration events assembly of other Module (see Module level view)
Each Module has its own Composition Root, which implies that each Module has its own Inversion-of-Control container
API as a host needs to initialize each module and each module has an initialization method
Each Module is highly encapsulated - only required types and members are public, the rest are internal or private

3.2 Module Level View

Each Module has Clean Architecture and consists of the following submodules (assemblies):

Application - the application logic submodule which is responsible for requests processing: use cases, domain events, integration events, internal commands.
Domain - Domain Model in Domain-Driven Design terms implements the applicable Bounded Context
Infrastructure - infrastructural code responsible for module initialization, background processing, data access, communication with Events Bus and other external components or systems
IntegrationEvents - Contracts published to the Events Bus; only this assembly can be called by other modules

Note: Application, Domain and Infrastructure assemblies could be merged into one assembly. Some people like horizontal layering or more decomposition, some don't. Implementing the Domain Model or Infrastructure in separate assembly allows encapsulation using the internal keyword. Sometimes Bounded Context logic is not worth it because it is too simple. As always, be pragmatic and take whatever approach you like.

3.3 API and Module Communication

The API only communicates with Modules in two ways: during module initialization and request processing.

Module initialization

Each module has a static Initialize method which is invoked in the API Startup class. All configuration needed by this module should be provided as arguments to this method. All services are configured during initialization and the Composition Root is created using the Inversion-of-Control Container.

public static void Initialize(
    string connectionString,
    IExecutionContextAccessor executionContextAccessor,
    ILogger logger,
    EmailsConfiguration emailsConfiguration)
{
    var moduleLogger = logger.ForContext("Module", "Meetings");

    ConfigureCompositionRoot(connectionString, executionContextAccessor, moduleLogger, emailsConfiguration);

    QuartzStartup.Initialize(moduleLogger);

    EventsBusStartup.Initialize(moduleLogger);
}

Request processing

Each module has the same interface signature exposed to the API. It contains 3 methods: command with result, command without result and query.

public interface IMeetingsModule
{
    Task<TResult> ExecuteCommandAsync<TResult>(ICommand<TResult> command);

    Task ExecuteCommandAsync(ICommand command);

    Task<TResult> ExecuteQueryAsync<TResult>(IQuery<TResult> query);
}

Note: Some people say that processing a command should not return a result. This is an understandable approach but sometimes impractical, especially when you want to immediately return the ID of a newly created resource. Sometimes the boundary between Command and Query is blurry. One example is AuthenticateCommand - it returns a token but it is not a query because it has a side effect.

3.4 Module Requests Processing via CQRS

Processing of Commands and Queries is separated by applying the architectural style/pattern Command Query Responsibility Segregation (CQRS).

Commands are processed using Write Model which is implemented using DDD tactical patterns:

internal class CreateNewMeetingGroupCommandHandler : ICommandHandler<CreateNewMeetingGroupCommand>
{
    private readonly IMeetingGroupRepository _meetingGroupRepository;
    private readonly IMeetingGroupProposalRepository _meetingGroupProposalRepository;

    internal CreateNewMeetingGroupCommandHandler(
        IMeetingGroupRepository meetingGroupRepository,
        IMeetingGroupProposalRepository meetingGroupProposalRepository)
    {
        _meetingGroupRepository = meetingGroupRepository;
        _meetingGroupProposalRepository = meetingGroupProposalRepository;
    }

    public async Task Handle(CreateNewMeetingGroupCommand request, CancellationToken cancellationToken)
    {
        var meetingGroupProposal = await _meetingGroupProposalRepository.GetByIdAsync(request.MeetingGroupProposalId);

        var meetingGroup = meetingGroupProposal.CreateMeetingGroup();

        await _meetingGroupRepository.AddAsync(meetingGroup);

        
    }
}

Queries are processed using Read Model which is implemented by executing raw SQL statements on database views:

internal class GetAllMeetingGroupsQueryHandler : IQueryHandler<GetAllMeetingGroupsQuery, List<MeetingGroupDto>>
{
    private readonly ISqlConnectionFactory _sqlConnectionFactory;

    internal GetAllMeetingGroupsQueryHandler(ISqlConnectionFactory sqlConnectionFactory)
    {
        _sqlConnectionFactory = sqlConnectionFactory;
    }

    public async Task<List<MeetingGroupDto>> Handle(GetAllMeetingGroupsQuery request, CancellationToken cancellationToken)
    {
        var connection = _sqlConnectionFactory.GetOpenConnection();

        const string sql = $"""
                           SELECT 
                                [MeetingGroup].[Id] as [{nameof(MeetingGroupDto.Id)}] , 
                                [MeetingGroup].[Name] as [{nameof(MeetingGroupDto.Name)}], 
                                [MeetingGroup].[Description] as [{nameof(MeetingGroupDto.Description)}] 
                                [MeetingGroup].[LocationCountryCode] as [{nameof(MeetingGroupDto.LocationCountryCode)}],
                                [MeetingGroup].[LocationCity] as [{nameof(MeetingGroupDto.LocationCity)}]
                           FROM [meetings].[v_MeetingGroups] AS [MeetingGroup]
                           """;
        var meetingGroups = await connection.QueryAsync<MeetingGroupDto>(sql);

        return meetingGroups.AsList();
    }
}

Key advantages:

Solution is appropriate to the problem - reading and writing needs are usually different
Supports Single Responsibility Principle (SRP) - one handler does one thing
Supports Interface Segregation Principle (ISP) - each handler implements interface with exactly one method
Supports Parameter Object pattern - Commands and Queries are objects which are easy to serialize/deserialize
Easy way to apply Decorator pattern to handle cross-cutting concerns
Supports Loose Coupling by use of the Mediator pattern - separates invoker of request from handler of request

Disadvantage:

Mediator pattern introduces extra indirection and is harder to reason about which class handles the request

For more information: Simple CQRS implementation with raw SQL and DDD

3.5 Domain Model Principles and Attributes

The Domain Model, which is the central and most critical part in the system, should be designed with special attention. Here are some key principles and attributes which are applied to Domain Models of each module:

High level of encapsulation

All members are private by default, then internal - only public at the very edge.
High level of PI (Persistence Ignorance)

No dependencies to infrastructure, databases, etc. All classes are POCOs.
Rich in behavior

All business logic is located in the Domain Model. No leaks to the application layer or elsewhere.
Low level of Primitive Obsession

Primitive attributes of Entites grouped together using ValueObjects.
Business language

All classes, methods and other members are named in business language used in this Bounded Context.
Testable

The Domain Model is a critical part of the system so it should be easy to test (Testable Design).

public class MeetingGroup : Entity, IAggregateRoot
{
    public MeetingGroupId Id { get; private set; }

    private string _name;

    private string _description;

    private MeetingGroupLocation _location;

    private MemberId _creatorId;

    private List<MeetingGroupMember> _members;

    private DateTime _createDate;

    private DateTime? _paymentDateTo;

    internal static MeetingGroup CreateBasedOnProposal(
        MeetingGroupProposalId meetingGroupProposalId,
        string name,
        string description,
        MeetingGroupLocation location, MemberId creatorId)
    {
        return new MeetingGroup(meetingGroupProposalId, name, description, location, creatorId);
    }

     public Meeting CreateMeeting(
            string title,
            MeetingTerm term,
            string description,
            MeetingLocation location,
            int? attendeesLimit,
            int guestsLimit,
            Term rsvpTerm,
            MoneyValue eventFee,
            List<MemberId> hostsMembersIds,
            MemberId creatorId)
        {
            this.CheckRule(new MeetingCanBeOrganizedOnlyByPayedGroupRule(_paymentDateTo));

            this.CheckRule(new MeetingHostMustBeAMeetingGroupMemberRule(creatorId, hostsMembersIds, _members));

            return new Meeting(this.Id,
                title,
                term,
                description,
                location,
                attendeesLimit,
                guestsLimit,
                rsvpTerm,
                eventFee,
                hostsMembersIds,
                creatorId);
        }

3.6 Cross-Cutting Concerns

To support Single Responsibility Principle and Don't Repeat Yourself principles, the implementation of cross-cutting concerns is done using the Decorator Pattern. Each Command processor is decorated by 3 decorators: logging, validation and unit of work.

Logging

The Logging decorator logs execution, arguments and processing of each Command. This way each log inside a processor has the log context of the processing command.

internal class LoggingCommandHandlerDecorator<T> : ICommandHandler<T> where T:ICommand
{
    private readonly ILogger _logger;
    private readonly IExecutionContextAccessor _executionContextAccessor;
    private readonly ICommandHandler<T> _decorated;

    public LoggingCommandHandlerDecorator(
        ILogger logger,
        IExecutionContextAccessor executionContextAccessor,
        ICommandHandler<T> decorated)
    {
        _logger = logger;
        _executionContextAccessor = executionContextAccessor;
        _decorated = decorated;
    }
    public async Task Handle(T command, CancellationToken cancellationToken)
    {
        if (command is IRecurringCommand)
        {
            return await _decorated.Handle(command, cancellationToken);
        }
        using (
            LogContext.Push(
                new RequestLogEnricher(_executionContextAccessor),
                new CommandLogEnricher(command)))
        {
            try
            {
                this._logger.Information(
                    "Executing command {Command}",
                    command.GetType().Name);

                var result = await _decorated.Handle(command, cancellationToken);

                this._logger.Information("Command {Command} processed successful", command.GetType().Name);

                return result;
            }
            catch (Exception exception)
            {
                this._logger.Error(exception, "Command {Command} processing failed", command.GetType().Name);
                throw;
            }
        }
    }

    private class CommandLogEnricher : ILogEventEnricher
    {
        private readonly ICommand _command;

        public CommandLogEnricher(ICommand command)
        {
            _command = command;
        }
        public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
        {
            logEvent.AddOrUpdateProperty(new LogEventProperty("Context", new ScalarValue($"Command:{_command.Id.ToString()}")));
        }
    }

    private class RequestLogEnricher : ILogEventEnricher
    {
        private readonly IExecutionContextAccessor _executionContextAccessor;
        public RequestLogEnricher(IExecutionContextAccessor executionContextAccessor)
        {
            _executionContextAccessor = executionContextAccessor;
        }
        public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
        {
            if (_executionContextAccessor.IsAvailable)
            {
                logEvent.AddOrUpdateProperty(new LogEventProperty("CorrelationId", new ScalarValue(_executionContextAccessor.CorrelationId)));
            }
        }
    }
}

Validation

The Validation decorator performs Command data validation. It checks rules against Command arguments using the FluentValidation library.

internal class ValidationCommandHandlerDecorator<T> : ICommandHandler<T> where T:ICommand
{
    private readonly IList<IValidator<T>> _validators;
    private readonly ICommandHandler<T> _decorated;

    public ValidationCommandHandlerDecorator(
        IList<IValidator<T>> validators,
        ICommandHandler<T> decorated)
    {
        this._validators = validators;
        _decorated = decorated;
    }

    public Task<Unit> Handle(T command, CancellationToken cancellationToken)
    {
        var errors = _validators
            .Select(v => v.Validate(command))
            .SelectMany(result => result.Errors)
            .Where(error => error != null)
            .ToList();

        if (errors.Any())
        {
            var errorBuilder = new StringBuilder();

            errorBuilder.AppendLine("Invalid command, reason: ");

            foreach (var error in errors)
            {
                errorBuilder.AppendLine(error.ErrorMessage);
            }

            throw new InvalidCommandException(errorBuilder.ToString(), null);
        }

        return _decorated.Handle(command, cancellationToken);
    }
}

Unit Of Work

All Command processing has side effects. To avoid calling commit on every handler, UnitOfWorkCommandHandlerDecorator is used. It additionally marks InternalCommand as processed (if it is Internal Command) and dispatches all Domain Events (as part of Unit Of Work).

public class UnitOfWorkCommandHandlerDecorator<T> : ICommandHandler<T> where T:ICommand
{
    private readonly ICommandHandler<T> _decorated;
    private readonly IUnitOfWork _unitOfWork;
    private readonly MeetingsContext _meetingContext;

    public UnitOfWorkCommandHandlerDecorator(
        ICommandHandler<T> decorated,
        IUnitOfWork unitOfWork,
        MeetingsContext meetingContext)
    {
        _decorated = decorated;
        _unitOfWork = unitOfWork;
        _meetingContext = meetingContext;
    }

    public async Task Handle(T command, CancellationToken cancellationToken)
    {
        await this._decorated.Handle(command, cancellationToken);

        if (command is InternalCommandBase)
        {
            var internalCommand =
                await _meetingContext.InternalCommands.FirstOrDefaultAsync(x => x.Id == command.Id,
                    cancellationToken: cancellationToken);

            if (internalCommand != null)
            {
                internalCommand.ProcessedDate = DateTime.UtcNow;
            }
        }

        await this._unitOfWork.CommitAsync(cancellationToken);

        
    }
}

3.7 Modules Integration

Integration between modules is strictly asynchronous using Integration Events and the In Memory Event Bus as broker. In this way coupling between modules is minimal and exists only on the structure of Integration Events.

Modules don't share data so it is not possible nor desirable to create a transaction which spans more than one module. To ensure maximum reliability, the Outbox / Inbox pattern is used. This pattern provides accordingly "At-Least-Once delivery" and "At-Least-Once processing".

The Outbox and Inbox is implemented using two SQL tables and a background worker for each module. The background worker is implemented using the Quartz.NET library.

Saving to Outbox:

Processing Outbox:

3.8 Internal Processing

The main principle of this system is that you can change its state only by calling a specific Command.

Commands can be called not only by the API, but by the processing module itself. The main use case which implements this mechanism is data processing in eventual consistency mode when we want to process something in a different process and transaction. This applies, for example, to Inbox processing because we want to do something (calling a Command) based on an Integration Event from the Inbox.

This idea is taken from Alberto's Brandolini's Event Storming picture called "The picture that explains “almost” everything" which shows that every side effect (domain event) is created by invoking a Command on Aggregate. See EventStorming cheat sheet article for more details.

Implementation of internal processing is very similar to implementation of the Outbox and Inbox. One SQL table and one background worker for processing. Each internally processing Command must inherit from InternalCommandBase class:

internal abstract class InternalCommandBase : ICommand
{
    public Guid Id { get; }

    protected InternalCommandBase(Guid id)
    {
        this.Id = id;
    }
}

This is important because the UnitOfWorkCommandHandlerDecorator must mark an internal Command as processed during committing:

public async Task Handle(T command, CancellationToken cancellationToken)
{
    await this._decorated.Handle(command, cancellationToken);

    if (command is InternalCommandBase)
    {
        var internalCommand =
            await _meetingContext.InternalCommands.FirstOrDefaultAsync(x => x.Id == command.Id,
                cancellationToken: cancellationToken);

        if (internalCommand != null)
        {
            internalCommand.ProcessedDate = DateTime.UtcNow;
        }
    }

    await this._unitOfWork.CommitAsync(cancellationToken);

    
}

3.9 Security

Authentication

Authentication is implemented using JWT Token and Bearer scheme using IdentityServer. For now, only one authentication method is implemented: forms style authentication (username and password) via the OAuth2 Resource Owner Password Grant Type. It requires implementation of the IResourceOwnerPasswordValidator interface:

public class ResourceOwnerPasswordValidator : IResourceOwnerPasswordValidator
{
    private readonly IUserAccessModule _userAccessModule;

    public ResourceOwnerPasswordValidator(IUserAccessModule userAccessModule)
    {
        _userAccessModule = userAccessModule;
    }

    public async Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
    {
        var authenticationResult = await _userAccessModule.ExecuteCommandAsync(new AuthenticateCommand(context.UserName, context.Password));
        if (!authenticationResult.IsAuthenticated)
        {
            context.Result = new GrantValidationResult(
                TokenRequestErrors.InvalidGrant,
                authenticationResult.AuthenticationError);
            return;
        }
        context.Result = new GrantValidationResult(
            authenticationResult.User.Id.ToString(),
            "forms",
            authenticationResult.User.Claims);
    }
}

Authorization

Authorization is achieved by implementing RBAC (Role Based Access Control) using Permissions. Permissions are more granular and a much better way to secure your application than Roles alone. Each User has a set of Roles and each Role contains one or more Permission. The User's set of Permissions is extracted from all Roles the User belongs to. Permissions are always checked on Controller level - never Roles:

[HttpPost]
[Route("")]
[HasPermission(MeetingsPermissions.ProposeMeetingGroup)]
public async Task<IActionResult> ProposeMeetingGroup(ProposeMeetingGroupRequest request)
{
    await _meetingsModule.ExecuteCommandAsync(
        new ProposeMeetingGroupCommand(
            request.Name,
            request.Description,
            request.LocationCity,
            request.LocationCountryCode));

    return Ok();
}

3.10 Unit Tests

Definition:

A unit test is an automated piece of code that invokes the unit of work being tested, and then checks some assumptions about a single end result of that unit. A unit test is almost always written using a unit testing framework. It can be written easily and runs quickly. It’s trustworthy, readable, and maintainable. It’s consistent in its results as long as production code hasn’t changed. Art of Unit Testing 2nd Edition Roy Osherove

Attributes of good unit test

Automated
Maintainable
Runs very fast (in ms)
Consistent, Deterministic (always the same result)
Isolated from other tests
Readable
Can be executed by anyone
Testing public API, not internal behavior (overspecification)
Looks like production code
Treated as production code

Implementation

Unit tests should mainly test business logic (domain model):

Each unit test has 3 standard sections: Arrange, Act and Assert:

1. Arrange

The Arrange section is responsible for preparing the Aggregate for testing the public method that we want to test. This public method is often called (from the unit tests perspective) the SUT (system under test).

Creating an Aggregate ready for testing involves calling one or more other public constructors/methods on the Domain Model. At first it may seem that we are testing too many things at the same time, but this is not true. We need to be one hundred percent sure that the Aggregate is in a state exactly as it will be in production. This can only be ensured when we:

Use only public API of Domain Model
Don't use InternalsVisibleToAttribute class
- This exposes the Domain Model to the Unit Tests library, removing encapsulation so our tests and production code are treated differently and it is a very bad thing
Don't use ConditionalAttribute classes - it reduces readability and increases complexity
Don't create any special constructors/factory methods for tests (even with conditional compilation symbols)
- Special constructor/factory method only for unit tests causes duplication of business logic in the test itself and focuses on state - this kind of approach causes the test to be very sensitive to changes and hard to maintain
Don't remove encapsulation from Domain Model (for example: change keywords from internal/private to public)
Don't make methods protected to inherit from tested class and in this way provide access to internal methods/properties

Isolation of external dependencies

There are 2 main concepts - stubs and mocks:

A stub is a controllable replacement for an existing dependency (or collaborator) in the system. By using a stub, you can test your code without dealing with the dependency directly.

A mock object is a fake object in the system that decides whether the unit test has passed or failed. It does so by verifying whether the object under test called the fake object as expected. There’s usually no more than one mock per test. Art of Unit Testing 2nd Edition Roy Osherove

Good advice: use stubs if you need to, but try to avoid mocks. Mocking causes us to test too many internal things and leads to overspecification.

2. Act

This section is very easy - we execute exactly one public method on aggregate (SUT).

3. Assert

In this section we check expectations. There are only 2 possible outcomes:

Method completed and Domain Event(s) published
Business rule was broken

Simple example:

[Test]
public void NewUserRegistration_WithUniqueLogin_IsSuccessful()
{
    // Arrange
    var usersCounter = Substitute.For<IUsersCounter>();

    // Act
    var userRegistration =
        UserRegistration.RegisterNewUser(
            "login", "password", "test@email",
            "firstName", "lastName", usersCounter);

    // Assert
    var newUserRegisteredDomainEvent = AssertPublishedDomainEvent<NewUserRegisteredDomainEvent>(userRegistration);
    Assert.That(newUserRegisteredDomainEvent.UserRegistrationId, Is.EqualTo(userRegistration.Id));
}

[Test]
public void NewUserRegistration_WithoutUniqueLogin_BreaksUserLoginMustBeUniqueRule()
{
    // Arrange
    var usersCounter = Substitute.For<IUsersCounter>();
    usersCounter.CountUsersWithLogin("login").Returns(x => 1);

    // Assert
    AssertBrokenRule<UserLoginMustBeUniqueRule>(() =>
    {
        // Act
        UserRegistration.RegisterNewUser(
            "login", "password", "test@email",
            "firstName", "lastName", usersCounter);
    });
}

Advanced example:

[Test]
public void AddAttendee_WhenMemberIsAlreadyAttendeeOfMeeting_IsNotPossible()
{
    // Arrange
    var creatorId = new MemberId(Guid.NewGuid());
    var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions
    {
        CreatorId = creatorId
    });
    var newMemberId = new MemberId(Guid.NewGuid());
    meetingTestData.MeetingGroup.JoinToGroupMember(newMemberId);
    meetingTestData.Meeting.AddAttendee(meetingTestData.MeetingGroup, newMemberId, 0);

    // Assert
    AssertBrokenRule<MemberCannotBeAnAttendeeOfMeetingMoreThanOnceRule>(() =>
    {
        // Act
        meetingTestData.Meeting.AddAttendee(meetingTestData.MeetingGroup, newMemberId, 0);
    });
}

CreateMeetingTestData method is an implementation of SUT Factory described by Mark Seemann which allows keeping common creation logic in one place:

protected MeetingTestData CreateMeetingTestData(MeetingTestDataOptions options)
{
    var proposalMemberId = options.CreatorId ?? new MemberId(Guid.NewGuid());
    var meetingProposal = MeetingGroupProposal.ProposeNew(
        "name", "description",
        new MeetingGroupLocation("Warsaw", "PL"), proposalMemberId);

    meetingProposal.Accept();

    var meetingGroup = meetingProposal.CreateMeetingGroup();

    meetingGroup.UpdatePaymentInfo(DateTime.Now.AddDays(1));

    var meetingTerm = options.MeetingTerm ??
                      new MeetingTerm(DateTime.UtcNow.AddDays(1), DateTime.UtcNow.AddDays(2));

    var rsvpTerm = options.RvspTerm ?? Term.NoTerm;
    var meeting = meetingGroup.CreateMeeting("title",
        meetingTerm,
        "description",
        new MeetingLocation("Name", "Address", "PostalCode", "City"),
        options.AttendeesLimit,
        options.GuestsLimit,
        rsvpTerm,
        MoneyValue.Zero,
        new List<MemberId>(),
        proposalMemberId);

    DomainEventsTestHelper.ClearAllDomainEvents(meetingGroup);

    return new MeetingTestData(meetingGroup, meeting);
}

3.11 Architecture Decision Log

All Architectural Decisions (AD) are documented in the Architecture Decision Log (ADL).

More information about documenting architecture-related decisions in this way : https://github.com/joelparkerhenderson/architecture_decision_record

3.12 Architecture Unit Tests

In some cases it is not possible to enforce the application architecture, design or established conventions using compiler (compile-time). For this reason, code implementations can diverge from the original design and architecture. We want to minimize this behavior, not only by code review.

To do this, unit tests of system architecture, design, major conventions and assumptions have been written. In .NET there is special library for this task: NetArchTest. This library has been written based on the very popular JAVA architecture unit tests library - ArchUnit.

Using this kind of tests we can test proper layering of our application, dependencies, encapsulation, immutability, DDD correct implementation, naming, conventions and so on - everything what we need to test. Example:

More information about architecture unit tests here: https://blogs.oracle.com/javamagazine/unit-test-your-architecture-with-archunit

3.13 Integration Tests

Definition

"Integration Test" term is blurred. It can mean test between classes, modules, services, even systems - see this article (by Martin Fowler).

For this reason, the definition of integration test in this project is as follows:

it verifies how system works in integration with "out-of-process" dependencies - database, messaging system, file system or external API
it tests particular use case
it can be slow (as opposed to Unit Test)

Approach

Do not mock dependencies over which you have full control (like database). Full control dependency means you can always revert all changes (remove side-effects) and no one can notice it. They are not visible to others. See next point, please.
Use "production", normal, real database version. Some use e.g. in memory repository, some use light databases instead "production" version. This is still mocking. Testing makes sense if we have full confidence in testing. You can't trust the test if you know that the infrastructure in the production environment will vary. Be always as close to production environment as possible.
Mock dependencies over which you don't have control. No control dependency means you can't remove side-effects after interaction with this dependency (external API, messaging system, SMTP server etc.). They can be visible to others.

Implementation

Integration test should test exactly one use case. One use case is represented by one Command/Query processing so CommandHandler/QueryHandler in Application layer is perfect starting point for running the Integration Test:

For each test, the following preparation steps must be performed:

Clear database
Prepare mocks
Initialize testing module

[SetUp]
public async Task BeforeEachTest()
{
    const string connectionStringEnvironmentVariable =
        "ASPNETCORE_MyMeetings_IntegrationTests_ConnectionString";
    ConnectionString = Environment.GetEnvironmentVariable(connectionStringEnvironmentVariable, EnvironmentVariableTarget.Machine);
    if (ConnectionString == null)
    {
        throw new ApplicationException(
            $"Define connection string to integration tests database using environment variable: {connectionStringEnvironmentVariable}");
    }

    using (var sqlConnection = new SqlConnection(ConnectionString))
    {
        await ClearDatabase(sqlConnection);
    }

    Logger = Substitute.For<ILogger>();
    EmailSender = Substitute.For<IEmailSender>();
    EventsBus = new EventsBusMock();
    ExecutionContext = new ExecutionContextMock(Guid.NewGuid());
    
    PaymentsStartup.Initialize(
        ConnectionString,
        ExecutionContext,
        Logger,
        EventsBus,
        false);

    PaymentsModule = new PaymentsModule();
}

After preparation, test is performed on clear database. Usually, it is the execution of some (or many) Commands and:
a) running a Query or/and
b) verifying mocks
to check the result.

[TestFixture]
public class MeetingPaymentTests : TestBase
{
    [Test]
    public async Task CreateMeetingPayment_Test()
    {
        PayerId payerId = new PayerId(Guid.NewGuid());
        MeetingId meetingId = new MeetingId(Guid.NewGuid());
        decimal value = 100;
        string currency = "EUR";
        await PaymentsModule.ExecuteCommandAsync(new CreateMeetingPaymentCommand(Guid.NewGuid(),
            payerId, meetingId, value, currency));

        var payment = await PaymentsModule.ExecuteQueryAsync(new GetMeetingPaymentQuery(meetingId.Value, payerId.Value));

        Assert.That(payment.PayerId, Is.EqualTo(payerId.Value));
        Assert.That(payment.MeetingId, Is.EqualTo(meetingId.Value));
        Assert.That(payment.FeeValue, Is.EqualTo(value));
        Assert.That(payment.FeeCurrency, Is.EqualTo(currency));
    }
}

Each Command/Query processing is a separate execution (with different object graph resolution, context, database connection etc.) thanks to Composition Root of each module. This behavior is important and desirable.

3.14 System Integration Testing

Definition

System Integration Testing (SIT) is performed to verify the interactions between the modules of a software system. It involves the overall testing of a complete system of many subsystem components or elements.

Implementation

Implementation of system integration tests is based on approach of integration testing of modules in isolation (invoking commands and queries) described in the previous section.

The problem is that in this case we are dealing with asynchronous communication. Due to asynchrony, our test must wait for the result at certain times.

To correctly implement such tests, the Sampling technique and implementation described in the Growing Object-Oriented Software, Guided by Tests book was used:

An asynchronous test must wait for success and use timeouts to detect failure. This implies that every tested activity must have an observable effect: a test must affect the system so that its observable state becomes different. This sounds obvious but it drives how we think about writing asynchronous tests. If an activity has no observable effect, there is nothing the test can wait for, and therefore no way for the test to synchronize with the system it is testing. There are two ways a test can observe the system: by sampling its observable state or by listening for events that it sends out.

Test below:

Creates Meeting Group Proposal in Meetings module
Waits until Meeting Group Proposal to verification will be available in Administration module with 10 seconds timeout
Accepts Meeting Group Proposal in Administration module
Waits until Meeting Group is created in Meetings module with 15 seconds timeout

public class CreateMeetingGroupTests : TestBase
{
    [Test]
    public async Task CreateMeetingGroupScenario_WhenProposalIsAccepted()
    {
        var meetingGroupId = await MeetingsModule.ExecuteCommandAsync(
            new ProposeMeetingGroupCommand("Name",
            "Description",
            "Location",
            "PL"));

        AssertEventually(
            new GetMeetingGroupProposalFromAdministrationProbe(meetingGroupId, AdministrationModule), 
            10000);

        await AdministrationModule.ExecuteCommandAsync(new AcceptMeetingGroupProposalCommand(meetingGroupId));

        AssertEventually(
            new GetCreatedMeetingGroupFromMeetingsProbe(meetingGroupId, MeetingsModule),
            15000);
    }

    private class GetCreatedMeetingGroupFromMeetingsProbe : IProbe
    {
        private readonly Guid _expectedMeetingGroupId;

        private readonly IMeetingsModule _meetingsModule;

        private List<MeetingGroupDto> _allMeetingGroups;

        public GetCreatedMeetingGroupFromMeetingsProbe(
            Guid expectedMeetingGroupId, 
            IMeetingsModule meetingsModule)
        {
            _expectedMeetingGroupId = expectedMeetingGroupId;
            _meetingsModule = meetingsModule;
        }

        public bool IsSatisfied()
        {
            return _allMeetingGroups != null && 
                   _allMeetingGroups.Any(x => x.Id == _expectedMeetingGroupId);
        }

        public async Task SampleAsync()
        {
            _allMeetingGroups = await _meetingsModule.ExecuteQueryAsync(new GetAllMeetingGroupsQuery());
        }

        public string DescribeFailureTo() 
            => $"Meeting group with ID: {_expectedMeetingGroupId} is not created";
    }

    private class GetMeetingGroupProposalFromAdministrationProbe : IProbe
    {
        private readonly Guid _expectedMeetingGroupProposalId;

        private MeetingGroupProposalDto _meetingGroupProposal;

        private readonly IAdministrationModule _administrationModule;

        public GetMeetingGroupProposalFromAdministrationProbe(Guid expectedMeetingGroupProposalId, IAdministrationModule administrationModule)
        {
            _expectedMeetingGroupProposalId = expectedMeetingGroupProposalId;
            _administrationModule = administrationModule;
        }

        public bool IsSatisfied()
        {
            if (_meetingGroupProposal == null)
            {
                return false;
            }

            if (_meetingGroupProposal.Id == _expectedMeetingGroupProposalId &&
                _meetingGroupProposal.StatusCode == MeetingGroupProposalStatus.ToVerify.Value)
            {
                return true;
            }

            return false;
        }

        public async Task SampleAsync()
        {
            try
            {
                _meetingGroupProposal =
                    await _administrationModule.ExecuteQueryAsync(
                        new GetMeetingGroupProposalQuery(_expectedMeetingGroupProposalId));
            }
            catch
            {
                // ignored
            }
        }

        public string DescribeFailureTo()
            => $"Meeting group proposal with ID: {_expectedMeetingGroupProposalId} to verification not created";
    }
}

Poller class implementation (based on example in the book):

public class Poller
{
    private readonly int _timeoutMillis;

    private readonly int _pollDelayMillis;

    public Poller(int timeoutMillis)
    {
        _timeoutMillis = timeoutMillis;
        _pollDelayMillis = 1000;
    }

    public void Check(IProbe probe)
    {
        var timeout = new Timeout(_timeoutMillis);
        while (!probe.IsSatisfied())
        {
            if (timeout.HasTimedOut())
            {
                throw new AssertErrorException(DescribeFailureOf(probe));
            }

            Thread.Sleep(_pollDelayMillis);
            probe.SampleAsync();
        }
    }

    private static string DescribeFailureOf(IProbe probe)
    {
        return probe.DescribeFailureTo();
    }
}

3.15 Event Sourcing

Theory

During the implementation of the Payment module, Event Sourcing was used. Event Sourcing is a way of preserving the state of our system by recording a sequence of events. No less, no more.

It is important here to really restore the state of our application from events. If we collect events only for auditing purposes, it is an Audit Log/Trail - not the Event Sourcing.

The main elements of Event Sourcing are as follows:

Events Stream
Objects that are restored based on events. There are 2 types of such objects depending on the purpose: -- Objects responsible for the change of state. In Domain-Driven Design they will be Aggregates. -- Projections: read models prepared for a specific purpose
Subscriptions : a way to receive information about new events
Snapshots: from time to time, objects saved in the traditional way for performance purposes. Mainly used if there are many events to restore the object from the entire event history. (Note: there is currently no snapshot implementation in the project)

Tool

In order not to reinvent the wheel, the SQL Stream Store library was used. As the documentation says:

SQL Stream Store is a .NET library to assist with developing applications that use event sourcing or wish to use stream based patterns over a relational database and existing operational infrastructure.

Like every library, it has its limitations and assumptions (I recommend the linked documentation chapter "Things you need to know before adopting"). For me, the most important 2 points from this chapter are:

"Subscriptions (and thus projections) are eventually consistent and always will be." This means that there will always be an inconsistency time from saving the event to the stream and processing the event by the projector(s).
"No support for ambient System.Transaction scopes enforcing the concept of the stream as the consistency and transactional boundary." This means that if we save the event to a events stream and want to save something in the same transaction, we must use TransactionScope. If we cannot use TransactionScope for some reason, we must accept the Eventual Consistency also in this case.

Other popular tools:

EventStore "An industrial-strength database solution built from the ground up for event sourcing."
Marten ".NET Transactional Document DB and Event Store on PostgreSQL"

Implementation

There are 2 main "flows" to handle:

Command handling: change of state - adding new events to stream (writing)
Projection of events to create read models

Command Handling

The whole process looks like this:

We create / update an aggregate by creating an event
We add changes to the Aggregate Store. This is the class responsible for writing / loading our aggregates. We are not saving changes yet.
As part of Unit Of Work a) Aggregate Store adds events to the stream b) messages are added to the Outbox

Command Handler:

public class BuySubscriptionCommandHandler : ICommandHandler<BuySubscriptionCommand, Guid>
{
    private readonly IAggregateStore _aggregateStore;

    private readonly IPayerContext _payerContext;

    private readonly ISqlConnectionFactory _sqlConnectionFactory;

    public BuySubscriptionCommandHandler(
        IAggregateStore aggregateStore, 
        IPayerContext payerContext, 
        ISqlConnectionFactory sqlConnectionFactory)
    {
        _aggregateStore = aggregateStore;
        _payerContext = payerContext;
        _sqlConnectionFactory = sqlConnectionFactory;
    }

    public async Task<Guid> Handle(BuySubscriptionCommand command, CancellationToken cancellationToken)
    {
        var priceList = await PriceListProvider.GetPriceList(_sqlConnectionFactory.GetOpenConnection());

        var subscriptionPayment = SubscriptionPayment.Buy(
            _payerContext.PayerId,
            SubscriptionPeriod.Of(command.SubscriptionTypeCode),
            command.CountryCode,
            MoneyValue.Of(command.Value, command.Currency),
            priceList);
        
        _aggregateStore.AppendChanges(subscriptionPayment);

        return subscriptionPayment.Id;
    }
}

SubscriptionPayment Aggregate:

public class SubscriptionPayment : AggregateRoot
{
    private PayerId _payerId;

    private SubscriptionPeriod _subscriptionPeriod;

    private string _countryCode;

    private SubscriptionPaymentStatus _subscriptionPaymentStatus;

    private MoneyValue _value;

    protected override void Apply(IDomainEvent @event)
    {
        this.When((dynamic)@event);
    }

    public static SubscriptionPayment Buy(
        PayerId payerId,
        SubscriptionPeriod period,
        string countryCode,
        MoneyValue priceOffer,
        PriceList priceList)
    {
        var priceInPriceList = priceList.GetPrice(countryCode, period, PriceListItemCategory.New);
        CheckRule(new PriceOfferMustMatchPriceInPriceListRule(priceOffer, priceInPriceList));

        var subscriptionPayment = new SubscriptionPayment();

        var subscriptionPaymentCreated = new SubscriptionPaymentCreatedDomainEvent(
            Guid.NewGuid(),
            payerId.Value,
            period.Code,
            countryCode,
            SubscriptionPaymentStatus.WaitingForPayment.Code,
            priceOffer.Value,
            priceOffer.Currency);

        subscriptionPayment.Apply(subscriptionPaymentCreated);
        subscriptionPayment.AddDomainEvent(subscriptionPaymentCreated);

        return subscriptionPayment;
    }

    private void When(SubscriptionPaymentCreatedDomainEvent @event)
    {
        this.Id = @event.SubscriptionPaymentId;
        _payerId = new PayerId(@event.PayerId);
        _subscriptionPeriod = SubscriptionPeriod.Of(@event.SubscriptionPeriodCode);
        _countryCode = @event.CountryCode;
        _subscriptionPaymentStatus = SubscriptionPaymentStatus.Of(@event.Status);
        _value = MoneyValue.Of(@event.Value, @event.Currency);
    }

AggregateRoot base class:

public abstract class AggregateRoot
{
    public Guid Id { get; protected set; }

    public int Version { get; private set; }

    private readonly List<IDomainEvent> _domainEvents;

    protected AggregateRoot()
    {
        _domainEvents = new List<IDomainEvent>();

        Version = -1;
    }

    protected void AddDomainEvent(IDomainEvent @event)
    {
        _domainEvents.Add(@event);
    }

    public IReadOnlyCollection<IDomainEvent> GetDomainEvents() => _domainEvents.AsReadOnly();

    public void Load(IEnumerable<IDomainEvent> history)
    {
        foreach (var e in history)
        {
            Apply(e);
            Version++;
        }
    }

    protected abstract void Apply(IDomainEvent @event);

    protected static void CheckRule(IBusinessRule rule)
    {
        if (rule.IsBroken())
        {
            throw new BusinessRuleValidationException(rule);
        }
    }
}

Aggregate Store implementation with SQL Stream Store library usage:

public class SqlStreamAggregateStore : IAggregateStore
{
    private readonly IStreamStore _streamStore;

    private readonly List<IDomainEvent> _appendedChanges;

    private readonly List<AggregateToSave> _aggregatesToSave;

    public SqlStreamAggregateStore(
        ISqlConnectionFactory sqlConnectionFactory)
    {
        _appendedChanges = new List<IDomainEvent>();

        _streamStore =
            new MsSqlStreamStore(
                new MsSqlStreamStoreSettings(sqlConnectionFactory.GetConnectionString())
                    {
                        Schema = DatabaseSchema.Name
                });

        _aggregatesToSave = new List<AggregateToSave>();
    }

    public async Task Save()
    {
        foreach (var aggregateToSave in _aggregatesToSave)
        {
            await _streamStore.AppendToStream(
                GetStreamId(aggregateToSave.Aggregate),
                aggregateToSave.Aggregate.Version,
                aggregateToSave.Messages.ToArray());
        }

        _aggregatesToSave.Clear();
    }

    public async Task<T> Load<T>(AggregateId<T> aggregateId) where T : AggregateRoot
    {
        var streamId = GetStreamId(aggregateId);

        IList<IDomainEvent> domainEvents = new List<IDomainEvent>();
        ReadStreamPage readStreamPage;
        do
        {
            readStreamPage = await _streamStore.ReadStreamForwards(streamId, StreamVersion.Start, maxCount: 100);
            var messages = readStreamPage.Messages;
            foreach (var streamMessage in messages)
            {
                Type type = DomainEventTypeMappings.Dictionary[streamMessage.Type];
                var jsonData = await streamMessage.GetJsonData();
                var domainEvent = JsonConvert.DeserializeObject(jsonData, type) as IDomainEvent;

                domainEvents.Add(domainEvent);
            }
        } while (!readStreamPage.IsEnd);

        var aggregate = (T)Activator.CreateInstance(typeof(T), true);

        aggregate.Load(domainEvents);

        return aggregate;
    }

Events Projection

The whole process looks like this:

Special class Subscriptions Manager subscribes to Events Store (using SQL Store Stream library)
Events Store raises StreamMessageRecievedEvent
Subscriptions Manager invokes all projectors
If projector know how to handle given event, it updates particular read model. In current implementation it updates special table in SQL database.

SubscriptionsManager class implementation:

public class SubscriptionsManager
{
    private readonly IStreamStore _streamStore;

    public SubscriptionsManager(
        IStreamStore streamStore)
    {
        _streamStore = streamStore;
    }

    public void Start()
    {
        long? actualPosition;

        using (var scope = PaymentsCompositionRoot.BeginLifetimeScope())
        {
            var checkpointStore = scope.Resolve<ICheckpointStore>();

            actualPosition = checkpointStore.GetCheckpoint(SubscriptionCode.All);
        }

        _streamStore.SubscribeToAll(actualPosition, StreamMessageReceived);
    }

    public void Stop()
    {
        _streamStore.Dispose();
    }

    private static async Task StreamMessageReceived(
        IAllStreamSubscription subscription, StreamMessage streamMessage, CancellationToken cancellationToken)
    {
        var type = DomainEventTypeMappings.Dictionary[streamMessage.Type];
        var jsonData = await streamMessage.GetJsonData(cancellationToken);
        var domainEvent = JsonConvert.DeserializeObject(jsonData, type) as IDomainEvent;

        using var scope = PaymentsCompositionRoot.BeginLifetimeScope();

        var projectors = scope.Resolve<IList<IProjector>>();

        var tasks = projectors
            .Select(async projector =>
            {
                await projector.Project(domainEvent);
            });

        await Task.WhenAll(tasks);

        var checkpointStore = scope.Resolve<ICheckpointStore>();
        await checkpointStore.StoreCheckpoint(SubscriptionCode.All, streamMessage.Position);
    }
}

Example projector:

internal class SubscriptionDetailsProjector : ProjectorBase, IProjector
{
    private readonly IDbConnection _connection;

    public SubscriptionDetailsProjector(ISqlConnectionFactory sqlConnectionFactory)
    {
        _connection = sqlConnectionFactory.GetOpenConnection();
    }

    public async Task Project(IDomainEvent @event)
    {
        await When((dynamic) @event);
    }

    private async Task When(SubscriptionRenewedDomainEvent subscriptionRenewed)
    {
        var period = SubscriptionPeriod.GetName(subscriptionRenewed.SubscriptionPeriodCode);
        
        await _connection.ExecuteScalarAsync("UPDATE payments.SubscriptionDetails " +
                                                "SET " +
                                                    "[Status] = @Status, " +
                                                    "[ExpirationDate] = @ExpirationDate, " +
                                                    "[Period] = @Period " +
                                                "WHERE [Id] = @SubscriptionId",
            new
            {
                subscriptionRenewed.SubscriptionId,
                subscriptionRenewed.Status,
                subscriptionRenewed.ExpirationDate,
                period
            });
    }

    private async Task When(SubscriptionExpiredDomainEvent subscriptionExpired)
    {
        await _connection.ExecuteScalarAsync("UPDATE payments.SubscriptionDetails " +
                                             "SET " +
                                             "[Status] = @Status " +
                                             "WHERE [Id] = @SubscriptionId",
            new
            {
                subscriptionExpired.SubscriptionId,
                subscriptionExpired.Status
            });
    }

    private async Task When(SubscriptionCreatedDomainEvent subscriptionCreated)
    {
        var period = SubscriptionPeriod.GetName(subscriptionCreated.SubscriptionPeriodCode);
        
        await _connection.ExecuteScalarAsync("INSERT INTO payments.SubscriptionDetails " +
                                       "([Id], [Period], [Status], [CountryCode], [ExpirationDate]) " +
                                       "VALUES (@SubscriptionId, @Period, @Status, @CountryCode, @ExpirationDate)",
            new
            {
                subscriptionCreated.SubscriptionId,
                period,
                subscriptionCreated.Status,
                subscriptionCreated.CountryCode,
                subscriptionCreated.ExpirationDate
            });
    }
}

Sample view of Event Store

Sample Event Store view after execution of SubscriptionLifecycleTests Integration Test which includes following steps:

Creating Price List
Buying Subscription
Renewing Subscription
Expiring Subscription

looks like this (SQL Stream Store table - payments.Messages):

3.16 Database Change Management

Database change management is accomplished by migrations/transitions versioning. Additionally, the current state of the database structure is also versioned.

Migrations are applied using a simple DatabaseMigrator console application that uses the DbUp library. The current state of the database structure is kept in the SSDT Database Project.

The database update is performed by running the following command:

dotnet DatabaseMigrator.dll "connection_string" "scripts_directory_path"

The entire solution is described in detail in the following articles:

Database change management (theory)
Using database project and DbUp for database management (implementation)

3.17 Continuous Integration

Definition

As defined on Martin Fowler's website:

Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily - leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible.

YAML Implementation [OBSOLETE]

Originally the build was implemented using yaml and GitHub Actions functionality. Currently, the build is implemented with NUKE (see next section). See buildPipeline.yml file history.

Pipeline description

CI was implemented using GitHub Actions. For this purpose, one workflow, which triggers on Pull Request to master branch or Push to master branch was created. It contains 2 jobs:

build test, execute Unit Tests and Architecture Tests
execute Integration Tests

Steps description
a) Checkout repository - clean checkout of git repository
b) Setup .NET - install .NET 8.0 SDK
c) Install dependencies - resolve NuGet packages
d) Build - build solution
e) Run Unit Tests - run automated Unit Tests (see section 3.10)
f) Run Architecture Tests - run automated Architecture Tests (see section 3.12)
g) Initialize containers - setup Docker container for MS SQL Server
h) Wait for SQL Server initialization - after container initialization MS SQL Server is not ready, initialization of server itself takes some time so 30 seconds timeout before execution of next step is needed
i) Create Database - create and initialize database
j) Migrate Database - execute database upgrade using DatabaseMigrator application (see 3.16 section)
k) Run Integration Tests - perform Integration and System Integration Testing (see section 3.13 and 3.14)

Workflow definition

Workflow definition: buildPipeline.yml

Example workflow execution

Example workflow output:

NUKE

Nuke is the cross-platform build automation solution for .NET with C# DSL.

The 2 main advantages of its use over pure yaml defined in GitHub actions are as follows:

You run the same code on local machine and in the build server. See buildPipeline.yml
You use C# with all the goodness (debugging, compilation, packages, refactoring and so on)

This is how one of the stage definition looks like (execute Build, Unit Tests, Architecture Tests) Build.cs:

partial class Build : NukeBuild
{
    /// Support plugins are available for:
    ///   - JetBrains ReSharper        https://nuke.build/resharper
    ///   - JetBrains Rider            https://nuke.build/rider
    ///   - Microsoft VisualStudio     https://nuke.build/visualstudio
    ///   - Microsoft VSCode           https://nuke.build/vscode

    public static int Main () => Execute<Build>(x => x.Compile);

    [Parameter("Configuration to build - Default is 'Debug' (local) or 'Release' (server)")]
    readonly Configuration Configuration = IsLocalBuild ? Configuration.Debug : Configuration.Release;

    [Solution] readonly Solution Solution;

    Target Clean => _ => _
        .Before(Restore)
        .Executes(() =>
        {
            EnsureCleanDirectory(WorkingDirectory);
        });

    Target Restore => _ => _
        .Executes(() =>
        {
            DotNetRestore(s => s
                .SetProjectFile(Solution));
        });

    Target Compile => _ => _
        .DependsOn(Restore)
        .Executes(() =>
        {
            DotNetBuild(s => s
                .SetProjectFile(Solution)
                .SetConfiguration(Configuration)
                .EnableNoRestore());
        });

    Target UnitTests => _ => _
        .DependsOn(Compile)
        .Executes(() =>
        {
            DotNetTest(s => s
                .SetProjectFile(Solution)
                .SetFilter("UnitTests")
                .SetConfiguration(Configuration)
                .EnableNoRestore()
                .EnableNoBuild());
        });

    Target ArchitectureTests => _ => _
        .DependsOn(UnitTests)
        .Executes(() =>
        {
            DotNetTest(s => s
                .SetProjectFile(Solution)
                .SetFilter("ArchTests")
                .SetConfiguration(Configuration)
                .EnableNoRestore()
                .EnableNoBuild());
        });

    Target BuildAndUnitTests => _ => _
        .Triggers(ArchitectureTests)
        .Executes(() =>
        {
        });
}

If you want to see more complex scenario when integration tests are executed (with SQL Server database creation using docker) see BuildIntegrationTests.cs file.

SQL Server database project build

Currently, compilation of database projects is not supported by the .NET Core and dotnet tool. For this reason, the MSBuild.Sdk.SqlProj library was used. In order to do that, you need to create .NET standard library, change SDK and create links to scripts folders. Final database project looks as follows:

<Project Sdk="MSBuild.Sdk.SqlProj/1.6.0">
    <PropertyGroup>
        <TargetFramework>netstandard2.0</TargetFramework>
    </PropertyGroup>
    <ItemGroup>
        <Content Include="..\CompanyName.MyMeetings.Database\administration\**\*.sql" />
        <Content Include="..\CompanyName.MyMeetings.Database\app\**\*.sql" />
        <Content Include="..\CompanyName.MyMeetings.Database\meetings\**\*.sql" />
        <Content Include="..\CompanyName.MyMeetings.Database\payments\**\*.sql" />
        <Content Include="..\CompanyName.MyMeetings.Database\users\**\*.sql" />
        <Content Include="..\CompanyName.MyMeetings.Database\Security\**\*.sql" />
    </ItemGroup>
</Project>

3.18 Static code analysis

In order to standardize the appearance of the code and increase its readability, the StyleCopAnalyzers library was used. This library implements StyleCop rules using the .NET Compiler Platform and is responsible for the static code analysis.

Using this library is trivial - it is just added as a NuGet package to all projects. There are many ways to configure rules, but currently the best way to do this is to edit the .editorconfig file. More information can be found at the link above.

Note! Static code analysis works best when the following points are met:

Each developer has an IDE that respects the rules and helps to follow them
The rules are checked during the project build process as part of Continuous Integration
The rules are set to help your system grow. Static analysis is not a value in itself. Some rules may not make complete sense and should be turned off. Other rules may have higher priority. It all depends on the project, company standards and people involved in the project. Be pragmatic.

3.19 System Under Test SUT

There is always a need to prepare the entire system in a specific state, e.g. for manual, exploratory, UX / UI tests. The fact that the tests are performed manually does not mean that we cannot automate the preparation phase (Given / Arrange). Thanks to the automation of system state preparation (System Under Test), we are able to recreate exactly the same state in any environment. In addition, such automation can be used later to automate the entire test (e.g. through an 3.13 Integration Tests).

The implementation of such automation based on the use of NUKE and the test framework is presented below. As in the case of integration testing, we use the public API of modules.

Below is a SUT whose task is to go through the whole process - from setting up a Meeting Group, through its Payment, adding a new Meeting and signing up for it by another user.

public class CreateMeeting : TestBase
{
    protected override bool PerformDatabaseCleanup => true;

    [Test]
    public async Task Prepare()
    {
        await UsersFactory.GivenAdmin(
            UserAccessModule,
            "testAdmin@mail.com",
            "testAdminPass",
            "Jane Doe",
            "Jane",
            "Doe",
            "testAdmin@mail.com");

        var userId = await UsersFactory.GivenUser(
            UserAccessModule,
            ConnectionString,
            "adamSmith@mail.com",
            "adamSmithPass",
            "Adam",
            "Smith",
            "adamSmith@mail.com");

        ExecutionContextAccessor.SetUserId(userId);

        var meetingGroupId = await MeetingGroupsFactory.GivenMeetingGroup(
            MeetingsModule,
            AdministrationModule,
            ConnectionString,
            "Software Craft",
            "Group for software craft passionates",
            "Warsaw",
            "PL");

        await TestPriceListManager.AddPriceListItems(PaymentsModule, ConnectionString);

        await TestPaymentsManager.BuySubscription(
            PaymentsModule,
            ExecutionContextAccessor);
        
        SetDate(new DateTime(2022, 7, 1, 10, 0, 0));

        var meetingId = await TestMeetingFactory.GivenMeeting(
            MeetingsModule,
            meetingGroupId,
            "Tactical DDD",
            new DateTime(2022, 7, 10, 18, 0, 0),
            new DateTime(2022, 7, 10, 20, 0, 0),
            "Meeting about Tactical DDD patterns",
            "Location Name",
            "Location Address",
            "01-755",
            "Warsaw",
            50,
            0,
            null,
            null,
            0,
            null,
            new List<Guid>()
        );
        
        var attendeeUserId = await UsersFactory.GivenUser(
            UserAccessModule,
            ConnectionString,
            "rickmorty@mail.com",
            "rickmortyPass",
            "Rick",
            "Morty",
            "rickmorty@mail.com");
        
        ExecutionContextAccessor.SetUserId(attendeeUserId);

        await TestMeetingGroupManager.JoinToGroup(MeetingsModule, meetingGroupId);

        await TestMeetingManager.AddAttendee(MeetingsModule, meetingId, guestsNumber: 1);
    }
}

You can create this SUT using following NUKE target providing connection string and particular test name:

 .\build PrepareSUT --DatabaseConnectionString "connection_string" --SUTTestName CreateMeeting

3.20 Mutation Testing

Description

Mutation testing is an approach to test and evaluate our existing tests. During mutation testing a special framework modifies pieces of our code and runs our tests. These modifications are called mutations or mutants. If a given mutation does not cause a failure of at least once test, it means that the mutant has survived so our tests are probably not sufficient.

Example

In this repository, the Stryker.NET framework was used for mutation testing. In the simplest use, after installation, all you need to do is enter the directory of tests that you want to mutate and run the following command:

dotnet stryker

The result of this command is the mutation report file. Assuming we want to test the unit tests of the Meetings module, such a report has been generated. This is its first page:

Let us analyze one of the places where the mutant survived. This is the AddNotAttendee method of the Meeting class. This method is used to add a Member to the list of people who have decided not to attend the meeting. According to the logic, if the same person previously indicated that he was going to the Meeting and later changed his mind, then if there is someone on the Waiting List, he should be added to the attendees. Based on requirements, this should be the person who signed up on the Waiting List first (based on SignUpDate).

As you can see, the mutation framework changed our sorting in linq query (from default ascending to descending). However, each test was successful, so it means that mutant survived so we don't have a test that checks the correct sort based on SignUpDate.

From the example above, one more important thing can be deduced - code coverage is insufficient. In the given example, this code is covered, but our tests do not check the given requirement, therefore our code may have errors. Mutation testing allow to detect such situations. Of course, as with any tool, we should use it wisely, as not every case requires our attention.

4. Technology

List of technologies, frameworks and libraries used for implementation:

.NET 8.0 (platform). Note for Visual Studio users: VS 2019 is required.
MS SQL Server Express (database)
Entity Framework Core 8.0 (ORM Write Model implementation for DDD)
Autofac (Inversion of Control Container)
IdentityServer4 (Authentication and Authorization)
Serilog (structured logging)
Hellang.Middleware.ProblemDetails (API Problem Details support)
Swashbuckle (Swagger automated documentation)
Dapper (micro ORM for Read Model)
Newtonsoft.Json (serialization/deserialization to/from JSON)
Quartz.NET (background processing)
FluentValidation (data validation)
MediatR (mediator implementation)
Postman (API tests)
NUnit (Testing framework)
NSubstitute (Testing isolation framework)
Visual Paradigm Community Edition (CASE tool for modeling and documentation)
NetArchTest (Architecture Unit Tests library)
Polly (Resilience and transient-fault-handling library)
SQL Stream Store (Library to assist with Event Sourcing)
DbUp (Database migrations deployment)
SSDT Database Project (Database structure versioning)
GitHub Actions (Continuous Integration workflows implementation)
StyleCopAnalyzers (Static code analysis library)
PlantUML (UML diagrams from textual description, diagrams as text)
C4 Model (Model for visualising software architecture)
C4-PlantUML (C4 Model for PlantUML plugin)
NUKE (Build automation system)
MSBuild.Sdk.SqlProj (Database project compilation)
Stryker.NET (Mutation Testing framework)

5. How to Run

Install .NET 8.0 SDK

Download and install .NET 8.0 SDK

Create database

Download and install MS SQL Server Express or other
Create an empty database using CreateDatabase_Windows.sql or CreateDatabase_Linux.sql. Script adds app schema which is needed for migrations journal table. Change database file path if needed.
Run database migrations using MigrateDatabase NUKE target by executing the build.sh script present in the root folder:

.\build MigrateDatabase --DatabaseConnectionString "connection_string"

"connection_string" - connection string to your database

Seed database

Execute SeedDatabase.sql script
2 test users will be created - check the script for usernames and passwords

Configure connection string

Set a database connection string called MeetingsConnectionString in the root of the API project's appsettings.json or use Secrets

Example config setting in appsettings.json for a database called MyMeetings:

{
 "MeetingsConnectionString": "Server=(localdb)\\mssqllocaldb;Database=MyMeetings;Trusted_Connection=True;"
}

Configure startup in IDE

Set the Startup Item in your IDE to the API Project, not IIS Express

Authenticate

Once it is running you'll need a token to make API calls. This is done via OAuth2 Resource Owner Password Grant Type. By default IdentityServer is configured with the following:
client_id = ro.client
client_secret = secret (this is literally the value - not a statement that this value is secret!)
scope = myMeetingsAPI openid profile
grant_type = password

Include the credentials of a test user created in the SeedDatabase.sql script - for example:

username = testMember@mail.com
password = testMemberPass

Example HTTP Request for an Access Token:

POST /connect/token HTTP/1.1
Host: localhost:5000
 
grant_type=password
&username=testMember@mail.com
&password=testMemberPass
&client_id=ro.client
&client_secret=secret

This will fetch an access token for this user to make authorized API requests using the HTTP request header Authorization: Bearer <access_token>

If you use a tool such as Postman to test your API, the token can be fetched and stored within the tool itself and appended to all API calls. Check your tool documentation for instructions.

Run using Docker Compose

You can run whole application using docker compose from root folder:

docker-compose up

It will create following services:

MS SQL Server Database
Database Migrator
Application

Run Integration Tests in Docker

You can run all Integration Tests in Docker (exactly the same process is executed on CI) using RunAllIntegrationTests NUKE target:

.\build RunAllIntegrationTests

6. Contribution

This project is still under analysis and development. I assume its maintenance for a long time and I would appreciate your contribution to it. Please let me know by creating an Issue or Pull Request.

7. Roadmap

List of features/tasks/approaches to add:

Name	Status	Release date
Domain Model Unit Tests	Completed	2019-09-10
Architecture Decision Log update	Completed	2019-11-09
Integration automated tests	Completed	2020-02-24
Migration to .NET Core 3.1	Completed	2020-03-04
System Integration Testing	Completed	2020-03-28
More advanced Payments module	Completed	2020-07-11
Event Sourcing implementation	Completed	2020-07-11
Database Change Management	Completed	2020-08-23
Continuous Integration	Completed	2020-09-01
StyleCop Static Code Analysis	Completed	2020-09-05
FrontEnd SPA application	Completed	2020-11-08
Docker support	Completed	2020-11-26
PlantUML Conceptual Model	Completed	2021-03-22
C4 Model	Completed	2021-03-29
Meeting comments feature	Completed	2021-03-30
NUKE build automation	Completed	2021-06-15
Database project compilation on CI	Completed	2021-06-15
System Under Test implementation	Completed	2022-07-17
Mutation Testing	Completed	2022-08-23
Migration to .NET 8.0	Completed	2023-12-09

NOTE: Please don't hesitate to suggest something else or a change to the existing code. All proposals will be considered.

8. Authors

Kamil Grzybek

Blog: https://kamilgrzybek.com

Twitter: https://twitter.com/kamgrzybek

LinkedIn: https://www.linkedin.com/in/kamilgrzybek/

GitHub: https://github.com/kgrzybek

8.1 Main contributors

9. License

The project is under MIT license.

10. Inspirations and Recommendations

Event Storming

"Introducing EventStorming" book, Alberto Brandolini
"Awesome EventStorming" GH repository, Mariusz Gil

Event Sourcing

"Hands-On Domain-Driven Design with .NET Core: Tackling complexity in the heart of software by putting DDD principles into practice" book, Alexey Zimarev
"Versioning in an Event Sourced System" book, Greg Young
Hands-On-Domain-Driven-Design-with-.NET-Core GH repository, Alexey Zimarev
EventSourcing.NetCore GH repository, Oskar Dudycz

dotnet/aspnetcore

ASP.NET Core is a cross-platform .NET framework for building modern cloud-based web applications on Windows, Mac, or Linux.

ASP.NET Core

ASP.NET Core is an open-source and cross-platform framework for building modern cloud-based internet-connected applications, such as web apps, IoT apps, and mobile backends. ASP.NET Core apps run on .NET, a free, cross-platform, and open-source application runtime. It was architected to provide an optimized development framework for apps that are deployed to the cloud or run on-premises. It consists of modular components with minimal overhead, so you retain flexibility while constructing your solutions. You can develop and run your ASP.NET Core apps cross-platform on Windows, Mac, and Linux. Learn more about ASP.NET Core.

Get started

Follow the Getting Started instructions.

Also check out the .NET Homepage for released versions of .NET, getting started guides, and learning resources.

See the Triage Process document for more information on how we handle incoming issues.

How to engage, contribute, and give feedback

Some of the best ways to contribute are to try things out, file issues, join in design conversations, and make pull-requests.

Download our latest daily builds
Follow along with the development of ASP.NET Core:
- Community Standup: The community standup is held every week and streamed live on YouTube. You can view past standups in the linked playlist.
- Roadmap: The schedule and milestone themes for ASP.NET Core.
Build ASP.NET Core source code
Check out the contributing page to see the best places to log issues and start discussions.

Reporting security issues and bugs

Security issues and bugs should be reported privately to the Microsoft Security Response Center (MSRC) via the MSRC Researcher Portal. You should receive a response within 24 hours. Further information can be found in the MSRC Report an Issue FAQ. You can also find these instructions in this repo's Security doc.

Also see info about related Microsoft .NET Bounty Program.

Related projects

These are some other repos for related projects:

Documentation - documentation sources for https://learn.microsoft.com/aspnet/core/
Entity Framework Core - data access technology
Runtime - cross-platform runtime for cloud, mobile, desktop, and IoT apps
Razor - the Razor compiler and tooling for working with Razor syntax (.cshtml, .razor)

Code of conduct

See CODE-OF-CONDUCT

Nightly builds

This table includes links to download the latest builds of the ASP.NET Core Shared Framework. Also included are links to download the Windows Hosting Bundle, which includes the ASP.NET Core Shared Framework, the .NET Runtime Shared Framework, and the IIS plugin (ASP.NET Core Module). You can download the latest .NET Runtime builds here, and the latest .NET SDK builds here. If you're unsure what you need, then install the SDK; it has everything except the IIS plugin.

Platform	Shared Framework (Installer)	Shared Framework (Binaries)	Hosting Bundle (Installer)
Windows x64	Installer	Binaries	Installer
Windows x86	Installer	Binaries	Installer
Windows arm64	Installer	Binaries	Installer
macOS x64	N/A	Binaries	N/A
macOS arm64	N/A	Binaries	N/A
Linux x64	Deb Installer - RPM Installer	Binaries	N/A
Linux arm	N/A	Binaries	N/A
Linux arm64	RPM Installer	Binaries	N/A
Linux-musl-x64	N/A	Binaries	N/A
Linux-musl-arm	N/A	Binaries	N/A
Linux-musl-arm64	N/A	Binaries	N/A

Klocman/Bulk-Crap-Uninstaller

Remove large amounts of unwanted applications quickly.

⚠️ Looking for maintainers ⚠️

Bulk Crap Uninstaller

Bulk Crap Uninstaller (or BCUninstaller) is a free (as in speech) program uninstaller. It excels at removing large amounts of applications with minimal user input. It can clean up leftovers, detect orphaned applications, run uninstallers according to premade lists, and much more! Even though BCU was made with IT pros in mind, it can be used by anyone with a basic understanding of how applications are installed/uninstalled in Windows.

BCU is fully compatible with Windows Store Apps, Steam, Windows Features and has special support for many uninstalling systems (NSIS, InnoSetup, Msiexec, and many other). Check below for a full list of functions.

Bulk Crap Uninstaller is licensed under Apache 2.0 open source license, and can be used in both private and commercial settings for free and with no obligations, as long as no conditions of the license are broken.

Visit the official homepage to see the full list of quirks and features!

Read the online documentation if you have any questions or issues (the help file included with all releases). If you didn't find an answer to your question, feel free to open a new issue.

Download

You can get the latest version from the releases page. Alternatively you can download it from one of these hosts:

What are the different variants?

Setup - Installs BCU as a normal application. If your system is missing the required .NET runtime, it is automatically installed as well.
Portable - Self-contained version that does not require the .NET runtime to run. It includes a runtime which is why the file size is so large.
net - Stand-alone portable version that requires the .NET runtime to be installed. Much smaller file size than the full Portable version.

Nightly builds

If you want to get the latest features and fixes as soon as they are available, you can download a nightly build from the actions page.

System requirements

BCUninstaller v6

Earliest supported OS: Windows 10 (may work on Windows 7)
Requirements: .NET 8 desktop runtime (not needed for portable)

To get this version download the latest release from the links below.

*Note: Since none of the supported systems have x86 versions, v6 releases no longer include an x86 build. If you need one you can still compile it yourself, or you can use the AnyCPU build instead.

BCUninstaller v5

Earliest supported OS: Windows 7 SP1 with all Platform Updates (KB2670838, KB2533623, etc.)
Requirements: .NET 6 desktop runtime (not needed for portable)

If you get a DLL error on startup then try running Windows Update. If you get a framework error, install .NET6 either manually or through Windows Update.

To get this version download the latest available 5.x release.

*Note: The Portable version does not require the .NET6 runtime to be installed, since it is included (that's why the portable version is so large).

BCUninstaller v1 - v4

Earliest supported OS: Windows XP (XP support may be dodgy in later releases)
Requirements: .Net Framework 4.5 (some versions can run on .Net Framework 3.5 with reduced functionality)

Make sure you have .Net Framework 4.5 installed with all available updates for your system (it is not installed on XP by default).

To get this version compile the legacy 4.x branch or download the latest available 4.x release.

How can I help?

Please check the contribution notes!

Compiling

Development is done on Visual Studio 2022. The solution should just load and build without doing anything extra, provided necessary VS features are installed. The installer is compiled with InnoSetup v6.4. To make a release you have to first run the publish.bat script.

Screenshots

QL-Win/QuickLook

Bring macOS “Quick Look” feature to Windows

QuickLook

Instant File Previews, Just Press Space

The most powerful Quick Look implementation for Windows

The Problem

Superpowers

Get Started

Extend

Community

💡 The Problem

Ever wished Windows had macOS's Quick Look?

You know the drill: you want to peek at a file, so you double-click, wait for an app to launch, view the file, close the app... exhausting, right?

macOS users? They just press Space. Instant preview. Any file.

Now Windows has it too. 🎉

QuickLook brings that buttery-smooth, instant-preview experience to Windows. No more waiting. No more opening heavy applications just to peek at a document.

WITHOUT QuickLook:
┌─────────────────┐
│ 1. Double click │
│ 2. Wait...      │
│ 3. App loads    │
│ 4. View file    │
│ 5. Close app    │
└─────────────────┘
   ⏱️ ~10 seconds

WITH QuickLook:
┌─────────────────┐
│ 1. Press SPACE  │
│ 2. Done! ✨     │
└─────────────────┘
   ⚡ ~0.2 seconds

🚀 Superpowers

What Makes QuickLook Extraordinary

⚡️ Lightning Speed

Instant previews with zero lag

Native performance that feels like magic

Hardware-accelerated rendering

🎨 Gorgeous Design

Fluent Design System integration

Beautiful on 4K displays

Touch-optimized interface

🌈 100+ Formats

Images, videos, documents, code

3D models, archives, fonts

Extensible with plugins

📸 Visual Files

🖼️ Images (JPEG, PNG, GIF, WebP, RAW)
🎬 Videos (MP4, AVI, MKV, MOV)
🎨 Photoshop (PSD), Illustrator (AI)
📐 3D Models (OBJ, STL, FBX)
🎭 Animated GIFs & APNGs

📄 Documents

📝 PDF, Word, Excel, PowerPoint
📋 Text files with syntax highlighting
📊 Markdown with live rendering
📜 E-books (EPUB, MOBI)
📑 Comics (CBZ, CBR)

💻 Developer Files

🐍 Python, JavaScript, C++, Rust
🌐 HTML, CSS, JSON, XML
⚙️ Config files (YAML, TOML, INI)
📦 Archives (ZIP, RAR, 7Z, TAR)
🔧 Binary files with hex view

🎵 Media

🎵 Audio (MP3, FLAC, WAV, AAC)
🎼 Sheet music
🎨 Fonts (TTF, OTF, WOFF)
🖌️ Vector graphics (SVG, EPS)
📹 Subtitles (SRT, ASS)

🎯 Works Everywhere

File Explorer

Native integration

Open/Save Dialogs

System-wide support

3rd Party Managers

Total Commander, xplorer²

Cloud Storage

OneDrive, Dropbox ready

📦 Get Started

Choose Your Adventure

Microsoft Store

Recommended for most users

✅ Automatic updates ✅ Sandboxed security ✅ One-click install

_{⚠️ Limited Open/Save dialog support}

Installer

Full-featured experience

✅ Complete functionality ✅ Open/Save dialog support ✅ Portable option available

_{💎 Get the full power}

Scoop

For command-line lovers

✅ Easy updates ✅ Reproducible installs ✅ Version management

scoop bucket add extras
scoop install quicklook

_{🤓 Power user choice}

Nightly

Live on the edge

✅ Latest features ✅ Bug fixes first ⚠️ May be unstable

_{🌙 Experimental builds}

🤔 Not sure which version to choose?

Feature	Store	Installer	Scoop	Nightly
Auto-updates	✅	⚠️	✅	⚠️
Open/Save dialogs	❌	✅	✅	✅
Portable mode	❌	✅	❌	✅
Stability	✅✅✅	✅✅✅	✅✅✅	✅✅

📖 Read the full comparison

⚡ Quick Start in 10 Seconds

Step 1️⃣  Install QuickLook
         ↓
Step 2️⃣  It runs automatically
         ↓
Step 3️⃣  Select any file
         ↓
Step 4️⃣  Press SPACE
         ↓
Step 5️⃣  🎉 Magic happens!

💡 Pro Tips:

QuickLook lives in your system tray
Works with any file in File Explorer
Use arrow keys to preview multiple files
Press Esc or Space again to close
Drag files directly from the preview!

⌨️ Master the Shortcuts

Your New Superpowers

🎮 Basic Controls

Key	Action
`Space`	Toggle preview
`Esc` `Space`	Close window
`Enter`	Open file
`↑` `↓`	Next/Previous

🔍 Navigation

Key	Action
`←` `→`	Navigate files
`Mouse Click`	Select file
`Page Up` `Down`	Scroll content
`Home` `End`	Jump to start/end

🎨 Advanced

Key	Action
`Wheel`	Zoom (images)
`Ctrl`+`Wheel`	Zoom (PDFs)
`L-Click Drag`	Rotate 3D
`M-Click Drag`	Pan 3D

💡 Pro Tip: You can navigate files using arrow keys even when the preview window isn't focused!

🧩 Extend

Supercharge QuickLook with Plugins

Transform QuickLook into a universal file viewer

OfficeViewer

Preview Word, Excel & PowerPoint files

No Microsoft Office required!

✅ Native Office formats
✅ Standalone viewer
✅ Fast rendering

PdfViewer-Native

Enhanced PDF viewing with WebView2

Modern, fast, feature-rich

✅ Smooth scrolling
✅ Search & annotations
✅ Hardware acceleration

PostScriptViewer

Preview .ps and .eps files

Perfect for designers

✅ Vector rendering
✅ High quality output
✅ Professional formats

CADImport

View CAD files natively

.dwg, .dxf, .plt, .cgm

✅ Engineering drawings
✅ Architecture files
✅ Technical diagrams

📦 How to Install or Upgrade Plugins

1️⃣ Download

Get the .qlplugin file

2️⃣ Install

Ensure QuickLook is currently running, select the file and press Spacebar.

3️⃣ Restart

Click on the Install button, then restart QuickLook.

📦 How to Remove Plugins

1️⃣ Quit

Quit QuickLook.

2️⃣ Navigate

Navigate to the Data location.

3️⃣ Remove

You should find several folders. Remove the one you do not want to use.

💖 Community

Join Thousands of Happy Users

QQ Group

Join our Chinese community

371388501

Translate

Help QuickLook speak your language

Make it accessible

Star Us

Show your support

It means a lot!

👨‍💻 For Developers

Interested in contributing? Check out our development resources:

🙏 Credits

Built with Love by Amazing People

Design Team

@OiCkilL @QubitsDev @Donno @Shomnipotence

Fluent UI & Icons

Contributors

Our Amazing Team

Code, translations & ideas

Open Source

Libraries We Use

Standing on giants

You!

Every User Matters

Thank you for using QuickLook

📜 License

QuickLook is free and open source under GPL-3.0

Free software, free forever. No ads, no tracking, no premium tiers.

Need commercial licensing? Contact us for sublicensing options.

⭐ Like QuickLook? Star the repo!

Your support keeps this project alive and improving

_{Made with ❤️ by the QuickLook community}

jasontaylordev/CleanArchitecture

Clean Architecture Solution Template for ASP.NET Core

Clean Architecture Solution Template

The goal of this template is to provide a straightforward and efficient approach to enterprise application development, leveraging the power of Clean Architecture and ASP.NET Core. Using this template, you can effortlessly create a new app with Angular, React, or Web API only, powered by ASP.NET Core and Aspire. Getting started is easy - simply install the .NET template (see below for full details).

For full documentation, visit cleanarchitecture.jasontaylor.dev.

If you find this project useful, please give it a star. Thanks! ⭐

Getting started

Prerequisites

.NET 10.0 SDK or later
Node.js (LTS) — only required if you plan to use the Angular or React frontend
Docker Desktop or Podman (or any OCI-compliant container runtime) — only required when using SQL Server or PostgreSQL. Not required when using SQLite (the default).

Install the template

dotnet new install Clean.Architecture.Solution.Template

Create a new solution

Create a new solution using the template. Specify the client framework using --client-framework (-cf) and the database provider using --database (-db):

dotnet new ca-sln --client-framework [angular|react|none] --database [postgresql|sqlite|sqlserver] --output YourProjectName

Option	Values	Default
`--client-framework`	`angular`, `react`, `none`	`angular`
`--database`	`postgresql`, `sqlite`, `sqlserver`	`sqlite`

Examples:

🅰️ Angular SPA with ASP.NET Core Web API and PostgreSQL:

dotnet new ca-sln -cf angular -db postgresql -o YourProjectName

⚛️ React SPA with ASP.NET Core Web API and SQL Server:

dotnet new ca-sln -cf react -db sqlserver -o YourProjectName

🔌 ASP.NET Core Web API only with SQLite:

dotnet new ca-sln -cf none -db sqlite -o YourProjectName

💡 Tip: Run dotnet new ca-sln --help to see all available template options.

Run the app

dotnet run --project .\src\AppHost

The Aspire dashboard will open automatically, showing the application URLs and logs.

To learn more, see the Getting started guide and Architecture overview.

Technologies

Versions

The main branch is on .NET 10.0. Previous versions are available:

Version	Branch
.NET 9.0	`net9.0`
.NET 8.0	`net8.0`
.NET 7.0	`net7.0`
.NET 6.0	`net6.0`
.NET 5.0	`net5.0`
.NET Core 3.1	`netcore3.1`

Architectural decisions

Key design decisions are documented as Architecture Decision Records.

Learn more

📖 Clean Architecture Solution Template documentation

Support

If you are having problems, please let me know by raising a new issue.

License

This project is licensed under the MIT License.

dotnet/eShop

A reference .NET application implementing an eCommerce site

eShop Reference Application - "AdventureWorks"

A reference .NET application implementing an e-commerce website using a services-based architecture using .NET Aspire.

Getting Started

This version of eShop is based on .NET 9.

Previous eShop versions:

.NET 8

Prerequisites

Clone the eShop repository: https://github.com/dotnet/eshop
Install & start Docker Desktop

Windows with Visual Studio

Install Visual Studio 2022 version 17.10 or newer.
- Select the following workloads:
  - ASP.NET and web development workload.
  - .NET Aspire SDK component in Individual components.
  - Optional: .NET Multi-platform App UI development to run client apps

Run the following commands in a Powershell & Terminal running as Administrator to automatically configure your environment with the required tools to build and run this application. (Note: A restart is required and included in the script below.)

install-Module -Name Microsoft.WinGet.Configuration -AllowPrerelease -AcceptLicense -Force
$env:Path = [System.Environment]::GetEnvironmentVariable("Path","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path","User")
get-WinGetConfiguration -file .\.configurations\vside.dsc.yaml | Invoke-WinGetConfiguration -AcceptConfigurationAgreements

From Dev Home go to Machine Configuration -> Clone repositories. Enter the URL for this repository. In the confirmation screen look for the section Configuration File Detected and click Run File.

Mac, Linux, & Windows without Visual Studio

Install the latest .NET 9 SDK

Run the following commands in a Powershell & Terminal running as Administrator to automatically configuration your environment with the required tools to build and run this application. (Note: A restart is required after running the script below.)

Install Visual Studio Code and related extensions

install-Module -Name Microsoft.WinGet.Configuration -AllowPrerelease -AcceptLicense  -Force
$env:Path = [System.Environment]::GetEnvironmentVariable("Path","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path","User")
get-WinGetConfiguration -file .\.configurations\vscode.dsc.yaml | Invoke-WinGetConfiguration -AcceptConfigurationAgreements

Note: These commands may require sudo

Optional: Install Visual Studio Code with C# Dev Kit
Optional: Install .NET MAUI Workload

Note: When running on Mac with Apple Silicon (M series processor), Rosetta 2 for grpc-tools.

Running the solution

Warning

Remember to ensure that Docker is started

(Windows only) Run the application from Visual Studio:

Open the eShop.Web.slnf file in Visual Studio
Ensure that eShop.AppHost.csproj is your startup project
Hit Ctrl-F5 to launch Aspire

Or run the application from your terminal:

dotnet run --project src/eShop.AppHost/eShop.AppHost.csproj

then look for lines like this in the console output in order to find the URL to open the Aspire dashboard:

Login to the dashboard at: http://localhost:19888/login?t=uniquelogincodeforyou

You may need to install ASP.NET Core HTTPS development certificates first, and then close all browser tabs. Learn more at https://aka.ms/aspnet/https-trust-dev-cert

Azure Open AI

When using Azure OpenAI, inside eShop.AppHost/appsettings.json, add the following section:

  "ConnectionStrings": {
    "OpenAi": "Endpoint=xxx;Key=xxx;"
  }

Replace the values with your own. Then, in the eShop.AppHost Program.cs, set this value to true

bool useOpenAI = false;

Here's additional guidance on the .NET Aspire OpenAI component.

Use Azure Developer CLI

You can use the Azure Developer CLI to run this project on Azure with only a few commands. Follow the next instructions:

Install the latest or update to the latest Azure Developer CLI (azd).
Log in azd (if you haven't done it before) to your Azure account:

azd auth login

Initialize azd from the root of the repo.

azd init

During init:
- Select Use code in the current directory. Azd will automatically detect the .NET Aspire project.
- Confirm .NET (Aspire) and continue.
- Select which services to expose to the Internet (exposing webapp is enough to test the sample).
- Finalize the initialization by giving a name to your environment.
Create Azure resources and deploy the sample by running:

azd up

Notes:

The operation takes a few minutes the first time it is ever run for an environment.
At the end of the process, azd will display the url for the webapp. Follow that link to test the sample.
You can run azd up after saving changes to the sample to re-deploy and update the sample.
Report any issues to azure-dev repo.
FAQ and troubleshoot for azd.

Contributing

For more information on contributing to this repo, read the contribution documentation and the Code of Conduct.

Sample data

The sample catalog data is defined in catalog.json. Those product names, descriptions, and brand names are fictional and were generated using GPT-35-Turbo, and the corresponding product images were generated using DALL·E 3.

eShop on Azure

For a version of this app configured for deployment on Azure, please view the eShop on Azure repo.

mob-sakai/ParticleEffectForUGUI

Render particle effect in UnityUI(uGUI). Maskable, sortable, and no extra Camera/RenderTexture/Canvas.

Particle Effect For UGUI (UI Particle)

📝 Description

This package uses the new APIs MeshBake/MeshTrailBake (introduced in Unity 2018.2) to render particles through CanvasRenderer.
You can render, mask, and sort your ParticleSystems for UI without the need for an additional Camera, RenderTexture, or Canvas.

📌 Key Features

Easy to use: The package is ready to use out of the box.
Sortable: Sort particle effects and other UI elements by sibling index.
Maskable: Supports Mask or RectMask2D.
No extra components required: No need for an additional Camera, RenderTexture, or Canvas.
Trail module support: Fully supports the Trail module.
CanvasGroup alpha support: Integrates with CanvasGroup alpha.
No allocations: Efficiently renders particles without allocations.
Any canvas render mode support: Works with overlay, camera space, and world space.
Any Render pipeline support: Compatible with Universal Render Pipeline (URP) and High Definition Render Pipeline (HDRP).
Disabling domain reload support: Supports disabling Enter Play Mode Options > Reload Domain.
Animatable material properties: Supports changing material properties with AnimationClip (AnimatableProperty).
Multiple materials: Supports 8+ materials.
Correct positioning: Adjusts world space particle positions correctly when changing window size for standalone platforms (Windows, MacOSX, and Linux).
Adaptive scaling: Provides adaptive scaling for UI (AutoScalingMode).
Performance optimization: Mesh sharing group to improve performance.
Particle attractor: Includes a particle attractor component.
Emission position mode: Supports relative/absolute particle emission position modes.
Custom view size: Fixes min/max particle size mismatch.

🎮 Demo

WebGL Demo

WebGL Demo (Cartoon FX & War FX)
- Cartoon FX Free & War FX (by Jean Moreno (JMO)) with UIParticle

⚙ Installation

This package requires Unity 2018.3 or later.

Install via OpenUPM

This package is available on OpenUPM package registry.
This is the preferred method of installation, as you can easily receive updates as they're released.
If you have openupm-cli installed, then run the following command in your project's directory:
```
openupm add com.coffee.ui-particle
```
To update the package, use Package Manager UI (Window > Package Manager) or run the following command with @{version}:
```
openupm add com.coffee.ui-particle@4.9.0
```

Install via UPM (with Package Manager UI)

Click Window > Package Manager to open Package Manager UI.
Click + > Add package from git URL... and input the repository URL: https://github.com/mob-sakai/ParticleEffectForUGUI.git
To update the package, change suffix #{version} to the target version.
- e.g. https://github.com/mob-sakai/ParticleEffectForUGUI.git#4.9.0

Install via UPM (Manually)

Open the Packages/manifest.json file in your project. Then add this package somewhere in the dependencies block:

{
  "dependencies": {
    "com.coffee.ui-particle": "https://github.com/mob-sakai/ParticleEffectForUGUI.git",
    ...
  }
}

To update the package, change suffix #{version} to the target version.
- e.g. "com.coffee.ui-particle": "https://github.com/mob-sakai/ParticleEffectForUGUI.git#4.9.0",

Install as Embedded Package

Download a source code zip file from Releases and extract it.
Place it in your project's Packages directory.

If you want to fix bugs or add features, install it as an embedded package.
To update the package, you need to re-download it and replace the contents.

🚀 Usage

Component: UIParticle

UIParticle controls the ParticleSystems that are attached to its own game objects and child game objects.

Maskable: Does this graphic allow maskable.
Scale: Scale the rendering particles. When the 3D toggle is enabled, 3D scale (x, y, z) is supported.
Animatable Properties: If you want to update material properties (e.g., _MainTex_ST, _Color) in AnimationClip, use this to mark as animatable.
Mesh Sharing: Particle simulation results are shared within the same group. A large number of the same effects can be displayed with a small load. When the Random toggle is enabled, it will be grouped randomly.
- None: Disable mesh sharing.
- Auto: Automatically select Primary/Replica.
- Primary: Provides particle simulation results to the same group.
- Primary Simulator: Primary, but do not render the particle (simulation only).
- Replica: Render simulation results provided by the primary.
Position Mode: Emission position mode.
- Absolute: The particles will be emitted from the world position.
- Relative: The particles will be emitted from the scaled position.
Auto Scaling Mode: How to automatically adjust when the Canvas scale is changed by the screen size or reference resolution.
- None: Do nothing.
- Transform: Transform.lossyScale (=world scale) will be set to (1, 1, 1).
- UIParticle: UIParticle.scale will be adjusted.
Use Custom View: Use this if the particles are not displayed correctly due to min/max particle size.
- Custom view size: Change the bake view size.
Time Scale Multiplier: Time scale multiplier.
Rendering Order: The ParticleSystem list to be rendered. You can change the order and the materials.

NOTE: Press the Refresh button to reconstruct the rendering order based on children ParticleSystem's sorting order and z-position.

Basic Usage

Select GameObject/UI/ParticleSystem to create UIParticle with a ParticleSystem.
Adjust the ParticleSystem as you like.

Usage with Your Existing ParticleSystem Prefab

Select GameObject/UI/ParticleSystem (Empty) to create UIParticle.
Drag and drop your ParticleSystem prefab onto UIParticle.

Usage with `Mask` or `RectMask2D` Component

If you want to mask particles, set a stencil-supported shader (such as UI/UIAdditive) to the material for ParticleSystem. If you use some custom shaders, see the How to Make a Custom Shader to Support Mask/RectMask2D Component section.

Usage with Script

// Instantiate ParticleSystem prefab with UIParticle on runtime.
var go = GameObject.Instantiate(prefab);
var uiParticle = go.AddComponent<UIParticle>();
uiParticle.scale = 100;

// Control by ParticleSystem.
particleSystem.Play();
particleSystem.Emit(10);

// Control by UIParticle.
uiParticle.Play();
uiParticle.Stop();

Component: UIParticleAttractor

UIParticleAttractor attracts particles generated by the specified ParticleSystem.

Particle Systems: Attracts particles generated by the specified ParticleSystems.
Destination Radius: Once the particle is within the radius, the particle lifetime will become 0, and OnAttracted will be called.
Delay Rate: Delay to start attracting. It is a percentage of the particle's start lifetime.
Max Speed: Maximum speed of attracting. If this value is too small, attracting may not be completed by the end of the lifetime, and OnAttracted may not be called.
Movement: Attracting movement type. (Linear, Smooth, Sphere)
Update Mode: Update mode.
- Normal: Update with scaled delta time.
- Unscaled Time: Update with unscaled delta time.
OnAttracted: An event called when attracting is complete (per particle).

Project Settings

Click Edit > Project Settings to open the Project Settings window and then select UI > UI Particle category.

🛠 Development Note

Compares the Baking mesh approach with the conventional approach

Baking mesh approach (=UIParticle)
- ✅ Rendered as is.
- ✅ Maskable.
- ✅ Sortable.
- ✅ Less objects.
Do nothing (=Plain ParticleSystem)
- ✅ Rendered as is.
- ❌ Looks like a glitch.
- ❌ Not maskable.
- ❌ Not sortable.
Convert particle to UIVertex (=UIParticleSystem)
- ✅ Maskable.
- ✅ Sortable.
- ❌ Adjustment is difficult.
- ❌ Requires UI shaders.
- ❌ Difficult to adjust scale.
- ❌ Force hierarchy scalling.
- ❌ Simulation results are incorrect.
- ❌ Trail, rotation of transform, time scaling are not supported.
- ❌ Generate heavy GC every frame.
Use Canvas to sort (Sorting By Canvas )
- ✅ Rendered as is.
- ✅ Sortable.
- ❌ You must to manage sorting orders.
- ❌ Not maskable.
- ❌ More batches.
- ❌ Requires Canvas.
Use RenderTexture
- ✅ Maskable.
- ✅ Sortable.
- ❌ Requires Camera and RenderTexture.
- ❌ Difficult to adjust position and size.
- ❌ Quality depends on the RenderTexture's setting.

Performance test results

Approach	FPS on Editor	FPS on iPhone6	FPS on Xperia XZ
Particle System	43	57	22
UIParticleSystem	4	3	0 (unmeasurable)
Sorting By Canvas	43	44	18
UIParticle	17	12	4
UIParticle with MeshSharing	44	45	30

🔍 FAQ: Why Are My UIParticles Not Displayed Correctly?

If ParticleSystem alone displays particles correctly but UIParticle does not, please check the following points:

Shader Limitation
- UIParticle does not support all built-in shaders except for UI/Default.
- Most cases can be solved by using UI/Additive or UI/Default.
Particles are not masked
- UIParticle is maskable.
- Set Mask or RectMask2D component properly.
- Use maskable/clipable shader (such as UI/Additive or UI/Default)
Particles are too small
- If particles are small enough, they will not appear on the screen.
- Increase the Scale value.
- If you don't want to change the apparent size depending on the resolution, try the Auto Scaling option.
Particles are too many
- No more than 65535 vertices can be displayed (for mesh combination limitations).
- Please set Emission module and Max Particles of ParticleSystem properly.
Particles are emitted off-screen.
- When Position Mode = Relative, particles are emitted from the scaled position of the ParticleSystem, not from the screen point of the ParticleSystem.
- Place the ParticleSystem in the proper position or try Position Mode = Absolute.
Attaching UIParticle to the same object as ParticleSystem
- Transform.localScale will be overridden by the Auto Scaling option.
- It is recommended to place ParticleSystem under UIParticle.
If Transform.localScale contains 0, rendering will be skipped.
Displayed particles are in the correct position but too large/too small
- Adjust ParticleSystem.renderer.Min/MaxParticleSize.

Shader Limitation

The use of UI shaders is recommended.

If you need a simple Additive shader, use the UI/Additive shader instead.
If you need a simple alpha-blend shader, use the UI/Default shader instead.
If your custom shader does not work properly with UIParticle, consider creating a custom UI shader.

Built-in shaders are not supported

UIParticle does not support all built-in shaders except for UI/Default.
If their use is detected, an error is displayed in the inspector.
Use UI shaders instead.

(Unity 2018 or 2019) UV.zw components will be discarded

UIParticleRenderer renders the particles based on UIVertex.
Therefore, only the xy components are available for each UV in the shader. (zw components will be discarded).
So unfortunately, UIParticles will not work well with some shaders.

(Unity 2018 or 2019) Custom vertex streams

When using custom vertex streams, you can fill zw components with "unnecessary" data.
Refer to this issue for more information.

Overheads

UIParticle has some overheads, and the batching depends on uGUI.
When improving performance, keep the following in mind:

If you are displaying a large number of the same effect, consider the Mesh Sharing feature in the UIParticle Component.
- If you don't like the uniform output, consider the Random Group feature.
If you are using multiple materials, you will have more draw calls.
- Consider a single material, atlasing the sprites, and using Sprite mode in the Texture Sheet Animation module in the ParticleSystem.

How to Make a Custom Shader to Support `Mask` and `RectMask2D` Component

Shader tips

Shader "Your/Custom/Shader"
{
    Properties
    {
        // ...
        // #### required for Mask ####
        _StencilComp ("Stencil Comparison", Float) = 8
        _Stencil ("Stencil ID", Float) = 0
        _StencilOp ("Stencil Operation", Float) = 0
        _StencilWriteMask ("Stencil Write Mask", Float) = 255
        _StencilReadMask ("Stencil Read Mask", Float) = 255
        _ColorMask ("Color Mask", Float) = 15
        [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
    }

    SubShader
    {
        Tags
        {
            // ...
        }

        // #### required for Mask ####
        Stencil
        {
            Ref [_Stencil]
            Comp [_StencilComp]
            Pass [_StencilOp]
            ReadMask [_StencilReadMask]
            WriteMask [_StencilWriteMask]
        }
        ColorMask [_ColorMask]
        // ...

        Pass
        {
            // ...
            // #### required for RectMask2D ####
            #include "UnityUI.cginc"
            #pragma multi_compile __ UNITY_UI_CLIP_RECT
            float4 _ClipRect;

            // #### required for Mask ####
            #pragma multi_compile __ UNITY_UI_ALPHACLIP

            struct appdata_t
            {
                // ...
            };

            struct v2f
            {
                // ...
                // #### required for RectMask2D ####
                float4 worldPosition    : TEXCOORD1;
            };
            
            v2f vert(appdata_t v)
            {
                v2f OUT;
                // ...
                // #### required for RectMask2D ####
                OUT.worldPosition = v.vertex;
                return OUT;
            }

            fixed4 frag(v2f IN) : SV_Target
            {
                // ...
                // #### required for RectMask2D ####
                #ifdef UNITY_UI_CLIP_RECT
                    color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
                #endif

                // #### required for Mask ####
                #ifdef UNITY_UI_ALPHACLIP
                    clip (color.a - 0.001);
                #endif

                return color;
            }
            ENDCG
        }
    }
}

🤝 Contributing

Issues

Issues are incredibly valuable to this project:

Ideas provide a valuable source of contributions that others can make.
Problems help identify areas where this project needs improvement.
Questions indicate where contributors can enhance the user experience.

Pull Requests

Pull requests offer a fantastic way to contribute your ideas to this repository.
Please refer to CONTRIBUTING.md and develop branch for guidelines.

Support

This is an open-source project developed during my spare time.
If you appreciate it, consider supporting me.
Your support allows me to dedicate more time to development. 😊

License

Author

mob-sakai

icsharpcode/ILSpy

.NET Decompiler with support for PDB generation, ReadyToRun, Metadata (&more) - cross-platform!

ILSpy

ILSpy is the open-source .NET assembly browser and decompiler.

Download: latest release | latest CI build (master) | Microsoft Store (RTM versions only)

Decompiler Frontends

Aside from the WPF UI ILSpy (downloadable via Releases, see also plugins), the following other frontends are available:

Visual Studio 2022/2026 ship with decompilation support for F12 enabled by default (using our engines v8.2 and v9.1 respectively).
Our Visual Studio 2022 extension marketplace (works with VS 2026 as well)
Our Visual Studio Code Extension repository | marketplace | open-vsx
Our dotnet tool for Linux/Mac/Windows - check out ILSpyCmd in this repository | dotnet tool install
C# for Visual Studio Code ships with decompilation support as well. To enable, activate the setting "Enable Decompilation Support".
In Visual Studio 2019, you have to manually enable F12 support. Go to Tools / Options / Text Editor / C# / Advanced and check "Enable navigation to decompiled source"
Our Visual Studio 2017/2019 extension marketplace
Our ICSharpCode.Decompiler NuGet for your own projects
Our Linux/Mac/Windows PowerShell cmdlets in this repository

Features

Decompilation to C# (check out the language support status)
Whole-project decompilation
Search for types/methods/properties (learn about the options)
Hyperlink-based type/method/property navigation
Base/Derived types navigation, history
Assembly metadata explorer (feature walkthrough)
BAML to XAML decompiler
ReadyToRun binary support for .NET Core (see the tutorial)
Extensible via plugins
Additional features in DEBUG builds (for the devs)

License

ILSpy is distributed under the MIT License. Please see the About doc for details, as well as third party notices for included open-source libraries.

How to build

Windows:

Make sure Windows PowerShell (at least version) 5.0 or PowerShell 7+ is installed.
Clone the ILSpy repository using git.
Execute git submodule update --init --recursive to download the ILSpy-Tests submodule (used by some test cases).
Install Visual Studio (documented version: 18.0/2026). You need the following workload components:
- Workload ".NET Desktop Development". This workload includes the .NET Framework 4.8 SDK and the .NET Framework 4.7.2 targeting pack, as well as the .NET 10.0 SDK (ILSpy.csproj targets .NET 10.0, but we have net472 projects too).
- Workload "Visual Studio extension development" (Note: ILSpy.VSExtensions.sln is separate from ILSpy.sln and thus this workload is optional)
- Individual Component "MSVC v143 - VS 2022 C++ x64/x86 build tools" (or similar)
  - The VC++ toolset is optional; if present it is used for editbin.exe to modify the stack size used by ILSpy.exe from 1MB to 16MB, because the decompiler makes heavy use of recursion, where small stack sizes lead to problems in very complex methods.
Open ILSpy.sln in Visual Studio.
- NuGet package restore will automatically download further dependencies
- Run project "ILSpy" for the ILSpy UI
- Use the Visual Studio "Test Explorer" to see/run the tests
- If you are only interested in a specific subset of ILSpy, you can also use
  - ILSpy.Wpf.slnf: for the ILSpy WPF frontend
  - ILSpy.XPlat.slnf: for the cross-platform CLI or PowerShell cmdlets
  - ILSpy.AddIn.slnf: for the Visual Studio plugin

Note: Visual Studio includes a version of the .NET SDK that is managed by the Visual Studio installer - once you update, it may get upgraded too. Please note that ILSpy is only compatible with the .NET 10.0 SDK and Visual Studio will refuse to load some projects in the solution (and unit tests will fail). If this problem occurs, please manually install the .NET 10.0 SDK from here.

Unix / Mac:

Make sure .NET 10.0 SDK is installed.
Make sure PowerShell is installed (formerly known as PowerShell Core)
Clone the repository using git.
Execute git submodule update --init --recursive to download the ILSpy-Tests submodule (used by some test cases).
Use dotnet build ILSpy.XPlat.slnf to build the non-Windows flavors of ILSpy (.NET Core Global Tool and PowerShell Core).

How to contribute

Report bugs
If you want to contribute a pull request, please add https://github.com/icsharpcode/ILSpy/blob/master/BuildTools/pre-commit to your .git/hooks to prevent checking in code with wrong formatting. We use tabs and not spaces. The build server runs the same script, so any pull requests using wrong formatting will fail.

Current and past contributors.

Privacy Policy for ILSpy

ILSpy does not collect any personally identifiable information, nor does it send user files to 3rd party services. ILSpy does not use any APM (Application Performance Management) service to collect telemetry or metrics.

dotnet/dotnet

Home of .NET's Virtual Monolithic Repository which includes all the code needed to build the .NET SDK.

dotnet/dotnet - Home of the .NET VMR

This repository is a Virtual Monolithic Repository (VMR) which includes all the source code and infrastructure needed to build the .NET SDK.

What this means:

Monolithic - a join of multiple repositories that make up the whole product, such as dotnet/runtime or dotnet/sdk.
Virtual - a mirror (not replacement) of product repos where sources from those repositories are synchronized with.

In the VMR, you can find:

source files of each product repository which are mirrored inside of their respective directories under src/,
tooling that enables building the whole .NET product from source on Linux platforms,
[in future] E2E tests for the whole .NET product.

Just like the development repositories, the VMR will have a release branch for every feature band (e.g. release/10.0.1xx). Similarly, VMR's main branch will follow default branches of product repositories (see Synchronization Based on Declared Dependencies).

More in-depth documentation about the VMR can be found in VMR Design And Operation. See also dotnet/source-build for more information about our whole-product source-build.

Installing the SDK

You can download the .NET SDK either as an installer (MSI, PKG) or as an archive (zip, tar.gz). The .NET SDK contains both the .NET runtimes and CLI tools.

Latest builds table

Goals

The main purpose of the dotnet/dotnet repository is to have all source code necessary to build the .NET product available in one repository and identified by a single commit.
The VMR also aims to become the place from which we release and service future versions of .NET to reduce the complexity of the product construction process. This should allow our partners and 3rd parties to easily build, test and modify .NET using their custom infrastructure as well as make the process available to the community.
Lastly, we hope to solve other problems that the current multi-repo setup brings:
- Enable the standard down-/up-stream open-source model.
- Fulfill requirements of .NET distro builders such as RedHat or Canonical to natively include .NET in their distribution repositories.
- Simplify scenarios such as client-run testing of bug fixes and improvements. The build should work in an offline environment too for certain platforms.
- Enable developers to make and test changes spanning multiple repositories.
- More efficient pipeline for security fixes during the CVE pre-disclosure process.

We will achieve these goals while keeping active coding work in the separate repos where it happens today. For example: ASP.NET features will continue to be developed in dotnet/aspnetcore and CLR features will be continue to be developed in dotnet/runtime. Each of these repos have their own distinct communities and processes, and aggregating development into a true mono-repo would work against that. Hence, the "virtual" monolithic repo: the VMR gives us the simplicity of a mono-repo for building and servicing the product, while active development of components of that product stays in its various existing repos. The day to day experience for typical contributors will not change.

Supported platforms

8.0 and 9.0
- source-build configuration on Linux
10.0+ (WIP)
- source-build configuration on Linux
- non-source-build configuration on Linux, Mac, and Windows

For the latest information about Source-Build support for new .NET versions, please check our GitHub Discussions page for announcements.

Code flow

The contents of the VMR are two-way synchronized with the product repositories via code flow PRs. Individual repositories flow source changes into the VMR upon promotion of their local official builds (forward flow). The VMR changes are checked in, an official build happens, and then source changes + packages flow backward into the constituent repositories (back flow). For more details on code flow and code flow pull requests, please see this information on Code Flow PRs.

Contribution

Contribution to the .NET product should currently be done mostly in the constituent repositories. The reasons for this are two-fold:

We want to slowly ramp up direct VMR changes to avoid surprises.
The individual repositories still have the best validation for most changes.

If you would like to make a cross-cutting change in the VMR, please ask the Unified Build team (please tag @dotnet/product-construction in an issue/discussion in your repository). However, some changes should be made directly in the VMR. For a breakdown of where changes should be made, please see below.

Where to make changes:

src/* - Constituent repositories, except VMR pipeline changes.
Non src/* directories - Directly in VMR
Arcade eng/common changes - There are many copies of eng/common in the VMR:
- The VMR uses its root eng/common/* to bootstrap the VMR build. These should not be updated manually. They should only be updated via a re-bootrap of the VMR.
- A VMR build uses src/arcade/eng/common/* for arcade and any repository that builds after arcade. Changes may be made to these files, and they will flow back into arcade as well as to any repository that gets its arcade flow from the VMR. However, due to varying scenarios in which eng/common/ can be used, it is generally recommended that the VMR only be used to test eng/common changes, while actual changes should still be made in the dotnet/arcade repository.
VMR pipeline changes - The root pipeline logic lives in eng/* and should be changed in the VMR.

For any questions, please ask the Unified Build team.

Dev instructions

Please note that this repository is a work-in-progress and there are some usability issues connected to this. These can be nuisances such as some checked-in files getting modified by the build itself and similar. For the latest information about Source-Build support, please watch for announcements posted on our GitHub Discussions page.

Prerequisites

The dependencies for building can be found here. In case you don't want to / cannot prepare your environment per the requirements, consider using Docker.

For building the VMR with Source-Build, the following additional dependencies are required for your Linux environment:

brotli-dev

For building the VMR on Windows, it is recommended to put the repo under a short path, i.e. C:\dotnet. Also, long path support must be enabled. This is necessary as some of the tools used don't support long paths (WiX Toolset v3 and cl.exe).

For some git commands and when synchronizing changes via the darc CLI, long path support should be enabled in the git config as well:

git config --system core.longpaths true # needs elevated prompt
git config --global core.longpaths true

Building

Clone the repository

git clone https://github.com/dotnet/dotnet dotnet-dotnet
cd dotnet-dotnet

Build the .NET SDK

Choose one of the following build modes:
- Microsoft based build
  
  For Unix:
```
./build.sh --clean-while-building
```
  For Windows:
```
.\build.cmd -cleanWhileBuilding
```
- Building from source
```
# Prep the source to build on your distro.
# This downloads a .NET SDK and a number of .NET packages needed to build .NET from source.
./prep-source-build.sh

# Build the .NET SDK
./build.sh -sb --clean-while-building
```
The resulting SDK is placed at artifacts/assets/Release/dotnet-sdk-9.0.100-[your-RID].tar.gz (for Unix) or artifacts/assets/Release/dotnet-sdk-9.0.100-[your-RID].zip (for Windows).

(Optional) Unpack and install the .NET SDK

For Unix:

mkdir -p $HOME/dotnet
tar zxf artifacts/assets/Release/dotnet-sdk-10.0.100-[your-RID].tar.gz -C $HOME/dotnet
ln -s $HOME/dotnet/dotnet /usr/bin/dotnet

For Windows:

mkdir %userprofile%\dotnet
tar -xf artifacts/assets/Release/dotnet-sdk-10.0.100-[your RID].zip -C %userprofile%\dotnet
set "PATH=%userprofile%\dotnet;%PATH%"

To test your built SDK, run the following:

dotnet --info

Note

Run ./build.sh --help (for Unix) or .\build.cmd -help (for Windows) to see more information about supported build options.

Building using Docker

You can also build the repository using a Docker image which has the required prerequisites inside. The example below creates a Docker volume named vmr and clones and builds the VMR there.

docker run --rm -it -v vmr:/vmr -w /vmr mcr.microsoft.com/dotnet-buildtools/prereqs:centos-stream-10-amd64
git clone https://github.com/dotnet/dotnet .

# - Microsoft based build
./build.sh --clean-while-building

# - Building from source
./prep-source-build.sh && ./build.sh -sb --clean-while-building

mkdir -p $HOME/.dotnet
tar -zxf artifacts/assets/Release/dotnet-sdk-9.0.100-centos.9-x64.tar.gz -C $HOME/.dotnet
ln -s $HOME/.dotnet/dotnet /usr/bin/dotnet

Codespaces

You can also utilize GitHub Codespaces where you can find preset containers in this repository.

Building from released sources

You can also build from sources (and not from a context of a git repository), such as the ones you can acquire from a dotnet/dotnet release. In this case, you need to provide additional information which includes the original repository and commit hash the code was built from so that the SDK can provide a better debugging experience (think the Step into.. functionality). Usually, this means the dotnet/dotnet repository together with the commit the release tag is connected to.

In practice, this means that when calling the main build script, you need to provide additional arguments when building outside of a context of a git repository.
Alternatively, you can also provide a manifest file where this information can be read from. This file (release.json) can be found attached with the dotnet/dotnet release.

Manually synchronizing code with the VMR

Sometimes you want to make a change in a repository and test that change in the VMR locally (or vice versa). You could of course make the change in the VMR directly, but in case it's already available in your repository, you can synchronize it locally into your clone of the VMR, commit, and then open a PR.

To do this, you need to use the darc vmr forwardflow or darc vmr backflow commands which can move your changes from your repository's dev branch into a local VMR one. Please refer to command's documentation (--help) for more details.

Filing Issues

This repo should contain issues that are tied to the VMR infrastructure and documentation.

For other issues, please open them in the appropriate product repos. We have links to many of them on our new issue page.

Useful Links

Design documentation for the VMR - a set of documents describing the high-level design and the why's and how's
.NET Source-Build
What is .NET

.NET Foundation

.NET Runtime is a .NET Foundation project.

License

.NET is licensed under the MIT license.

aelassas/servy

Run Any App as a Native Windows Service - Modern Alternative to NSSM, WinSW & FireDaemon Pro

⭐ Don't forget to give us a star on GitHub. It costs nothing but means a lot and helps the project grow!

Servy

Servy lets you run any app as a native Windows service with full control over the working directory, startup type, process priority, logging, health checks, environment variables, dependencies, pre-launch and post-launch hooks, pre-stop and post-stop hooks, and parameters. It's designed to be a full-featured alternative to NSSM, WinSW, and FireDaemon Pro.

Servy is digitally signed using a trusted code-signing certificate provided by the SignPath Foundation. This ensures that all Servy executables and installers are verified and secure, giving you peace of mind when using the tool.

Servy offers a desktop app, a CLI, and a PowerShell module that let you create, configure, and manage Windows services interactively or through scripts and CI/CD pipelines. It also includes a Manager app for easily monitoring and managing all installed services in real time.

Servy continuously monitors your app, restarting it automatically if it crashes, hangs, or stops. It is perfect for keeping non-service apps running in the background and ensuring they start automatically at system boot, even before logon, without rewriting them as services. Use it to run Node.js, Python, .NET, Java, Go, Rust, PHP, or Ruby applications; keep web servers, background workers, sync tools, or daemons alive after reboots; and automate task runners, schedulers, or scripts in production with built-in health checks, logging, and restart policies.

Why?

See NOTES.md for details.

Getting Started

Download the latest release from GitHub or install via a package manager:

WinGet

winget install servy

Chocolatey

choco install -y servy

Scoop

scoop bucket add extras
scoop update innounp
scoop install servy

Quick Example

You can manage services using the desktop app (GUI), the CLI, or PowerShell.

Here's a minimal example using the CLI to turn a Node.js app into a Windows service:

servy-cli install `
--name="MyService" `
--path="C:\Program Files\nodejs\node.exe" `
--startupDir="C:\MyServer" `
--params="C:\MyServer\server.js"

This creates a service named MyService that runs your Node.js server in the background and starts automatically with Windows.

Then start the service:

servy-cli start --name="MyService"

Explore more examples and recipes for Python, Java, Go, and other popular frameworks.

Quick Links

Features

Clean, simple UI
Monitor and manage all installed services with Servy Manager
Real-time CPU and RAM monitoring with live performance graphs for installed services
Real-time service stdout and stderr output preview in Servy Console
Service dependency tree visualization with status indicators
CLI and PowerShell module for full scripting and automated deployments
Run any executable as a Windows service
Set service name, description, startup type, priority, working directory, environment variables, and dependencies
Environment variable expansion supported in parameters, process paths and startup directories
Run services as Local System, local or domain accounts, Active Directory accounts, or gMSAs
Redirect stdout/stderr to log files with automatic size-based and date-based rotations
Run pre-launch hook before starting the service, with retries, timeout, logging and failure handling
Run post-launch hook after the application starts successfully
Run pre-stop and post-stop hooks before the application stops and after the application stops
Supports Ctrl+C for command-line apps, close-window for GUI apps, and force kill if unresponsive
Supports Ctrl+C propagation to descendant processes of the wrapped process
Prevent orphaned/zombie processes with improved lifecycle management and ensuring resource cleanup
Health checks and automatic service recovery
Browse and search logs by level, date, and keyword for faster troubleshooting from Servy Manager
Export/Import service configurations for easy backups and automation
Service Event Notification alerts on service failures via Windows notifications and email
Compatible with Windows 7-11 x64 and Windows Server editions

Changelog

See CHANGELOG.md.

Roadmap

See ROADMAP.md.

Support & Contributing

Servy is free and open-source. If you are using it in a commercial or revenue-generating context, or simply find it valuable, consider supporting the project via GitHub Sponsors, PayPal, or Buy Me a Coffee.

Open-source software requires time, effort, and resources to maintain. Every contribution, big or small, makes a difference and motivates continued work on features, bug fixes, and new ideas.

If you have suggestions, issues, or would like to contribute, feel free to open an issue or submit a pull request.

Stats for Nerds

License

Servy is MIT licensed.

Acknowledgments

Thanks to SignPath for providing a free code signing service, and to the SignPath Foundation for supplying a free code signing certificate.

Thanks to JetBrains for providing an open-source license for their tools. Their software made it much easier to profile, debug, and optimize Servy, helping improve its performance and stability. Having access to these professional tools really made a difference during development and saved a lot of time.

Special thanks to everyone who tested Servy, reported issues, and suggested improvements on GitHub and Reddit. Your feedback and contributions have shaped the project and made it better with every release.

memstechtips/Winhance

Application designed to optimize, customize and enhance your Windows experience.

Winhance - Windows Enhancement Utility 🚀

Winhance is a C# application designed to debloat, optimize and customize your Windows experience. From software management to system optimizations and customization, Winhance provides everything you need to enhance Windows 10 and 11 systems.

Winhance features most of the same enhancements as UnattendedWinstall without needing to do a clean install of Windows.

Note

Winhance is an independent, open-source project and is not affiliated with, endorsed by, or associated with Microsoft in any way. "Windows" is a registered trademark of Microsoft Corporation. Any similarities to Windows Settings or other Microsoft interfaces are a natural result of building a Windows enhancement tool using native Windows UI frameworks.

Requirements 💻

Windows 10/11
- Tested on Windows 10 x64 22H2 and Windows 11 23H2, 24H2 and 25H2

Installation 📥

Quick Install via PowerShell

Paste this command into PowerShell to download and run the installer:

irm "https://get.winhance.net" | iex

Download the Installer

The Winhance.Installer.exe includes both Installable and Portable versions during setup.

Note

This tool is currently in development. Any issues can be reported using the Issues tab.
Also, I'm not a developer, I'm just enjoying learning more about scripting/programming and learning as I go.

Please also understand that I prefer to develop and work on these projects independently.
I do value other people's insights and appreciate any feedback, but don't take it personally if a pull request is not accepted.

Support the developer

It really does make a big difference, and is very much appreciated. Thanks

Current Features 🛠️

Software & Apps 💿

Windows Apps & Features Section
- Searchable interface with explanatory legend
- Organized sections for Windows Apps, Legacy Capabilities, and Optional Features
- One-click removal and installation of selected items
- Control scripts and scheduled tasks via Windows Apps Help menu
External Apps Section
- Install various useful applications via WinGet
  - (WinGet COM API integration based on https://github.com/marticliment/WinGet-API-from-CSharp)
- Categories include Browsers, Multimedia utilities, Document viewers, and more

Optimize 🚀

Searchable interface with quick nav control
Toggle switches and selection controls for each setting
Set UAC Notification Level
Privacy Settings
Gaming and Performance Optimizations
Windows Updates
Power Settings with Power Plan selection
Sound Settings
Notification Preferences

Customize 🎨

Searchable interface with quick nav control
Toggle switches and selection controls for each setting
Windows Theme selector (Dark/Light Mode)
Taskbar Customization
Start Menu Customization
Explorer Customizations

Advanced Tools 🛠️

Create Custom Windows ISO's with WIMUtil (Windows Installation Media Utility) including adding drivers from current OS
Create autounattend.xml files based on your Winhance selections

Other Settings

Manage Your Winhance (and Windows) Settings with Wihance Configuration Files:
- Save settings currently applied in Winhance to a config file for easy importing on a new system or after a fresh Windows install.
Toggle Winhance's theme (Light/Dark Mode)

License

Except where otherwise stated (see THIRD-PARTY-NOTICES.txt), the content of this repository is provided under the PolyForm Shield 1.0.0 license by Marco du Plessis.

In plain language: Winhance is free to use for everyone -- individuals, businesses, and IT professionals. You can use it to service and consult for clients. You just can't fork or rebrand it and redistribute it as a competing product. See the full LICENSE.txt for details.

Feedback and Community

If you have feedback, suggestions, or need help with Winhance, please join the discussion on GitHub or our Discord community:

builtbybel/Winslopr

Windows Slop Remover

Note: "winslop" might refer to Windows 11 in some corners of the internet.
Winslopr is the tool designed to clean it up.

Winslopr

Windows slop remover

"We need to get beyond the arguments of slop vs sophistication…"
— Satya Nadella

"Slop" = stuff that ships by default, wastes resources, and takes control away, while doing basically nothing for you.

This started as a joke.
Then Microsoft said "slop vs sophistication" out loud and it stopped being one.

📋 What annoys you most about Windows 11?

59 community-sourced annoyances. Filterable. With fixes.
See what Winslopr handles and what needs extra tools.

winslopr

Windows
└── slop
    ├── telemetry
    ├── assistants
    ├── ads
    ├── suggestions
    └── background junk
         ↓
      removed by winslopr
         ↓
       thanks
        Satya

remove the slop. Nothing fancy. Just tools.

FAQ

_{Click to expand. No assistant required.}

Is Winslopr anti-Windows?

No.
Windows itself is fine.
The unnecessary stuff layered on top of it isn’t.

Winslopr targets slop, not Windows.

Is there a help file / quick start guide?

Yes.
There's a small, lightweight entry guide to get you going:

Quick Start / Help: https://github.com/builtbybel/Winslop/blob/main/docs/Help.md

Is this an anti-AI project?

Also no.

Winslopr doesn’t care whether something is AI, scripted, cloud-based or hand-written.
If it’s forced, opaque, or unnecessary, its slop.

If it’s optional, transparent and useful, it’s fine.

Does Winslopr use AI?

No.

There is no model, no prompt, no inference step.
Everything is deterministic and based on explicit user choices.

Is anything uploaded to the cloud?

No.

Winslopr does not upload logs, telemetry, system data or usage statistics.
All actions happen locally on your machine.

Can Winslopr break my system?

Any system tool can if misused.

That’s why Winslopr:

shows exactly what it will change
never runs anything automatically
allows changes to be reviewed and reverted

You stay in control.

Why not just use Copilot / Settings / PowerShell?

You can.

Winslopr exists for people who prefer:

fewer layers
less abstraction
no opinions
no assistants

Just tools.

Is this related to CrapFixer?

Yes.

Winslopr is a very small, focused fork of CrapFixer.
The goal was to remove complexity, reduce scope and make things easier to maintain.

Smaller codebase.
Clearer intent.
Less slop.

Why the name?

Because Microsoft said “slop vs sophistication” out loud.

And because Windows isn't bad.
The slop is.

Winslopr is anti-slop by design.

That’s why the UI is intentionally small, plain and functional. No glossy visuals.
No animations.
No AI-generated fluff.

Slop comes in many forms:

AI slop > mass-produced, soulless output
Feature slop > unnecessary features that make UX worse
UX / Design slop > bloated, unclear interfaces
Corporate slop > buzzwords, filler and dark patterns

Winslopr does the opposite: It removes more than it adds.

Confession: I like Windows, but...

I just hate what Windows 11 keeps trying to become.
So I built the “stop doing that” button again.
Consider this stress relief with a UI.

Is "Slopr" even a real word?

Not really.
Its a constructed name

Winslopr is a made-up tool name, somewhere between cleaner, remover, and something that just sounds like it belongs in a Windows utility folder.

"Sloper" isnt a real word in this context.
But Winslopr still reads like one: the thing that removes the slop

So no, the word didn’t exist. Now it does

What is Winslopr written in?

C# with WinUI 3. Started as a fork of CrapFixer, rebuilt from scratch to be smaller and more focused.

nopSolutions/nopCommerce

ASP.NET Core eCommerce software. nopCommerce is a free and open-source shopping cart.

nopCommerce: free and open-source eCommerce solution

nopCommerce is the best open-source eCommerce platform. nopCommerce is free, and it is the most popular ASP.NET Core shopping cart.

Key features

The product is being developed and supported by the professional team since 2008.
nopCommerce has been downloaded more than 3,000,000 times.
The active developer community has more than 250,000 members.
nopCommerce runs on .NET 9 with an MS SQL 2012 (or higher) backend database.
nopCommerce is cross-platform, and you can run it on Windows, Linux, or Mac.
nopCommerce supports Docker out of the box, so you can easily run nopCommerce on a Linux machine.
nopCommerce supports PostgreSQL and MySQL databases.
nopCommerce fully supports web farms. You can read more about it here.
All methods in nopCommerce are async.
nopCommerce supports multi-factor authentication out of the box.
Start our online course for developers and get the practical and technical skills you need to run and customize nopCommerce websites.

nopCommerce architecture follows well-known software patterns and the best security practices. The source code is fully customizable. Pluggable and clear architecture makes it easy to develop custom functionality and follow any business requirements.

Using the latest Microsoft technologies, nopCommerce provides high performance, stability, and security. nopCommerce is also fully compatible with Azure and web farms.

Our clear and detailed documentation and online course for developers will help you start with nopCommerce easily.

The advantages of working with nopCommerce

nopCommerce offers powerful out-of-the-box features for creating an online store of any size and type.

nopCommerce is integrated with all the popular third-party services. You can find thousands of integrations on nopCommerce Marketplace.

The Web API plugin by the nopCommerce team lets you build integrations with third-party services or mobile applications using REST. The Web API plugin is available with source code and covers all methods of nopCommerce: backend and frontend. You can read more about it here.

Friendly members of the nopCommerce community will always help with advice and share their experiences. nopCommerce core development team provides professional support within 24 hours.

Store demo

Evaluate the functionality and convenience of nopCommerce as a customer and store owner.

Front End	Admin area

nopCommerce resources

nopCommerce official site: https://www.nopcommerce.com

nopCommerce YouTube: The Architecture behind the nopCommerce eCommerce Platform

Earn with nopCommerce

60,000 stores worldwide are powered by nopCommerce, and 10,000 new stores open every year. nopCommerce solution partners’ directory gets 80,000+ page views per year from store owners who are looking for a partner to build a store from scratch, migrate from another platform, or improve and customize an existing store.

Become a solution partner of nopCommerce and get new clients – learn more.

Create a new graphical theme or develop a new plugin or integration and sell it on the nopCommerce Marketplace.

Contribute

As a free and open-source project, we are very grateful to everyone who helps us to develop nopCommerce. Please find more details about the options and bonuses for contributors at contribute page.

Jackett/Jackett

API Support for your favorite torrent trackers

Jackett

Introduction

Jackett works as a proxy server that translates queries from applications (Sonarr, Radarr, SickRage, CouchPotato, Mylar3, Lidarr, DuckieTV, qBittorrent, Nefarious, NZBHydra2, etc.) into tracker-site-specific HTTP queries, parses the HTML or JSON response, and sends results back to the requesting software.

What Jackett does:

Acts as a bridge between your apps and torrent trackers
Provides recent uploads (similar to RSS feeds)
Performs searches across multiple trackers
Returns results in a standardized format (Torznab/TorrentPotato)

Key Features:

Single repository of maintained indexer scraping and translation logic
Removes the burden of tracker integration from other applications
Supports public, semi-private and private trackers
Implements the Torznab and TorrentPotato APIs

Developer Information

This project is recruiting development help. If you can help out please contact us.

For detailed troubleshooting and contributing guidelines, please see CONTRIBUTING.md

A third-party Golang SDK for Jackett is available from webtor-io/go-jackett

Note: The Discord server is no longer maintained. If you have a problem, request, or question, please open a new issue on GitHub.

Supported Systems

The currently supported version of Jackett is 0.24.+, which is compatible with:

Windows: Windows 10 Version 1607 or greater (full list)
Linux: Various distributions (full list)
macOS: macOS 13.0+ (Ventura) or greater (full list)

Prior versions of Jackett are no longer supported.

Supported Trackers

Supported Public Trackers

ØMagnet
1337x
52BT
ACG.RIP
AniLibria
Anime Tosho
AniRena
AniSource
ApacheTorrent
arab-torrents.com
AudioBook Bay (ABB)
Bangumi Moe
BigFANGroup
BitRu
BlueRoms
BT.etree
BTdirectory (BT目录)
btstate
Byrutor
Catorrent
CrackingPatching
DaMagNet
Demonoid Clone
DivxTotal
dmhy
DonTorrent
E-Hentai
EBook Bay (EBB)
Elitetorrent.wf
EpubLibre
ExtraTorrent.st
EZTV
FileMood
FilmesHdTorrent
Free JAV Torrent
GamesTorrents
HDRTorrent
ilCorSaRoNeRo
Internet Archive (archive.org)
kickasstorrents.to
kickasstorrents.ws
Knaben
LimeTorrents
LinuxTracker
Mac Torrents Download
Magnet Cat
MagnetDownload
Magnetz
MegaPeer
MejorTorrent
Mikan
MixTapeTorrent
MoviesDVDR
MyPornClub
nekoBT
NewStudio
Nipponsei
NoNaMe Club (NNM-Club)
NorTorrent
Nyaa.si
OneJAV
OpenSharing
PC-torrent
PandaCD
plugintorrent
PornoTorrent
PornRips
Postman
RedeTorrent
RinTorNeT
RuTor
RuTracker.RU
Sexy-Pics
Shana Project
ShowRSS
SkidrowRepack
sosulki
SubsPlease
sukebei.Nyaa.si
The Pirate Bay (TPB)
TheRARBG
Tokyo Tosho
Torrent Downloads
Torrent Oyun indir
Torrent[CORE]
torrent.by
torrent-pirat
Torrent9
TorrentDownload
TorrentGalaxyClone
TorrentKitty
TorrentProject2
TorrentQQ (토렌트큐큐)
Torrents.csv
Torrentsome (토렌트썸)
Torrenttip (토렌트팁)
U2P
U3C3
Uindex
UzTracker
VSTHouse
VST Torrentz
VSTorrent
Wolfmax4K
World-torrent
XXXClub
xxxtor
YTS.ag
Zamunda RIP
ZkTorrent

Supported Semi-Private Trackers

AniDUB
Anime by Belka (Аниме от Белки)
AnimeLayer
Best-Torrents [PAY2DL]
BitMagnet (Local DHT) [site]
BookTracker
BootyTape
comicat
DarkiWorld
Deildu
Devil-Torrents
DreamingTree
DXP (Deaf Experts)
Electro-Torrent
Erai-Raws
Ex-torrenty
ExKinoRay
EZTV (login)
Fenyarnyek-Tracker
File-Tracker
Gay-Torrents.net
HD-CzTorrent [PAY2DL]
HDGalaKtik
HellTorrents [PAY2DL]
HunTorrent
Il CorSaRo Blu
ilDraGoNeRo
Kinorun
Kinozal
LostFilm.tv
Magnetico (Local DHT) [site]
Marine Tracker
Mazepa
Metal Tracker
MioBT
MuseBootlegs (MB)
MVGroup Forum
MVGroup Main
NetHD (VietTorrent)
New-Team
NewStudio (login)
NoNaMe Club (NNM-Club) (login)
Polskie-Torrenty
PornoLab
Postman (login)
ProPorno
PussyTorrents
Rainbow Tracker
RGFootball
RinTor
RiperAM
RockBox
RUDUB (ex-BaibaKoTV)
Rustorka
RuTracker.org
seleZen
Sk-CzTorrent
SkTorrent-org
themixingbowl (TMB)
Toloka
TorrentMasters
TrahT
TribalMixes
Union Fansub
UniOtaku
Ztracker

Supported Private Trackers

0day.kiev
13City
1ptbar
3ChangTrai (3CT)
3D Torrents (3DT)
4thD (4th Dimension)
52PT
720pier
Abnormal (ABN)
ABtorrents (ABT + RNS)
AcrossTheTasman
Aftershock
AFUN
AGSVPT (Arctic Global Seed Vault)
Aidoru!Online
Aither
alingPT
AlphaRatio (AR)
AmigosShareClub (ASC)
AnimeBytes (AB)
AnimeTorrents (AnT)
AnimeTorrents.ro (Anime Torrents Romania)
AnimeWorld (AW)
Anthelion (ANT)
Araba Fenice (Phoenix)
ArabicSource
ArabP2P
ArabScene
ArabTorrents
AsianCinema
AsianDVDClub (ADC)
Audiences
AudioNews (AN)
AURA4K
Aussierul.es
AvistaZ (AsiaTorrents)
Azusa (梓喵)
Back-ups
BakaBT
baoziPT
Beload
Best-Core
BeyondHD (BHD)
Bibliotik
BigBBS
BigCore
Bit-Bázis
BIT-HDTV
Bitded
bitGAMER
BitHUmen
Bitpalace
BitPorn
BitTorrentFiles
BiTTuRK
BJ-Share (BJ)
BlueBird
BlueTorrents
BlurayTracker
Blutopia (BLU)
Borgzelle
Boxing Torrents
Brasil Tracker
BroadcasTheNet (BTN)
BrokenStones
BTArg
BTNext (BTNT)
BTSCHOOL
BWTorrents
BYRBT
C411
cangbaoge (CBG)
CapybaraBR
Carp-Hunter
Carpathians
CarPT
Cathode-Ray.Tube (CRT)
CeskeForum
CGPeers
CHDBits
ChileBT
Cinemageddon
CinemaMovieS_ZT
Cinematik
CinemaZ (EuTorrents)
ClearJAV
Coastal-Music-Crew (C-M-C)
ConCen (Conspiracy Central)
Concertos
CrabPT (蟹黄堡)
CrazySpirits
CrnaBerza
cspt (财神)
cyanbug (大青虫)
Darkpeers
Das Unerwartete (D-U)
DataScene (DS)
DesiGaane (DG)
DesiTorrents
Diablo Torrent
DICMusic
DigitalCore (DC)
DimeADozen (EzTorrent)
DiscFan
DocsPedia
Drugari
DS-Reloaded
dubhe (天枢)
Ebooks-Shares
Empornium (EMP)
eMuwarez
eStone (BigTorrent)
Exitorrent.org
ExoticaZ (YourExotic)
Explosiv-World (E-W)
ExtremeBits
F1Carreras
F1GP
FANO.IN
Fappaizuri
FearNoPeer
Femdomcult
FileList (FL)
FinElite (FE)
Flood (FLD)
Free Farm (自由农场)
FunFile (FF)
FunkyTorrents (FT)
funZone
FutureTorrent [PAY2DL]
Fuzer (FZ)
G3MINI TR4CK3R
Gay-Torrents.org
GAYtorrent.ru
GazelleGames (GGn)
Generation-Free
GGPT
GigaTorrents
GimmePeers (formerly ILT) [PAY2DL]
GiroTorrent
GreatPosterWall (GPW)
HaiDan
Hǎitáng (海棠PT)
HappyFappy (HF)
Hawke-uno (HUNO)
HD Dolby
HD Zero
HD-Club
HD-Forever (HDF)
HD-Olimpo
HD-Only (HDO)
HD-Space (HDS)
HD-Torrents (HDT)
HD-UNiT3D
HDArea (HDA)
HDBao
HDBits
HDCiTY (HDC)
HDClone
HDFans
HDHome
HDKylin (麒麟)
HDRoute
HDSky
HDtime
HDTorrents.it [PAY2DL]
HDTurk
HDU
HDVideo
Hebits (HB)
HellasHut
HELLENIC-HD
HHanClub
HHD
House of Devil
HQMusic
HUDBT (蝴蝶)
HxPT (好学)
ImmortalSeed (iS)
Immortuos
Indietorrents
INFINITY [PAY2DL]
InfinityHD
Infire
Insane Tracker
IPTorrents (IPT)
ItaTorrents
JME-REUNIT3D
JoyHD (JHD)
JPopsuki
JPTV4us
KamePT
Karagarga
Keep Friends (FRDS-PT)
Kelu
Korsar
KrazyZone
Kufei (库非)
Kufirc
Kunlun (昆仑)
lajidui
Last Digital Underground (LDU)
LastFiles (LF)
Lat-Team
Le Saloon
LearnFlakes
Leech24
LemonHD.net
LetSeed
Libble
LibraNet (LN)
LinkoManija
Locadora
LongPT
LosslessClub
LP-Bits 2.0
LST
LuckPT
Luminarr
M-Team - TP (MTTP)
MaDs Revolution
Majomparádé (TurkDepo)
Making Off
Malayabits
Mansão dos Animes (MDAN)
March
Matrix
MeseVilág (Fairytale World)
MetalGuru
Milkie (ME)
MMA-Torrents
MNV (Max-New-Vision)
MOJBLiNK
MomentPT
MonikaDesign (MDU)
MoreThanTV (MTV)
MouseBits
Muxuege
MyAnonamouse (MAM)
MySpleen
NanyangPT (南洋)
NCore
Nebulance (NBL) (TransmiTheNet)
NewHeaven (TorrentHeavenResurrection)
Nexum
NicePT
Nirvana
njtupt (浦园))
NOBS (NUCLEAR ORDER BIT SYNDICATE)
NorBits
NordicBytes
NORDiCHD
NordicQuality
Nostradamus
NovaHD
OKPT
Old Greek Tracker (OGT)
Old Toons World (OTW)
OpenCD
Orpheus
OnlyEncodes+
OshenPT
OurBits (HDPter)
P2PBG [PAY2DL]
Panda
Party-Tracker
PassThePopcorn (PTP)
Peeratiko
Peers.FM
Phoenix Project
PigNetwork (猪猪网)
PixelCove (Ultimate Gamer)
PiXELHD (PxHD)
PlayletPT
Podzemlje
Polish Torrent (PTT)
PolishTracker
Pornbay
Portugas
Pretome
PrivateHD (PHD)
ProAudioTorrents (PAT)
PT GTK
PT分享站 (itzmx)
PTCafe (咖啡)
PTCC (我的PT)
PTerClub (PT之友俱乐部)
PTFans
PTFiles (PTF)
PThome
PTLAO
PTLGS
PTSBAO (烧包)
PTSKIT
PTTey
PTtime
PTYING (樱花)
PTzone
Punk's Horror Tracker
PuntoTorrent
PuTao (葡萄)
PWTorrents (PWT)
Qingwa (青蛙)
R3V WTF!
Racing4Everyone (R4E)
RacingForMe (RFM)
RailgunPT
Rain (雨)
Rastastugan
Red Star Torrent (RST)
Redacted (PassTheHeadphones)
ReelFlix (HD4Free,LegacyHD)
RetroFlix
RetroMoviesClub (RMC)
RevolutionTT
RocketHD
Romanian Metal Torrents (RMT)
RoTorrent (ROT)
Rousi.pro
SAMARITANO
SBPT
SceneHD
SceneRush
SceneTime
Secret Cinema
SeedFile (SF)
seedpool
SewerPT (下水道)
SexTorrent
ShaKaw
Shareisland
Shazbat
SiamBIT [PAY2DL]
Siqi
SkipTheCommercials
Slobit Media
SnowPT (SSPT)
SoulVoice (聆音Club)
SpeedApp (SceneFZ, XtreMeZone / MYXZ, ICE Torrent)
SpeedCD
Speedmaster HD
Spirit of Revolution
SportsCult
SpringSunday (SSD)
SunnyPT
Superbits (SBS)
Swarmazon
Tangmen (唐门)
TangPT (躺平)
Tapochek
Tasmanit
Team CT Game (TCTG)
TeamFlix
TeamHD
TeamOS
TEKNO3D
The Brothers
The Crazy Ones
The Empire (TE)
The Falling Angels (TFA)
The Geeks
The Kitchen (TK)
The New Retro
The Occult (TO)
The Old School (TOS)
The Paradiese
The Place (TP)
The Show (TSBZ)
The Vault (TVBZ)
The-New-Fun
TheLeachZone (TLZ)
TJUPT (北洋园PT)
TLFBits
TmGHuB (TH)
Toca Share
TokyoPT
Tormac
Tornado
Torr9
Torrent Heaven (Dutch)
Torrent Network (TN)
Torrent Trader
Torrent-Syndikat
TOrrent-tuRK (TORK)
Torrent.LT
TorrentBD
TorrentBytes (TBy)
TorrentCCF (TCCF)
TorrentDay (TD)
TorrentDD (TodayBit)
Torrenteros (TTR)
TorrentHR
Torrenting (TT)
TorrentLeech (TL)
TorrentLeech.pl
ToTheGlory (TTG)
TrackerMK
TrackerZero [PAY2DL]
TranceTraffic
Trellas (Magico)
TreZzoR
TurkSeed (Aturk)
TurkTorrent (TT) [PAY2DL]
TV Chaos UK (TVCUK)
TVstore
U2 (U2分享園@動漫花園)
UBits
UltraHD
UnlimitZ
upload.cx (ULCX)
Upscale Vault
UTOPIA
Vault network
VietMediaF
White Angel
WinterSakura
World-In-HD
World-of-Tomorrow
Xingwan (星湾)
Xingyung (星陨阁)
xloli (ilolicon PT)
XSpeeds (XS)
xTorrenty
XtremeBytes (TorrentSurf)
XWT-Classics
XWTorrents (XWT)
YUSCENE
Zappateers
ZmPT (织梦)
ZRPT (自然)

Note: Trackers marked with have no active maintainer and may be broken or missing features. If you have an invite, please send it to jacketttest [at] gmail [dot] com or garfieldsixtynine [at] gmail [dot] com to help improve these indexers.

Installation

Windows Installation

Method 1: Using the Installer (Recommended)

Prerequisites:

Windows 10 Version 1607 or newer
Administrator privileges
.NET prerequisites (check here)

Installation Steps:

Download the latest version of the Windows installer
Run the Jackett.Installer.Windows.exe program
When prompted for permission to make changes to your computer, click "Yes"
During installation:
- Check "Install as Windows Service" if you want Jackett to start automatically with Windows
- Check "Launch Jackett" to open Jackett after installation completes
Click "Install" and wait for the installation to finish
Double-click the Jackett tray icon, or navigate your web browser to http://127.0.0.1:9117
You are now ready to begin adding trackers

Service Management:

When installed as a service, the tray icon acts as a way to open, start, or stop Jackett
If not installed as a service, Jackett will run its web server from the tray tool

Method 2: Manual Installation

Download the zipped version
Extract to your preferred location (e.g., C:\ProgramData\Jackett)
Run JackettConsole.exe to start Jackett
Navigate your web browser to http://127.0.0.1:9117

Running from Command Line: You can run Jackett from the command line to see log messages. Use JackettConsole.exe (for Command Prompt), found in the Jackett data folder: e.g. %ProgramData%\Jackett. Ensure the server is not already running from the tray or service.

Linux Installation (AMD x64)

This section covers installation on most common Linux distributions including Ubuntu, Linux Mint, Debian, Fedora, and others.

Prerequisites:

Most operating systems include all required dependencies
If dependencies are missing, refer to .NET Required Packages

Method 1: One-Command Installation (Easiest)

Copy and paste this command into your terminal:

cd /opt && wget -O - -o /dev/stderr https://github.com/Jackett/Jackett/releases/latest/download/Jackett.Binaries.LinuxAMDx64.tar.gz | sudo tar -xz && cd Jackett* && sudo chown $(whoami):$(id -g) -R "/opt/Jackett" && sudo ./install_service_systemd.sh && systemctl status jackett.service && cd - && echo -e "\nVisit http://127.0.0.1:9117"

Method 2: Step-by-Step Installation

Download and extract the latest release:

cd /opt
wget -O - -o /dev/stderr https://github.com/Jackett/Jackett/releases/latest/download/Jackett.Binaries.LinuxAMDx64.tar.gz | sudo tar -xz

Set proper ownership:

sudo chown -R $(whoami):$(id -g) /opt/Jackett

Install as a service:

cd /opt/Jackett
sudo ./install_service_systemd.sh

Check service status:
```
systemctl status jackett.service
```
Navigate your web browser to http://127.0.0.1:9117

Running Without Installing as a Service

Download and extract the latest Jackett.Binaries.LinuxAMDx64.tar.gz release from the releases page
Open a Terminal and cd to the Jackett folder
Run Jackett with the command ./jackett

Service Management Commands

# Start Jackett
systemctl start jackett.service

# Stop Jackett
systemctl stop jackett.service

# Restart Jackett
systemctl restart jackett.service

# Check status
systemctl status jackett.service

Logs Location: ~/.config/Jackett/log.txt View Logs: journalctl -u jackett.service

Home Directory Configuration

If you want to run Jackett with a user without a /home directory, add this line to your systemd file:

Environment=XDG_CONFIG_HOME=/path/to/folder

This folder will be used to store configuration files.

Linux Installation (ARMv7 or above)

For modern ARM-based systems (Raspberry Pi, etc.)

Prerequisites:

Most operating systems include all required dependencies
If dependencies are missing, refer to .NET Required Packages

Installing as a Service

Download the appropriate release:
- For 32-bit ARM (most common): Jackett.Binaries.LinuxARM32.tar.gz
- For 64-bit ARM: Jackett.Binaries.LinuxARM64.tar.gz
```
cd /opt
wget -O - -o /dev/stderr https://github.com/Jackett/Jackett/releases/latest/download/Jackett.Binaries.LinuxARM32.tar.gz | sudo tar -xz
```

Install as a service:

cd /opt/Jackett
sudo ./install_service_systemd.sh

The service will start on each login. Manage it using:

# Start Jackett
systemctl start jackett.service

# Stop Jackett
systemctl stop jackett.service

# Restart Jackett
systemctl restart jackett.service

# Check status
systemctl status jackett.service

Download and extract the latest Jackett.Binaries.LinuxARM32.tar.gz or Jackett.Binaries.LinuxARM64.tar.gz release from the releases page
Open a Terminal and cd to the Jackett folder
Run Jackett with the command ./jackett

Linux Installation (ARMv6 or below)

For legacy ARM systems.

Prerequisites:

Install Mono 5.10 or newer (latest stable release recommended):
- Follow instructions on the Mono website
- Install mono-devel and ca-certificates-mono packages
- On Red Hat/CentOS/openSUSE/Fedora, also install mono-locale-extras
Install libcurl:
- Debian/Ubuntu: apt-get install libcurl4-openssl-dev
- Redhat/Fedora: yum install libcurl-devel
- For other distributions, see the Curl documentation
Download and extract the latest Jackett.Binaries.Mono.tar.gz from the releases page
Run Jackett using Mono:
```
mono --debug JackettConsole.exe
```
(Optional) To install as a service:
```
sudo ./install_service_systemd_mono.sh
```

Important Notes:

Mono must be compiled with the Roslyn compiler (default)
Using MCS will cause "An error has occurred" errors (see issue #2704)
For users without a /home directory, add Environment=XDG_CONFIG_HOME=/path/to/folder to your systemd file

macOS Installation

Prerequisites:

macOS 13.0+ (Ventura) or greater

Installing as a Service

Download the appropriate release:
- Intel (x86): Jackett.Binaries.macOS.tar.gz
- Apple silicon (ARM): Jackett.Binaries.macOSARM64.tar.gz
Get the latest release from the releases page
Extract the downloaded file
Open the extracted folder and double-click on install_service_macos
If installation is successful, close the Terminal window
Navigate your web browser to http://127.0.0.1:9117

Service Management:

The service will start on each login. You can control it using:

# Stop Jackett
launchctl unload ~/Library/LaunchAgents/org.user.Jackett.plist

# Start Jackett
launchctl load ~/Library/LaunchAgents/org.user.Jackett.plist

Logs Location:

~/.config/Jackett/log.txt
/Users/your-user-name/Library/Application Support/Jackett/log.txt

Running Without Installing as a Service

Download and extract the latest Jackett.Binaries.macOS.tar.gz or Jackett.Binaries.macOSARM64.tar.gz release from the releases page
Open Terminal and navigate to the Jackett folder
Run Jackett with the command ./jackett

Docker Installation

Docker installation is highly recommended, especially if you are experiencing Mono stability issues or having trouble running Mono on your system (e.g., QNAP, Synology).

Detailed instructions are available at LinuxServer.io Jackett Docker

Thanks to LinuxServer.io for maintaining the Docker image.

Other Installation Methods

Linux via Ansible

CentOS/RedHat 7: jewflix.jackett
Ubuntu 16: chrisjohnson00.jackett

Homebrew (macOS/Linux)

Install via Homebrew: Homebrew Formulae - Jackett

Synology

Jackett is available as a beta package from SynoCommunity

Alpine Linux

Detailed instructions available at Jackett's Wiki - Alpine Linux

OpenWrt

Detailed instructions available at Jackett's Wiki - OpenWrt

Uninstallation

Windows

Use "Add or Remove Programs" in Windows Settings
Or run the installer again and choose "Uninstall"

Linux

Run this command:

wget https://raw.githubusercontent.com/Jackett/Jackett/master/uninstall_service_systemd.sh --quiet -O - | sudo bash

macOS

Run this command:

curl -sSL https://raw.githubusercontent.com/Jackett/Jackett/master/uninstall_jackett_macos | bash

Configuration

Running Behind Reverse Proxy

When running Jackett behind a reverse proxy, ensure that the original hostname of the request is passed to Jackett. If HTTPS is used, also set the X-Forwarded-Proto header to "https".

Important: Adjust the "Base path override" in Jackett settings accordingly.

Apache Configuration Example

<Location /jackett>
    ProxyPreserveHost On
    RequestHeader set X-Forwarded-Proto expr=%{REQUEST_SCHEME}
    ProxyPass http://127.0.0.1:9117
    ProxyPassReverse http://127.0.0.1:9117
</Location>

Nginx Configuration Example

location /jackett {
    proxy_pass http://127.0.0.1:9117;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Forwarded-Host $http_host;
    proxy_redirect off;
}

Search Cache

Jackett has an internal cache to increase search speed and reduce the number of requests to torrent sites. The default values should be suitable for most users.

Configuration Options:

Cache TTL (seconds): Default is 2100 (35 minutes). This indicates how long results can remain in the cache.
Cache max results per indexer: Default is 1000. This limits how many results are kept in cache for each indexer to control RAM usage.

Note: If you make many requests and have sufficient memory, you can increase the maximum results. If you experience problems, you can reduce the TTL value or disable the cache. Be aware that making too many requests can result in being banned by tracker sites.

Torznab Cache

If you have enabled the Jackett internal cache but want to fetch fresh results for a specific query (ignoring the cache), add the &cache=false parameter to your Torznab query.

Example:

http://127.0.0.1:9117/api/v2.0/indexers/all/results/torznab/api?apikey=YOUR_API_KEY&t=search&q=query&cache=false

Configuring FlareSolverr

Some indexers are protected by Cloudflare or similar services, and Jackett cannot solve the challenges on its own. For these cases, FlareSolverr has been integrated into Jackett.

What is FlareSolverr: FlareSolverr is a proxy server that solves Cloudflare and other anti-bot challenges, then provides Jackett with the necessary cookies.

Setup Instructions:

Install FlareSolverr service following their installation instructions
Configure FlareSolverr in Jackett:
- Open Jackett settings
- Set FlareSolverr API URL (e.g., http://172.17.0.2:8191)
- It is recommended to keep the default value in FlareSolverr Max Timeout (ms)

Note: Setting up this service is optional. Most indexers do not require it.

Configuring OMDb

This feature is used as a fallback when using the aggregate indexer to get the movie or series title if only the IMDB ID is provided in the request.

Setup Instructions:

Request a free API key from OMDb
- Free tier allows 1,000 daily requests
Paste the API key in Jackett settings

API Usage

Jackett Torznab Query Syntax

Jackett accepts Torznab queries following the specifications described in the Torznab specification document.

Basic Query Structure:

http://127.0.0.1:9117/api/v2.0/indexers/<indexer-name>/results/torznab/api?apikey=<your-api-key>&t=<search-type>&<parameters>

Examples:

Get indexer capabilities:

http://127.0.0.1:9117/api/v2.0/indexers/1337x/results/torznab/api?apikey=YOUR_API_KEY&t=caps

Perform a free text search:

http://127.0.0.1:9117/api/v2.0/indexers/1337x/results/torznab/api?apikey=YOUR_API_KEY&t=search&q=ubuntu

Search Modes and Parameters

Jackett supports the following search modes:

t=search (General Search)

Parameters: q (query string)

Example:

.../api?apikey=YOUR_API_KEY&t=search&cat=100002,100003&q=Show+Title+S01E02

t=tvsearch (TV Search)

Parameters: q, season, ep, imdbid, tvdbid, rid, tmdbid, tvmazeid, traktid, doubanid, year, genre

Examples:

.../api?apikey=YOUR_API_KEY&t=tvsearch&cat=5000&q=Show+Title&season=1&ep=2

.../api?apikey=YOUR_API_KEY&t=tvsearch&cat=5040,5045&genre=comedy&season=2023&ep=02/13

t=movie (Movie Search)

Parameters: q, imdbid, tmdbid, traktid, doubanid, year, genre

Examples:

.../api?apikey=YOUR_API_KEY&t=movie&cat=100001&q=Movie+Title&year=2023

.../api?apikey=YOUR_API_KEY&t=movie&cat=2000&imdbid=tt1234567

t=music (Music Search)

Parameters: q, album, artist, label, track, year, genre

Example:

.../api?apikey=YOUR_API_KEY&t=music&cat=100004&album=Title&artist=Name

t=book (Book Search)

Parameters: q, title, author, publisher, year, genre

Example:

.../api?apikey=YOUR_API_KEY&t=book&cat=100005,100006&genre=horror&publisher=Stuff

Note: Most indexers will only support a subset of these search modes and parameters. Use t=caps to get a list of the actual modes and parameters supported by a specific indexer.

Filter Indexers

A special "filter" indexer is available at:

http://127.0.0.1:9117/api/v2.0/indexers/<filter>/results/torznab

It will query the configured indexers that match the filter expression criteria and return combined results as "all".

Supported Filters

Filter	Condition
`type:<type>`	Indexer type equals `<type>`
`tag:<tag>`	Indexer tags contain `<tag>`
`lang:<lang>`	Indexer language starts with `<lang>`
`test:passed`	Last indexer test passed
`test:failed`	Last indexer test failed
`status:healthy`	Indexer successfully operated in recent minutes
`status:failing`	Indexer generated errors in recent calls
`status:unknown`	Indexer unused for a while

Supported Operators

Operator	Condition
`!<expr>`	NOT `<expr>`
`<expr1>+<expr2>`	`<expr1>` AND `<expr2>`
`<expr1>,<expr2>`	`<expr1>` OR `<expr2>`

Filter Examples

Example 1: Query indexers tagged with "group1" OR all non-private indexers with English language:

.../api/v2.0/indexers/tag:group1,!type:private+lang:en/results/torznab

Example 2: Query indexers that are not failing OR that passed their last test:

.../api/v2.0/indexers/!status:failing,test:passed/results/torznab

Aggregate Indexers

A special "all" indexer is available at:

http://127.0.0.1:9117/api/v2.0/indexers/all/results/torznab

It will query all configured indexers and return combined results.

Important Considerations

When to use the "all" indexer:

Quick setup with fewer configuration steps
Testing multiple indexers at once

Limitations of the "all" indexer:

You lose control over indexer-specific settings (categories, search modes, etc.)
Mixing search modes (IMDB, query, etc.) might cause low-quality results
Indexer-specific categories (>= 100000) cannot be used
Slow indexers will slow down overall results
Total results are limited to 1000

Recommendation: If your client supports multiple feeds, add each indexer directly instead of using the "all" indexer for better control and performance.

Getting Indexer Information

To get all Jackett indexers including their capabilities:

.../api/v2.0/indexers/all/results/torznab/api?apikey=YOUR_API_KEY&t=indexers

To filter by configuration status:

.../api/v2.0/indexers/all/results/torznab/api?apikey=YOUR_API_KEY&t=indexers&configured=true
.../api/v2.0/indexers/all/results/torznab/api?apikey=YOUR_API_KEY&t=indexers&configured=false

Command Line Switches

You can pass various options when running Jackett via the command line:

Windows Service Management

-i, --Install - Install Jackett Windows service (requires administrator)
-s, --Start - Start the Jackett Windows service (requires administrator)
-k, --Stop - Stop the Jackett Windows service (requires administrator)
-u, --Uninstall - Uninstall Jackett Windows service (requires administrator)
-r, --ReserveUrls - Register Windows port reservations (required for listening on all interfaces)

Configuration Options

-l, --Logging - Log all requests/responses to Jackett
-t, --Tracing - Enable tracing
-c, --UseClient - Override web client selection: automatic (default), httpclient, httpclient2
-x, --ListenPublic - Listen publicly (accessible from other devices)
-z, --ListenPrivate - Only allow local access (default)
-p, --Port - Specify web server port (default: 9117)
-n, --IgnoreSslErrors - Ignore invalid SSL certificates: true or false
-d, --DataFolder - Specify the location of the data folder (requires administrator on Windows)
- Example: --DataFolder="D:\Your Data\Jackett\"
- Note: Do not use this on Unix (Mono) systems. Adjust the HOME directory or set XDG_CONFIG_HOME environment variable instead
--NoRestart - Don't restart after update
--PIDFile - Specify the location of the PID file
--NoUpdates - Disable automatic updates
--help - Display help screen
--version - Display version information

Example Usage

# Start Jackett on a custom port
./jackett --Port 9118

# Start with public access enabled
./jackett --ListenPublic

# Start with custom data folder (Windows)
JackettConsole.exe --DataFolder="D:\Jackett Data"

# Enable detailed logging
./jackett --Logging --Tracing

Building from Source

Windows

See the contributing guide for detailed instructions.

macOS

Prerequisites: Install .NET SDK manually from dotnet.microsoft.com

Build Steps:

# Clone the repository
git clone https://github.com/Jackett/Jackett.git
cd Jackett/src

# Build for .NET Core
dotnet publish Jackett.Server -f net9.0 --self-contained -r osx-x64 -c Debug

# Run Jackett
./Jackett.Server/bin/Debug/net9.0/osx-x64/jackett

Linux

Prerequisites:

# Install build tools (Debian/Ubuntu)
sudo apt install nuget msbuild dotnet-sdk-9.0

# For other distributions, install equivalent packages

Build Steps:

# Clone the repository
git clone https://github.com/Jackett/Jackett.git
cd Jackett/src

# Build for .NET Core
dotnet publish Jackett.Server -f net9.0 --self-contained -r linux-x64 -c Debug

# Run Jackett
./Jackett.Server/bin/Debug/net9.0/linux-x64/jackett

Troubleshooting

Common Issues

Cannot Connect to Jackett

Check if Jackett is running:

# Linux
systemctl status jackett.service

# Windows
- Check the system tray for Jackett icon
- Check Services (services.msc) for "Jackett" service

Try alternative URL:

Instead of http://127.0.0.1:9117, try http://localhost:9117

Check firewall:

Ensure port 9117 is not blocked by your firewall
On Linux: sudo ufw allow 9117
On Windows: Check Windows Defender Firewall settings

No Search Results

Test the indexer directly:

Go to Jackett dashboard
Click "Manual Search" on the indexer
Enter a test query
Check if results appear

Verify tracker status:

Check if the tracker website is accessible in your browser
Some trackers may be down or blocking your IP

Check indexer configuration:

For private trackers, ensure your credentials are correct
Try re-adding the indexer

Permission Denied Errors (Linux)

# Fix ownership of Jackett files
sudo chown -R $USER:$USER /opt/Jackett
sudo chown -R $USER:$USER ~/.config/Jackett

Service Won't Start (Linux)

# View recent error logs
journalctl -u jackett.service -n 50

# Reload systemd and restart
sudo systemctl daemon-reload
sudo systemctl restart jackett.service

# Check for errors
systemctl status jackett.service

Cloudflare Protection

If an indexer shows "Cloudflare protected" errors:

Install and configure FlareSolverr (see Configuring FlareSolverr)
Make sure FlareSolverr is running and accessible
Test the indexer again

Updates Failing

Manual update:

Download the latest release for your platform
Stop Jackett service
Extract new files over existing installation
Start Jackett service

Disable automatic updates:

./jackett --NoUpdates

Other Common Issues

See https://github.com/Jackett/Jackett/wiki/Troubleshooting

Getting Help

Check the GitHub Issues for similar problems
Read the Troubleshooting Guide
Open a new issue with:
- Your operating system and version
- Jackett version
- Error messages from logs
- Steps to reproduce the problem

Log Locations

Linux:

~/.config/Jackett/log.txt
journalctl -u jackett.service

Windows:

%ProgramData%\Jackett\log.txt

macOS:

~/.config/Jackett/log.txt
/Users/your-user-name/Library/Application Support/Jackett/log.txt

Contributing

This project is actively recruiting development help. If you can contribute code, please see:

Ways to Contribute:

Report bugs and issues
Suggest new features
Add or fix indexer definitions
Improve documentation
Submit code contributions

Screenshots

Quick Reference

Item	Value/Location
Default URL	`http://127.0.0.1:9117`
Default Port	9117
Config (Linux)	`~/.config/Jackett/`
Config (Windows)	`%ProgramData%\Jackett\`
Config (macOS)	`~/.config/Jackett/` or `~/Library/Application Support/Jackett/`
Logs (Linux)	`~/.config/Jackett/log.txt`
Logs (Windows)	`%ProgramData%\Jackett\log.txt`
Latest Release	GitHub Releases
Documentation	GitHub Wiki
Issues	GitHub Issues

License and Credits

Jackett is an open-source project maintained by the community.

Links:

jellyfin/jellyfin

The Free Software Media System - Server Backend & API

Jellyfin

The Free Software Media System

Jellyfin is a Free Software Media System that puts you in control of managing and streaming your media. It is an alternative to the proprietary Emby and Plex, to provide media from a dedicated server to end-user devices via multiple apps. Jellyfin is descended from Emby's 3.5.2 release and ported to the .NET platform to enable full cross-platform support.

There are no strings attached, no premium licenses or features, and no hidden agendas: just a team that wants to build something better and work together to achieve it. We welcome anyone who is interested in joining us in our quest!

For further details, please see our documentation page. To receive the latest updates, get help with Jellyfin, and join the community, please visit one of our communication channels. For more information about the project, please see our about page.

Want to get started?
Check out our downloads page or our installation guide, then see our quick start guide. You can also build from source.

Something not working right?
Open an Issue on GitHub.

Want to contribute?
Check out our contributing choose-your-own-adventure to see where you can help, then see our contributing guide and our community standards.

New idea or improvement?
Check out our feature request hub.

Don't see Jellyfin in your language?
Check out our Weblate instance to help translate Jellyfin and its subprojects.

Jellyfin Server

This repository contains the code for Jellyfin's backend server. Note that this is only one of many projects under the Jellyfin GitHub organization on GitHub. If you want to contribute, you can start by checking out our documentation to see what to work on.

Server Development

These instructions will help you get set up with a local development environment in order to contribute to this repository. Before you start, please be sure to completely read our guidelines on development contributions. Note that this project is supported on all major operating systems except FreeBSD, which is still incompatible.

Prerequisites

Before the project can be built, you must first install the .NET 9.0 SDK on your system.

Instructions to run this project from the command line are included here, but you will also need to install an IDE if you want to debug the server while it is running. Any IDE that supports .NET 6 development will work, but two options are recent versions of Visual Studio (at least 2022) and Visual Studio Code.

ffmpeg will also need to be installed.

Cloning the Repository

After dependencies have been installed you will need to clone a local copy of this repository. If you just want to run the server from source you can clone this repository directly, but if you are intending to contribute code changes to the project, you should set up your own fork of the repository. The following example shows how you can clone the repository directly over HTTPS.

git clone https://github.com/jellyfin/jellyfin.git

Installing the Web Client

The server is configured to host the static files required for the web client in addition to serving the backend by default. Before you can run the server, you will need to get a copy of the web client since they are not included in this repository directly.

Note that it is recommended for development to host the web client separately from the web server with some additional configuration, in which case you can skip this step.

There are two options to get the files for the web client.

Build them from source following the instructions on the jellyfin-web repository
Get the pre-built files from an existing installation of the server. For example, with a Windows server installation the client files are located at C:\Program Files\Jellyfin\Server\jellyfin-web

Running The Server

The following instructions will help you get the project up and running via the command line, or your preferred IDE.

Running With Visual Studio

To run the project with Visual Studio you can open the Solution (.sln) file and then press F5 to run the server.

Running With Visual Studio Code

To run the project with Visual Studio Code you will first need to open the repository directory with Visual Studio Code using the Open Folder... option.

Second, you need to install the recommended extensions for the workspace. Note that extension recommendations are classified as either "Workspace Recommendations" or "Other Recommendations", but only the "Workspace Recommendations" are required.

After the required extensions are installed, you can run the server by pressing F5.

Running From the Command Line

To run the server from the command line you can use the dotnet run command. The example below shows how to do this if you have cloned the repository into a directory named jellyfin (the default directory name) and should work on all operating systems.

cd jellyfin                          # Move into the repository directory
dotnet run --project Jellyfin.Server --webdir /absolute/path/to/jellyfin-web/dist # Run the server startup project

A second option is to build the project and then run the resulting executable file directly. When running the executable directly you can easily add command line options. Add the --help flag to list details on all the supported command line options.

Build the project

dotnet build                       # Build the project
cd Jellyfin.Server/bin/Debug/net10.0 # Change into the build output directory

Execute the build output. On Linux, Mac, etc. use ./jellyfin and on Windows use jellyfin.exe.

Accessing the Hosted Web Client

If the Server is configured to host the Web Client, and the Server is running, the Web Client can be accessed at http://localhost:8096 by default.

API documentation can be viewed at http://localhost:8096/api-docs/swagger/index.html

Running from GitHub Codespaces

As Jellyfin will run on a container on a GitHub hosted server, JF needs to handle some things differently.

NOTE: Depending on the selected configuration (if you just click 'create codespace' it will create a default configuration one) it might take 20-30 seconds to load all extensions and prepare the environment while VS Code is already open. Just give it some time and wait until you see Downloading .NET version(s) 7.0.15~x64 ...... Done! in the output tab.

NOTE: If you want to access the JF instance from outside, like with a WebClient on another PC, remember to set the "ports" in the lower VS Code window to public.

NOTE: When first opening the server instance with any WebUI, you will be sent to the login instead of the setup page. Refresh the login page once and you should be redirected to the Setup.

There are two configurations for you to choose from.

Default - Development Jellyfin Server

This creates a container that has everything to run and debug the Jellyfin Media server but does not setup anything else. Each time you create a new container you have to run through the whole setup again. There is also no ffmpeg, webclient or media preloaded. Use the .NET Launch (nowebclient) launch config to start the server.

Keep in mind that as this has no web client you have to connect to it via an external client. This can be just another codespace container running the WebUI. vuejs does not work from the get-go as it does not support the setup steps.

Development Jellyfin Server ffmpeg

this extends the default server with a default installation of ffmpeg6 though the means described here: https://jellyfin.org/docs/general/installation/linux#repository-manual If you want to install a specific ffmpeg version, follow the comments embedded in the .devcontainer/Dev - Server Ffmpeg/install.ffmpeg.sh file.

Use the ghcs .NET Launch (nowebclient, ffmpeg) launch config to run with the jellyfin-ffmpeg enabled.

Running The Tests

This repository also includes unit tests that are used to validate functionality as part of a CI pipeline on Azure. There are several ways to run these tests.

Run tests from the command line using dotnet test
Run tests in Visual Studio using the Test Explorer
Run individual tests in Visual Studio Code using the associated CodeLens annotation

Advanced Configuration

The following sections describe some more advanced scenarios for running the server from source that build upon the standard instructions above.

Hosting The Web Client Separately

It is not necessary to host the frontend web client as part of the backend server. Hosting these two components separately may be useful for frontend developers who would prefer to host the client in a separate webpack development server for a tighter development loop. See the jellyfin-web repo for instructions on how to do this.

To instruct the server not to host the web content, there is a nowebclient configuration flag that must be set. This can be specified using the command line switch --nowebclient or the environment variable JELLYFIN_NOWEBCONTENT=true.

Since this is a common scenario, there is also a separate launch profile defined for Visual Studio called Jellyfin.Server (nowebcontent) that can be selected from the 'Start Debugging' dropdown in the main toolbar.

NOTE: The setup wizard cannot be run if the web client is hosted separately.

This project is supported by:

OpenRA/OpenRA

Open Source real-time strategy game engine for early Westwood games such as Command & Conquer: Red Alert written in C# using SDL and OpenGL. Runs on Windows, Linux, *BSD and Mac OS X.

OpenRA

A Libre/Free Real Time Strategy game engine supporting early Westwood classics.

Website: https://www.openra.net
Chat: #openra on Libera (web) or Discord
Repository: https://github.com/OpenRA/OpenRA

Please read the FAQ in our Wiki and report problems at https://github.com/OpenRA/OpenRA/issues.

Join the Forum for discussion.

Play

Distributed mods include a reimagining of

Command & Conquer: Red Alert
Command & Conquer: Tiberian Dawn
Dune 2000

EA has not endorsed and does not support this product.

Check our Playing the Game Guide to win multiplayer matches.

Contribute

Please read INSTALL.md and Compiling on how to set up an OpenRA development environment.
See Hacking for a (now very outdated) overview of the engine.
Read and follow our Code of Conduct.
To get your patches merged, please adhere to the Contributing guidelines.

Mapping

We offer a Mapping Tutorial as you can change gameplay drastically with custom rules.
For scripted mission have a look at the Lua API.
If you want to share your maps with the community, upload them at the OpenRA Resource Center.

Modding

Download a copy of the OpenRA Mod SDK to start your own mod.
Check the Modding Guide to create your own classic RTS.
There exists an auto-generated Trait documentation to get started with yaml files.
Some hints on how to create new OpenRA compatible Pixelart.
Upload total conversions at our Mod DB profile.

Support

Sponsor a mirror server if you have some bandwidth to spare.
You can immediately set up a Dedicated Game Server.

License

Copyright (c) OpenRA Developers and Contributors This file is part of OpenRA, which is free software. It is made available to you under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. For more information, see COPYING.

DearVa/Everywhere

Context-aware AI assistant for your desktop. Ready to respond intelligently, seamlessly integrating multiple LLMs and MCP tools.

前往中文版本 »

Every moment, Every place. Your AI - `Everywhere`

📖 Explore Official Docs · 🎬 Watch the Trailer · 🪲 Report a Bug · 💡 Request a Feature

📖 Table of Contents

🦄 About Everywhere

Everywhere is an interactive AI assistant with context-aware capabilities, featuring a sleek, modern UI and powerful integrated functionality. Unlike traditional AI tools, Everywhere instantly perceives and understands anything on your screen. No need for screenshots, copying, or switching apps—just press a shortcut key to get the help you need right where you are, delivering seamless AI assistant support.

🌟 Experience Examples

🩺 Troubleshooting Expert

You encounter an error message while using your computer but are unsure how to resolve it. Bring up Everywhere next to the error message, simply type "What is this error? How to solve it?", and Everywhere will capture the message context in place and provide an accurate solution.

📰 Quick Web Summarization

Browsing a lengthy technical article but just need the key points? Bring up Everywhere over the webpage, ask "Give me a short summary", and instantly receive the main arguments without reading the entire content.

🌐 Instant Translation

Encounter a foreign word while researching literature? Highlight it or just bring up Everywhere against the text, tell it to "Translate to Chinese", and see an immediate translation without opening a secondary translation tool.

✉️ Email Draft Assistance

Unsure about the tone of an important business email? Bring up Everywhere over your draft, enter "Make this email more professional", and your casual text is transformed into polished, business-ready communication.

❔ Is it true?

Come across information of uncertain authenticity? Select the relevant text, bring up Everywhere, ask "Is this true?", and Everywhere will quickly search and verify the reliability of the information.

🛠️ Technical Features

Category	✅ Currently Supported	🚧 Work in Progress
🤖 Rich Model Ecosystem	• Everywhere Cloud Service • OpenAI • Anthropic (Claude) • Google (Gemini) • DeepSeek • Moonshot (Kimi) • MiniMax • Local Deployment (Ollama) • Compatible with custom API endpoints
⚙️ Powerful Agent System	• Web Browser • Dispatch Sub-agents • Local File System • Terminal Script Execution • MCP Tools • Everything Fast Search (Windows) • Integrated System Apps (macOS)	• Memory System
🫧 Seamless Interaction	• Ultimate Modern Frosted Glass UI • Intelligent Context Awareness • Global System Hotkeys • Text Selection Interaction • Rich Markdown and Math Formula Rendering	• Mouse Shortcuts • Voice Interaction
🖥️ Multi-Platform	• 🪟 Windows • 🍎 macOS	• 🐧 Linux
🌐 i18n Support	• Simplified/Traditional Chinese • English, Deutsch, Español • Français, Italiano, 日本語 • 한국어, Русский, Türkçe	Partially AI-assisted translation. Contributions and corrections are welcome!

⚙️ Core Technology & Architecture

👁️ Broad Context Awareness: In addition to supporting traditional screen multi-modality, we have deeply integrated underlying accessibility APIs and UI automation technologies. This allows the application to accurately extract active structured environment data across a huge variety of software with low intrusion.
🧠 Scenario Invocation & Strategy Engine: 🚧 The original intention was to completely end the workflow that disrupts your working rhythm. Previously, using LLMs often required: selecting & copying -> switching to the AI window -> pasting -> manually typing to complete your intention. With the advanced features powered by the strategy engine, Everywhere, invoked via shortcut, instantly perceives the scenario or app you are browsing. It pushes shortcut execution strategies tailored to your exact context without the need to explain your request, achieving a true state of flow.
🧱 Commitment to Core Quality: We emphasize software performance, code quality, and security. Starting from the system's core foundation, via modern architecture design and meticulous system engineering, we fundamentally reject pure reliance on "Vibe Coding" and blind agile piling. Every line of code is carefully written and meticulously polished.

📋 System Requirements

Platform	Minimum System Requirements
🪟 Windows	Windows 10 (10.0.19041.0)
🍎 macOS	Monterey 12.0
🐧 Linux	🚧 In Development

🚀 Getting Started

Acquisition & Installation

Tip

We recommend visiting our official website to directly download the appropriate version for your system.

Windows

Everywhere-Windows-x64-Setup-vx.x.x.exe: Full wizard installer package (Recommended).
Everywhere-Windows-x64-vx.x.x.zip: Portable/install-free zip package.

macOS

Everywhere-macOS-arm64-vx.x.x.pkg: For Apple Silicon (M-series) Mac devices.
Everywhere-macOS-x64-vx.x.x.pkg: For Intel Mac devices.

Help & Community

Note

New here? Or looking for deep integration features like MCP? We highly recommend checking out our official guide first!

📖 Official Documentation: https://everywhere.sylinko.com
👾 Discord Community: Join our channel for support
💬 Chinese User Group: Click to join our QQ group

🤝 Contributing

We love open source and welcome your brilliant ideas and code contributions (Pull Requests)! Please see CONTRIBUTING.md for code styling guidelines and local compilation instructions.

A massive thanks to all of the outstanding contributors during our inception and growth phases:

📄 License

This project is released under the Business Source License 1.1. See the LICENSE file for more information. For Third-Party dependencies and open-source component licenses, see ThirdPartyNotices.txt.

💖 Sponsor

302.AI is a pay-as-you-go enterprise AI resource hub that offers the latest and most comprehensive AI models and APIs on the market, along with a variety of ready-to-use online AI applications.

🤩 Special Thanks

The Code Signing Certificate for this project is generously sponsored by Certum China, continuing their great contribution to the open-source community.

📈 Star History

⬆️ Back to top

lucasg/Dependencies

A rewrite of the old legacy software "depends.exe" in C# for Windows devs to troubleshoot dll load dependencies issues.

Dependencies - An open-source modern Dependency Walker

Download here

(If you're running an AV, use this download instead)

NB : due to limitations on /clr compilation, Dependencies needs Visual C++ Redistributable installed to run properly.

Overview

Dependencies is a rewrite of the legacy software Dependency Walker which was shipped along Windows SDKs, but whose development stopped around 2006. Dependencies can help Windows developers troubleshooting their dll load dependencies issues.

Releases

v1.11 :
- lots of bugfixes and incremental improvements
- covid pandemic
v1.10 :
- lots of bugfixes and incremental improvements
- support of Windows 8.1 apisets parsing
v1.9 :
- Display imports and exports the way Depends.exe does.
- Added user customization for search folders and working directory
- Added LLVM demangler to availables symbol demangling
- Fixed Wow64 FsRedirection bugs
- F5 can now refresh the analysis
- Added CLR assembly dependencies enumeration
- Added a packaging option without Peview.exe (which triggers some AV).
v1.8 :
- Add x86/x64 variants for Dependencies
v1.7 :
- Add CLI tool "dependencies.exe"
v1.6 :
- Add appx packaging
v1.5 :
- Support of Sxs parsing
- Support of api set schema parsing
- API and Modules list can be filtered
v1.0 -- Initial release

Installation and Usage

Dependencies is currently shipped as two binaries (no installer present) : Dependencies.exe as a CLI tool and DependenciesGui.exe for its GUI counterpart (see screenshot). Just click on one of the release numbers above (preferably the latest), download and uncompress the archive and run DependenciesGui.exe. Since the binary is not signed, SmartScreen might scream at runtime. Dependencies also bundle ClrPhTester.exe, a dumpbin-like executable used to test for non-regressions.

Dependencies currently does not recursively resolve child imports when parsing a new PE since it can be really memory-hungry to do so ( it can over a GB even for "simple" PEs ). This behavior can be overridden (app-wide) via a property located in "Options->Properties->Tree build behaviour".

Tree build behaviours available :

ChildOnly (default) : only process PE child imports and nothing beyond.
RecursiveOnlyOnDirectImports : do not process delayload dlls.
Recursive : Full recursive analysis. You better have time and RAM on your hands if you activate this setting :

Limitations

At the moment, Dependencies recreates features and "features" of depends.exe, which means :

Only direct, forwarded and delay load dependencies are supported. Dynamic loading via LoadLibrary are not supported (and probably won't ever be).
Support of api set schema redirection since 1.5
Checks between Api Imports and Exports.
Minimal support of sxs private manifests search only.

Building

Building is pretty straightforward. The only caveat is you need to select the "Debug" or "Release" configuration and "x64" or "x86" platform which may not be the default.

Credits and licensing

Special thanks to :

ProcessHacker2 for :
- phlib, which does the heavy lifting for processing PE informations.
- peview, a powerful and lightweight PE informations viewer.
Dragablz a C#/XAML library which implement dockable and dragable UI elements, and can recreate the MDI programming model in WPF.
@aionescu, @zodiacon and Quarkslab for their public infos on ApiSets schema.
Thomas levesque's blog which pretty much solved all my WPF programming issues. His AutoGridSort is used in this project
Venkatesh Mookkan for it's FilterControl for ListView used in this project
demumble for demangling GCC symbols on Windows

GitHub C# Daily Trending

Devolutions/UniGetUI

WARNING: wingetui•com and unigetui•com are fake websites hosted by a third-party. please do NOT trust them

Devolutions UniGetUI

Project stewardship

Table of contents

Installation

Microsoft Store installation (recommended)

Download UniGetUI installer:

Install UniGetUI via WinGet:

Install UniGetUI via Scoop:

Install UniGetUI via Chocolatey:

Update UniGetUI

Features

Package Managers

Translations

Screenshots

Contributions

Frequently asked questions

Command-line parameters:

fullstackhero/dotnet-starter-kit

FullStackHero .NET 10 Starter Kit

Quick Start

Option 1: FSH CLI (recommended)

Option 2: dotnet new template

Option 3: Clone the repository

Option 4: GitHub Codespaces

FSH CLI Commands

Why teams pick this

Stack highlights

Repository map

Run it now (Aspire)

Run the API only

Bring the framework into your API

Included modules

Development notes

kgrzybek/modular-monolith-with-ddd

Modular Monolith with DDD

Announcement

CI

FrontEnd application

Table of contents

1. Introduction

1.1 Purpose of this Repository

1.2 Out of Scope

1.3 Reason

1.4 Disclaimer

1.5 Give a Star

1.6 Share It

2. Domain

2.1 Description

2.2 Conceptual Model

2.3 Event Storming

3. Architecture

3.0 C4 Model

3.0.1 C1 System Context

3.0.2 C2 Container

3.0.3 C3 Component (high-level)

3.0.4 C3 Component (module-level)

3.0.5 C4 Code (meeting group aggregate)

3.1 High Level View

3.2 Module Level View

3.3 API and Module Communication

3.4 Module Requests Processing via CQRS

3.5 Domain Model Principles and Attributes

3.6 Cross-Cutting Concerns

3.7 Modules Integration

3.8 Internal Processing

3.9 Security

3.10 Unit Tests

3.11 Architecture Decision Log

3.12 Architecture Unit Tests

3.13 Integration Tests

Definition

Approach

Implementation

3.14 System Integration Testing

Definition

Implementation

3.15 Event Sourcing

WARNING: wingetui_•com and unigetui_•com are fake websites hosted by a third-party. please do NOT trust them