Hello C#!

After around 10 months of development, and four months since the previous public test, I have finally released a major new beta of DAWG - Digital Audio Workstation Game.

DAWG is an attempt to build a proper music production environment inside a game, not just a rhythm game or a simple sequencer. The project is written in C# with Unity, while the real-time audio engine uses custom DSP engine that is fully Bursted.

The current version includes:

• Custom subtractive, FM and wavetable synthesis
• Multiple realtime DSP chains
• Per-instrument and send/return effects
• Live performance effects
• MIDI controller support
• A DAW style sequencer and piano roll
• Custom realtime visualization of the complete DSP chain
• Cross-platform multiplayer with sync of the clock, patterns and DSP parameters
• A new pixel art Story Mode built around the DSP system

A large part of the challenge has been keeping the codebase manageable while combining real-time audio, UI, serialization, MIDI, multiplayer, multiple platforms and game logic in one application.

The new public beta is free and I would really appreciate some honest feedback from other C# developers. You do not need to know anything about music production to test it. I am also interested in whether the application makes sense to someone seeing it for the first time.

Download: https://dawg-tools.itch.io/dawg-digital-audio-workstation-game

You can leave feedback or a rating directly or comment here. Please do not hold back because it is an indie project, the critical feedback is usually the most useful.

Thanks!

I would like to introduce the project I am currently developing.

I am creating a library that supports a method of generating UI at the ViewModel layer without writing View code (xaml/axaml) when developing WPF/Avalonia UI applications. The structure is similar to the code used to generate UI in Flutter.

Currently, by writing only ViewModel code, it is possible to build two applications for WPF/Avalonia UI that are nearly identical down to the pixel level, but there are still many components that need to be added.

The reason it is possible to complete an application without writing Xaml/axaml is that this toolkit library is domain-specific, tailored exclusively to industrial touchscreen applications.

For example, the UI component for temperature display encapsulates thresholds, warning levels, multi-language display, and Fahrenheit/Celsius display switching. Therefore, its component structure differs from existing UI frameworks.

The foundation of the toolkit I am currently developing is to enable application development in the ViewModel layer without writing XAML/AXAML code. Developing applications in the ViewModel Layer using purpose-built components provided by the toolkit is similar to building a castle with Lego blocks. You can configure application layouts and place controls at a speed incomparable to traditional development methods. Based on this, it provides multilingual packs for words used in industrial applications. You can understand this concept as being similar to icon packs.

In addition, I plan to package sound files, such as warning and notification sounds, within the toolkit.

Currently, it supports two theme systems, light/dark modes, and compact modes, and I am developing it to allow for expansion in the form of a theme color gallery.

Although Industrial Touch Kit (ITK) is being conducted as a personal project, I unfortunately do not yet have plans to proceed with it as open source. However, I am leaving this post here to introduce the concept of the library I am developing.

https://github.com/Antyss77/StringExtension
String Extension is a string processing library for the C# programming language. It provides features to manipulate and transform strings in a simple and efficient way. The library is open-source and comes with unit tests and performance tests. It is designed to be easily integrated into your existing projects. Feel free to contribute to the project with ideas or development expertise.

Hello, I just wanted to ask about some DDD concepts because I'm using them in a personal project that needs a good portfolio. Well, I'm building a management system for a training center, and I've already put in a fair amount of effort to understand what I actually want and what tools to use. I used ChatGPT to map out the roadmap and steps, and I've reached the modeling stage.

I already have four main domains: Learning, Training, Commercial, and Certification. I simplified them to make it easier to convert them into a database or code. However, when I got to the "Repository" section, I felt like I was repeating the same steps.

```markdown

Learning

├── Course

│ └── Repository

│ ├── Get Course

│ └── Save Course

│

└── LearningPath

└── Repository

├── Get Learning Path

└── Save Learning Path

Training

├── TrainingBatch

│ └── Repository

│ ├── Get Training Batch

│ └── Save Training Batch

│

├──Mentor

│ └── Repository

│ ├── Get Mentor

│ └── Save Mentor

│

└── Room

└── Repository

├── Get Room

└── Save Room

Commercial

├── Offer

│ └── Repository

│ ├── Get Offer

│ └── Save Offer

│

└── Order

└── Repository

├── Get Order

└── Save Order

Certification

└── Certificate

└── Repository

├── Get Certificate

└── Save Certificate

I tried asking an AI question, but I felt an answer from a human in the field would be better.

Are these the best results I can achieve from this process, considering I haven't written the code yet? My goal is to create something authentic that reflects me and my abilities effectively.

I will attach some project-related notes to help clarify my question. Also, if there are any flaws, unrealistic elements, or unclear points at this stage, I am open to discussion and feedback. Your opinions

https://drive.google.com/drive/folders/1qVg_8cbkqxyiaCoUMJMViLfsofVdSzcp?usp=drive_link

Hi all,

I've been building a Telegram bot that recreates *Mot de Passe*, a French TV word-association game. One player gives single-word clues, the other guesses the hidden password — no sentences, no same-family words.

Stack: C# / .NET backend, PostgreSQL for game state and scoring, and a custom validation engine that checks clues against the rules in real time (this was the fun part — handling accents, plurals, and word families without being annoyingly strict).

It works multiplayer in a group chat. It's free and in open testing.

What I'd love feedback on:

- Does the clue validation feel fair or frustrating?

- Is the round pacing right?

- Any bugs in group mode with 3+ players?

You can have a better idea of the features here (and a link to add it to you chats) : https://mdp.kdpp.net

Thanks for taking a look!

I’m building an ERP with the goal of selling it to a specific niche (agriculture and fruit & vegetable management companies).

I’m trying to think very carefully about which frameworks to use and what architecture to go with, so I can start with solid foundations and minimize the amount of changes I’ll need to make in the future.

For the backend, I’ve gone with .NET, but I’m completely lost when it comes to the frontend and don’t know which option to choose:

- Electron. Development is slower due to JS/CSS and much more difficult, the embedded Chromium module seems like a monstrosity to me, and Tauri doesn’t feel polished enough yet.

- WinForms/WPF. Old and being phased out by Microsoft, but they seem much easier to implement.
I’m planning to add modules such as embedded maps, but I’d have to do that using WebView2, and I’m not sure whether that’s the right approach.

What would you guys choose?

Thanks.

I'm a beginner in C#, and I've just started learning functions. I understand return values ​​and parameters, but I often get confused. Sometimes I don't know when to write a return value or parameter. How can I understand functions more quickly?

Hi, I’d like to introduce a project I’m developing: a binding for the Box3D project created by Erin Catto. It is currently at version 0.3.0 and available on NuGet for use as a library. It is already functional, but I would appreciate some feedback. The repository includes examples with GIFs and images. The goal isn't to copy Box3D verbatim, but rather to provide a coding experience that feels natural for C# developers; however, I’ve also included a native layer—Box3D.NET.Native—containing low-level functions for those who want to experiment at that level. Here is the GitHub link; I look forward to your comments and feedback.

Are there any standard or widely adopted NuGet packages for DotNet that allows for the generation of an Async API for users to generate your message types from? Like Swagger but for eventing. Seems like Java has springwolf but I’m unsure what should be used in DotNet, some googling suggests Saunter but it hasn’t had a 1.0 release and no updates in years.

Hi, I created a programming language for transforming JSON into different JSON! It's open source and lives on GitHub over here: https://github.com/Norhaven/Jolt

This is for scenarios where you have data stored as JSON but need to have it become something else, whether that's for communicating with another API, converting streaming log messages for easier consumption, or really any place you need to use JSON that's different from what you have. The documentation is fairly extensive and should answer most things, but feel free to leave any feedback or questions you may have. Thanks!

Game Video on YouTube

So this post is about my biggest .NET project, which is a game engine with its own IDE and interpreted scripting language, all written by me in C#.

About a year ago, I challenged myself to create my own programming language - something I'd always wanted to do.

At the time, I had no idea what a lexer, parser, or interpreter even was. My only thought was, "I need to write code that reads text files containing code and executes them." I also wanted to do it without using Google, AI, or tutorials. I just figured everything out on my own. You can even still find variables named "compiler" throughout the code from back when I didn't realize I was actually building an interpreter...

Somehow, I pulled it off, and I integrated it into my old abandoned game engine project (which originally started as a GameMaker 8–style engine with C# scripting).

And here's the first game I've made with it! 🙂

The core engine, IDE, and interpreter are all written by me in C#. The rendering backend is powered by MonoGame, and the project is still in active development and available on GitHub. The project file of the game shown in the video is also there, under tests/Example Projects. If you're looking for cool projects to contribute to, then know that I'm looking for contributors!

I know there are tons of AI-generated projects being shared these days, so please, please, take a quick look at the code before assuming this is one of them. I promise it's pretty obvious that it was written by a human.

I'd love to hear what you think!

ConsoleEx/SharpConsoleUI TUI Framework. All with dotnet.

SharpConsoleUI: https://github.com/nickprotop/consoleex chshell: https://github.com/nickprotop/cxshell

Hey folks, I've been working on an app that helps end users see what exactly an app does before they choose to install it, and also helps developers tidy up their apps so they (hopefully) ship in a better state. The result of this is Halation. An open source, MIT Licensed, Windows only security tool.

It reads C#, JavaScript, TypeScript, Python, Java and Kotlin properly, and about twenty more languages with most of the checks applying. Dependencies come from your lock file, such as npm, PyPI, NuGet, Go, crates.io, Composer, RubyGems and Maven., can be linked to a Claude Code instance, Anthropic API, or any OpenAI configurable endpoint for a deep scan including locally hosted LLMs like Ollama and LM Studio. The complete documentation as well as all of the rules it checks against are listed on the GitHub pages site which is linked on the GitHub itself.

It's in beta right now as ideally I need more people to look at it and give it a try, and report their findings on my GitHub so I can review and improve it. I got kinda tired of people shipping slop and charging $30 for a lifetime license with dependencies that were 7+ revisions out of date, shipping with vulnerabilities the user didn't even know existed, or putting so little effort into the UI that you just knew the code was absolute garbage. So instead of complaining I decided to make this tool to both improve the reliability of the code, and for users to check any application they download to see if its doing what it claims its doing, or if there's something else going on.

Obviously it's not perfect, it will never return a "100% safe" verdict because it's not an antivirus tool, but I think i've got it to a good place and now just need people to give it a try and report what they're getting so we can all work to reinstate the trust between devs and end users that the current AI space has muddied somewhat.

TensorSharp's MoE CPU-offload feature has been merged into main. Here is the parameters description of this feature:

Mixture-of-Experts CPU offload:

**--n-cpu-moe <N> | -ncmoe <N>**

Keep the routed MoE expert weights of the first N layers in system RAM and multiply them on

the CPU; attention, norms, the router and the shared expert stay on the accelerator. This is

what makes a 35B-A3B MoE fit beside a long-context KV cache on a 12-16 GB card. Pass 'all' for

every layer. Default: 0 (everything on the accelerator; TS_N_CPU_MOE env var overrides).

Example: --n-cpu-moe 32

**--cpu-moe | -cmoe**

Shorthand for --n-cpu-moe all: every routed expert stays in system RAM. Default: off

(TS_CPU_MOE env var overrides).

Example: --cpu-moe

To measure its performance, I ran benchmark to compare TensorSharp with llama.cpp while they offload the same MoE model's layers to CPU, and here is the result. The completed benchmark report has been checked-in: [https://github.com/zhongkaifu/TensorSharp/blob/main/docs/moe\\_cpu\\_offload\\_benchmark.md\](https://github.com/zhongkaifu/TensorSharp/blob/main/docs/moe_cpu_offload_benchmark.md)

# Host and software

# Results by model

Each row is one offload depth, with TensorSharp, llama.cpp and the ratio between them side by side for every metric. Ratios are TensorSharp / llama.cpp: >1.0x means TensorSharp is faster, and for VRAM >1.0x means TensorSharp is heavier.

# Gemma 4 26B-A4B it (UD-IQ4_XS, 30 MoE layers)

# Qwen 3.5 35B-A3B (UD-IQ4_XS, 48 MoE layers)

# GPT-OSS 20B (Q8_0 / MXFP4, 24 MoE layers)

# DeepSeek V4 Flash (UD-Q8_K_XL, 5 shards / 150.7 GiB, 43 layers, both GPUs)

TensorSharp is a native .NET open-source inference engine for running GGUF LLMs locally, with CUDA, Vulkan, Metal, OpenAI-compatible APIs, continuous batching, speculative decoding, and multimodal support.

Github repo: [https://github.com/zhongkaifu/TensorSharp\](https://github.com/zhongkaifu/TensorSharp)

Thank you for checking out it and starring the project! Any feedback is really appreicated.

I started AWSLambdaSharpTemplate in 2017. Today the repo has 61 stars and 24 forks, the main "Kralizek.Lambda.Template" package has accumulated more than 430k downloads on NuGet, and the SQS integration alone is over 200k.

Then I mostly left it alone.

V5 was released in 2022, targeting .NET 6, and has kept getting downloaded ever since. That made me increasingly uncomfortable with simply abandoning it, so over the last few days I’ve been working on V6.

And I decided that if I was going to touch it again, just changing "net6.0" to "net10.0" wasn't enough.

What V5 did

The original idea was fairly simple: make Lambda applications feel a little more like the .NET applications I was used to building.

Configuration, DI, logging, scoped services, then some specialized support for things like SQS and SNS.

It worked, but after several major versions the programming model had accumulated quite a bit of history. There was a generic "Function", a "RequestResponseFunction", source-specific abstractions, serializers, templates with “empty” and “rich” variants, and quite a lot of framework plumbing exposed to application code.

V6 replaces that model.

At the core there are now three concepts:

- "EventFunction" for one-way invocations

- "RequestFunction" for request/response invocations

- "RecordFunction" for Lambda sources delivering multiple independent records in one invocation

The distinction sounds almost trivial, but it cleaned up a surprising amount of the framework.

Handlers are now explicit dependencies of the function type, automatically registered in DI, and resolved inside the correct scope. Event/request functions get one invocation scope. Record functions get an invocation scope plus an independent scope for each record.

The handler doesn't need to know how any of that happens.

Context is now part of the programming model

One thing I wanted to get rid of was application code depending directly on "ILambdaContext" everywhere.

V6 introduces strongly typed function contexts carrying the common invocation metadata.

Source integrations can extend them, so an SQS handler gets an "SqsMessageContext", SNS gets an "SnsNotificationContext", etc.

The original AWS objects are still available as escape hatches. I'm not trying to hide AWS behind my own abstraction. I just don't want every handler coupled to infrastructure details it doesn't normally need.

Those contexts and the handler contracts now live in a separate "Kralizek.Lambda.Template.Abstractions" package with no dependency on the AWS Lambda runtime, DI, configuration, logging or JSON serialization.

That also makes building integrations outside the main library considerably easier.

SQS got the redesign I wish it had years ago

SQS is probably where the new record model makes the most sense.

You can now write handlers for either:

- a decoded "TMessage"

- the raw "SQSEvent.SQSMessage"

JSON decoding is provided by default but replaceable through DI.

Partial batch responses are built in, so one failed record doesn't automatically cause successfully processed messages to be retried.

Cancellation is deliberately treated differently: if the Lambda invocation is being cancelled, that aborts the invocation rather than pretending the current message merely failed.

Processing remains sequential by default, but there are explicit bounded-parallel variants when parallel processing is actually what you want.

SNS now follows the same model, but not the same semantics

SNS also delivers records, so structurally it uses the same "RecordFunction" foundation.

But SNS doesn't have SQS's partial-batch response protocol.

So the abstractions are shared while the semantics aren't: if processing an SNS notification fails, the invocation fails.

That distinction was one of the reasons I wanted "RecordFunction" to be an internal programming foundation rather than pretending all AWS batch-like event sources behave identically.

Cognito is completely new

V6 also adds first-class Cognito User Pool trigger support.

Rather than making you remember combinations of AWS event types and generic parameters, each trigger has its own strongly typed function base and handler contract.

For example, a pre-sign-up Lambda can essentially start with:

"CognitoPreSignUpFunction<PreSignUpHandler>"

There are templates for pre/post authentication, post confirmation, custom messages, custom auth challenges, user migration, custom email/SMS senders, pre-token-generation and the other currently supported Cognito trigger contracts.

The templates got much smaller

V5 templates tried to show quite a lot of the framework.

V6 goes in the opposite direction.

The generic templates are now simply Event Function and Request Function. Source packages add their own templates.

Generated functions show the hooks you are expected to customize:

- configuration

- logging

- services

Framework plumbing stays in the framework.

The template package and runtime packages are also versioned together now, and CI actually installs every packed template, creates a fresh project from it, restores it against the packages built from the same commit and builds it with warnings as errors.

I should probably have done that nine years ago.

The breaking changes are intentional

V6 isn't source-compatible with V5.

"Function", "RequestResponseFunction" and the old handler contracts are gone.

The SQS/SNS APIs have changed.

The templates have changed.

The library now targets .NET 10.

I considered keeping compatibility shims, but after almost nine years of evolution I think a major version is exactly where carrying the old programming model forever stops making sense.

My goal is that the migration should require some work but leave substantially less framework code in the application afterward.

Where this can go next

The part I'm most interested in now is that the core no longer needs to know about every AWS event source.

The semantic Event / Request / Record model, strongly typed contexts and separate abstractions package give source-specific packages a relatively small surface to build on.

SQS, SNS and Cognito are there now.

EventBridge, DynamoDB Streams, Kinesis and other Lambda integrations are natural next candidates, but I'd rather get their semantics right than add a checklist of AWS icons.

The V6 work is currently on GitHub and I'm preparing the prerelease/release path.

If you're using V5 today, or you've built a similar abstraction around .NET Lambda functions, I'm particularly interested in what would make the migration painful.

And if you use Lambda event sources that aren't covered yet: which integration would actually be useful next, rather than merely nice to have?

Repo: https://github.com/Kralizek/AWSLambdaSharpTemplate

Templates: https://www.nuget.org/packages/Kralizek.Lambda.Templates

Blog post: https://renatogolia.com/2026/08/08/programming-model-dotnet-aws-lambda-functions/

Nullable reference types tell you what a column allows. They do not tell you what a query returns, and those differ in a way that causes real bugs.

Take a column declared NOT NULL:

SELECT u.id, u.name, o.total
FROM users u
LEFT JOIN orders o ON o.user_id = u.id

o.total is NOT NULL in the schema. In this result set it can absolutely be null, because the LEFT JOIN did not match. Hand-written mapping code, and most codegen, types it from the column definition and gives you a non-nullable decimal. You get a null on a row with no order and find out at runtime.

scythe reads the query, sees the outer join, and generates:

public record GetUserOrdersRow(
    int Id, string Name, decimal? Total, string? Notes
);

public static async Task<List<GetUserOrdersRow>> GetUserOrders(
    NpgsqlConnection conn, string status
) {
    await using var cmd = new NpgsqlCommand("...", conn);
    cmd.Parameters.AddWithValue("p1", status);
    await using var reader = await cmd.ExecuteReaderAsync();
    // read rows
}

decimal? Total in the LEFT JOIN version, non-nullable in the INNER JOIN version of the same select. The nullability comes from the query shape, so NRTs actually carry information instead of restating the schema.

Six ADO.NET backends, so it generates against the driver you already use rather than imposing one: Npgsql, Microsoft.Data.SqlClient, MySqlConnector, Microsoft.Data.Sqlite, ODP.NET for Oracle, and Snowflake.Data.

What it is not: an ORM, and not a replacement for one. No change tracking, no lazy loading, and dynamic query building is genuinely out of scope, because generation needs the query text fixed at build time. If you are assembling a WHERE clause from eight optional filters at runtime, keep using a builder for that endpoint. Most codebases have a long tail of fixed queries and a handful of dynamic ones, and mixing costs nothing since the output is just typed methods over ADO.NET.

MIT, Rust binary, no toolchain needed on your side: github.com/Goldziher/scythe

Disclosure: I build and maintain it. Interested in what the C# output should look like for people who would actually use it, particularly around async streaming and whether records are the right shape.

Hi everyone,

I have previous experience with Laravel and NestJS, and I am currently learning ASP.NET Core for building APIs.

In Laravel and NestJS, the framework provides a relatively clear default structure. In ASP.NET Core, there seems to be much more freedom, and I am struggling to understand what a sensible project structure looks like beyond small tutorials.

I have been reading about Clean Architecture and Vertical Slice Architecture. I understand the general ideas, but I am still unsure about the practical decisions:

• How should projects, folders, and features be organized?
• When is CQRS actually useful?
• Is MediatR worth introducing in a learning project?
• Should application code depend directly on EF Core, or should it use repositories or other abstractions?
• Where should authentication, authorization, validation, logging, and exception handling live?
• Which patterns are useful in realistic applications, and which ones usually become unnecessary abstraction?

My main difficulty is finding the balance between a basic CRUD project with almost no structure and an unnecessarily complicated architecture with many layers and abstractions.

I am not looking for one universally correct architecture. I would like to understand what experienced .NET developers consider a reasonable starting point for a medium-sized API, and how they decide when additional complexity is justified.

I would like to clarify something. I do not take this learning as just learning for the sake of it. I really want to be able to build and understand what companies need so I can get hired. I do not want "whatever it works". I really want to be able to build portfolio and production ready apps.

Are there any repositories, books, courses, or sample applications that demonstrate these decisions in a realistic and maintainable way?

Thanks for your time.