Official statement from the .NET Foundation on Open Source Maintenance Fees

TL;DR: I/O-heavy .NET API (FFmpeg + Testcontainers + Rider). Already tested Dev Drive and WSL2; both choke memory/speed on a soldered 32GB laptop. Bare-metal Ubuntu runs circles around both. Looking for deep Windows tuning insights or confirmation to stick with native Linux, despite preferring Windows user experience.

Hi all,

I’m developing an API that processes and serves multimedia content to client devices. It’s built on modern .NET (.NET 10, ASP.NET Core, EF Core + Postgres, Hangfire, and FFmpeg for media validation).

I'm currently on a 32GB Windows laptop (AMD Ryzen 8845HS with soldered RAM, so no upgrades possible) using JetBrains Rider. Because the backend involves heavy filesystem I/O, process spawning (FFmpeg), and integration testing with Testcontainers, I've hit some serious performance and memory bottlenecks on Windows.
Here is what I’ve tested so far:
Native Windows 11:
I’ve set up a dev drive and added full Defender exclusions for code/build directories. Filesystem operations and FFmpeg process invocation still feel noticeably sluggish compared to Unix. Tests take quite a while longer because of this

WSL2 (Podman / Remote Dev):
I/O is faster inside the virtual disk, but running Rider via Remote Development / Gateway or crossing the ⁠\\wsl$⁠ boundary consumes massive amounts of RAM and feels laggy. Along with Chrome, Testcontainers, and Rider, it quickly saturates the 32GB ceiling.

Dual-Boot Ubuntu 26.04 (Bare Metal):
Dual-booted on a secondary SSD, and the performance difference is night and day. Native Podman has zero VM memory overhead, test runs are dramatically faster, and it matches our Ubuntu 24.04 production environment 1:1.

Windows still has the edge for general desktop/hardware polish and daily ergonomics though, it plays a lot nicer with my dock and input devices (Logitech MX Keys and MX Master 4) as well as display scaling.

For those running I/O-heavy .NET workloads and containerized tests:

1. Are there any non-obvious Windows/WSL2 tuning tricks for Testcontainers and high-churn disk I/O that make it truly competitive with bare-metal Linux?
2. Or is bare-metal Linux (or macOS) simply the pragmatic path once an app is reliant on containers and I/O for testing?

Would love to hear how others balance this on 32GB machines.

Currently, writing my bachelor's thesis on development practices and software architecture, a lot of good general resources, but all the ones for dotnet seem extremely clickbaity or seem to use an illogical structure for the purpose of the application ie clean architecture for a to-do app without ever explaining why.

I am not nearly experienced and well-read enough to go into detail about a specific aspect in my thesis. The topic is intentionally broad, because I want to learn the general picture of mapping out the process of software design and deployment in the real world. I've only dipped my toe nail in this kind of thing during my internship where I worked on a small project using clean architecture and the why's and how's really interested me, so both my mentors(boss and thesis mentor) suggested this topic.

So the general thesis concept would be: "client has X problem, what design principles, architecture, code organization, etc do you choose depending on their requirements"

Also, there might be cultural(?) confusion regarding writing a thesis about something you don't know about, but in my country all university students need to write a thesis to graduate, so the threshold is far lower for our paper's, than other countries(I'm assuming at least), it's very common to just copy/paste documentation from frameworks you used for a personal project and be done with it for a thesis.

Hi,
I am seeing the warning that `LogInformation` and other log methods evaluation is expensive and should be wrapped in `if` statement.

Why don't those methods do this check internally already? This would help with less code and better code readabilty I think.

Here is the example:

https://preview.redd.it/maffgqy8qakh1.png?width=705&format=png&auto=webp&s=099656d48dc09e4a71e2deec9c61cd419fbcd24f

Ok this has been bugging me for a while. I let the AI write tests, everything's green, coverage looks great... and I still don't trust any of it lol. Because the test just asserts whatever the code already does. If there's a bug in there, the test just locks it in and moves on like nothing happened.

Like, 100% coverage means nothing if the assertions are garbage, right? The only thing that actually matters is whether the test fails when the code is wrong. And nobody's sitting there checking that by hand for a wall of generated tests.

So I started messing with mutation testing for this. Basically you break the code on purpose and see if the test notices. Doesn't notice? The test is useless, toss it.

Ended up wrapping it into a little .NET tool. FsCheck for the properties, Stryker.NET does the mutation. The LLM proposes stuff, then it gets filtered pretty hard: anything that fails on working code gets dropped, anything that survives a mutant gets dropped too. You only keep what actually killed something.

Ran it on a real CliWrap commit just so I wasn't fooling myself: 2 proposed, 1 kept (with the mutant it caught), 1 thrown out for killing zero mutants. Honestly the throwing-out part is the whole point, I'd rather it show me nothing than hand me a test that does nothing.

Not gonna pretend it's some genius original thing btw. Meta does this propose-then-refute loop internally and Mutahunter is an open source take on it. Mine just does properties instead of examples, and the LLM never gets to be the judge, all the yes/no stuff is deterministic.

Anyway, mostly just curious: does anyone here actually do this in CI? Or are you all kinda just vibing and hoping the generated tests are fine lol.

I’m currently building an e-commerce backend using ASP.NET Core and looking for good resources to help me in the project .

Like I have done a project , a really small one , but it was done using a tutorial video on YouTube. so that's why I need help with resources like a GitHub repo that may help me understand stuff better and build a project on my own .

Hey everyone 👋

I’ve been working on a personal project called WEBZONEBW.in, and I thought I’d finally share it here and get some real feedback.

Basically, I’m trying to turn it into more than just a normal portfolio. It’s becoming a kind of personal tech workspace where I can bring together my IT/networking experience, web development projects, cybersecurity work, AI experiments, useful tools, and things I’m currently learning or building.

I’ve been adding and changing things as I go, so it’s definitely still a work in progress.

What I’d really like feedback on

If you have a few minutes to look around, I’d be interested to know:

• Does the site structure make sense?
• Are the projects explained clearly?
• Does it feel like an actual technology workspace or just another portfolio?
• How does it feel on mobile?
• Is anything confusing or unnecessary?
• What would you personally add?

🛠️ Explore the services & projects

I’ve also started putting some of the services, technical solutions, tools, and project ideas into the blog, so they’re easier to explore instead of just having everything sitting on one page.

The blog is where I’m planning to explain things in a little more detail — what a service does, who it could be useful for, how the technology works, and some of the projects behind it.

👉 Website: https://webzonebw.in
👉 Blog: https://webzonebw.in/p/blog.html

I’m not really looking for a bunch of “looks great!” comments 😅

Tell me what you think actually needs work.

If you were building this from scratch, what would you change or add?

I've been running .NET 10 in a couple of side projects since the LTS drop. When it launched I assumed that the big C# 14 win for me would be extension members. It's nice but the feature that I actually ended up using the most is turned out to be the boring one: the field keyword.

Every time I needed a little validation in a property, I used to write the full backing-field:

Before (C# 13):

private string _name;
public string Name
{
    get => _name;
    set => _name = value?.Trim()
        ?? throw new ArgumentNullException(nameof(value));
}

After (C# 14):

public string Name
{
    get;
    set => field = value?.Trim()
        ?? throw new ArgumentNullException(nameof(value));
}

No hand-declared _name. Tiny change, but it shows up multiple places, which is exactly why it wins.

The other one which impressed the most is the file-based apps which quietly replaced half of my throwaway scripts:

Before:

mkdir tool && cd tool
dotnet new console
// edit Program.cs + csproj, then:
dotnet run

After:

// tool.cs — no project, no folder
Console.WriteLine("Just run me.");

dotnet run tool.cs

Type-safe code with the full BCL and zero .csproj turned out to be more useful than I expected.

So I'm curious where everyone actually landed:

• Which C# 14 feature earned a permanent spot in your muscle memory, and which turned out to be a demo-only feature?
• Anyone using extension members from C# 14 in real code yet, or still letting it settle?
• And for the folks still on .NET 8 what's holding up the jump to 10?

I have been thing what should I choose for backend as i want to become a full stack engineer. I just completed js and React in frontend . I am confused between java+spring boot or .Net . I will learn python as well .

What's your opinion ? What will be better option for me ?

Microsoft is really shooting itself in the foot with a lot of the really high-profile people, like Jeff Fritz. I watch Jeff’s Twitch streams all the time, and it’s always great content.

I’m even hearing less and less from the two Scotts online. Scott Hanselman still has his podcast, for sure, but the only really high-profile .NET guy we seem to see now is Dan Roth, especially within the Blazor community.
I see James has jumped teams again, now doing Visual Studio Code material on YouTube and TikTok.

I get that employees move teams and new, talented people join. It’s just sad nonetheless. We never hear from Maddy anymore, and .NET and .NET Conf have had very poor-quality content over the last few years.

Title.

Do you mock out that OAuth handling? Or do you actually use one of the test Auth servers. If so, does your resource server have its own client credentials just for running integration tests?

I am new to a team that have selected CSharpier and I do not like it at all. Not because it is a style that I do not use but that is tooooo rigid. You cant customise it.
And this makes developers stop caring about how they write code. It's too much trouble to format code differently when it is needed, and it's too easy to forget to add csharpier-ignore.

Writing code is art, you need to manage code like a painting and everything needs to fit together.

This is a lot harder with a rigid formater.

I don't even need to say that the code in this new team is... how do I put it? Not good.

.NET shop looking to add some agentic workflows and chat interfaces to platform, currently researching framework options so we don’t have to build the thing from scratch.

Being a .NET shop MAF has come up. Hooked it up to GitHub CoPilot and took it for a quick spin, wasn’t too verbose and conceptually maps to tools like OpenCode pretty well.

Saw some posts on here about it a while ago but things seem to be moving really fast in this space. Looking for opinions on the viability of this framework? I see it had a 1.0 launch in April, it’s meant to supersede both Semantic Kernel and AutoGen.

Are the team behind it any good / trustworthy?

How likely is it to remain supported?

Has there been much community participation / extension?

How does it compare to similar frameworks in other languages, LangChain/Graph being an obvious one?

Is it good enough to prevent you from hopping languages or is python where it’s really at?

Any useful information is guaranteed at least one updoot, thanks in advance!

https://github.com/fullbleed-engine/fullbleed-dotnet

dotnet bindings for the rust html/css to pdf engine, Fullbleed. MIT, free, open source, and quite fast if I do say so myself!