Docker in WSL Without Docker Desktop

The Challenge with Docker Desktop

Docker Desktop has been the solution for running Docker on Windows, but it comes with some considerations:

  • Licensing requirements for commercial use
  • Resource overhead from running a full Docker Desktop
  • Complexity for users who just need basic Docker functionality

For developers looking for a lightweight alternative, running Docker directly in Windows Subsystem for Linux 2 (WSL) is a practical option.

Introducing docker-wsl

I’ve created docker-wsl, an automated PowerShell script that installs and configures Docker within WSL without requiring Docker Desktop. This project enables you to run Docker natively in WSL’s Ubuntu environment while maintaining full compatibility with Windows PowerShell.


Serilog.Sinks.SqlServer: High-Performance Serilog sink for Microsoft SQL Server

Application logging is the foundation of observability in production systems, yet many logging solutions suffer from performance overhead that can impact application throughput. When logging to SQL Server, developers need a solution that’s both fast and memory-efficient. Enter Serilog.Sinks.SqlServer - a high-performance sink that writes log events to Microsoft SQL Server using optimized bulk insert operations, delivering significant performance improvements over existing alternatives.

https://github.com/loresoft/serilog-sinks-sqlserver

What is Serilog.Sinks.SqlServer?

Serilog.Sinks.SqlServer is a lightweight, high-performance .NET library designed specifically to integrate Serilog’s powerful structured logging capabilities with Microsoft SQL Server. Whether you’re building ASP.NET Core web applications, microservices, or console applications, this sink provides an efficient way to persist your logs to SQL Server with minimal performance overhead.


Blazilla: Seamless FluentValidation Integration for Blazor Forms

Form validation is a critical aspect of any web application, and Blazor developers have long sought a clean, powerful way to integrate FluentValidation with Blazor’s EditForm component. Enter Blazilla - a library that bridges this gap perfectly, providing seamless integration between FluentValidation and Blazor forms.

What is Blazilla?

Blazilla is a lightweight .NET library designed specifically to integrate FluentValidation’s robust validation capabilities with Blazor’s EditForm component. Whether you’re building Blazor Server or Blazor WebAssembly applications, Blazilla provides a clean, efficient way to implement client-side validation using FluentValidation’s expressive syntax.


HashGate - HMAC Authentication Implementation

In today’s microservices landscape, secure server-to-server communication is more critical than ever. While OAuth and JWT tokens are popular choices for user authentication, they often introduce unnecessary complexity and dependencies for service-to-service communication. That’s where HashGate comes in - a lightweight, powerful HMAC authentication library designed specifically for ASP.NET Core applications.

https://github.com/loresoft/HashGate

What is HashGate?

HashGate is a comprehensive HMAC (Hash-based Message Authentication Code) authentication system that provides both server-side authentication middleware and client-side HTTP handlers. Inspired by AWS Signature Version 4 and Azure HMAC Authentication, HashGate ensures that every HTTP request is cryptographically signed, providing request integrity and authenticity without the overhead of traditional token-based systems.


Privileged: A Powerful Authorization Library for .NET

Privileged, a .NET authorization library that makes implementing rule-based permissions both simple and powerful. Whether you’re building a basic web application or a complex enterprise system, Privileged provides the flexibility to scale from simple claim-based authorization to a fully-featured subject and attribute-based authorization system.

https://github.com/loresoft/Privileged

What is Privileged?

Privileged is an authorization library that operates on rules defining what a user can actually do in your application. It’s designed to be incrementally adoptable - you can start simple and add complexity as your authorization requirements grow.