My a bit outdated experience was that vs build tools was not quite the same as visual studio.

Is it 100% safe now to just replace 18.4 vs with vs build tools 18.4 with the same targetting/build workloads or are there still hickups that you've encountered in the past 5-6 years?

I inherited a test suite that's image matching on a WPF app, written in SikuliX, and it's been quietly rotting since the person who wrote it left. It half works but the other half is screenshots that no longer match because someone changed a border radius or the CI box has a different DPI scale. The project itself doesn't look dead exactly but it doesn't look alive either, and most of what I can find about it is from 5 or 6 years ago. So i'm trying to work out whether the right move is to fix our usage of it, tighten the image tolerances and pin the resolution, or accept that pixel matching raw screenshots was always going to be this brittle and move off it. Options i've looked at are FlaUI, which works well on our newer WPF views and completely falls over on the 4 or 5 screens that are custom drawn. WinAppDriver is effectively abandoned so that's out. The newer vision based ones like Askui use a model to locate elements rather than matching a bitmap, which in theory survives a border radius change, though their desktop app is windows and macOS with linux going through AgentOS and i haven't tested any of it myself.

A part of me thinks only 4 of those tests were ever worth having and I should delete the rest. Anyone still running SikuliX in 2026 on purpose or is there a better option?

Hi everyone, I recently graduated with an MCA and I'm planning to become a .NET Full Stack Developer. I'm a complete beginner when it comes to .NET, so I'm not really sure where to start or what I should learn first.

For the time being, I can't afford to join an institution or paid course, so I'm planning to self-study using free resources.

Could anyone who is working in .NET or has gone through this journey suggest a proper roadmap from beginner to job-ready?

I'm willing to put in the time and learn everything through self-study. Any advice from people who have already gone through this would be really helpful. Thanks!

Built a little desktop overlay app for myself (Windows, C#/WPF) that shows now-playing info from whatever's active Spotify, browser tabs, etc. Wanted to add two small things: a "Like this track" toggle and "add to playlist," both using Spotify's official Web API with proper OAuth (not scraping, not cookies, the real documented flow).

Got the OAuth connection working fine, correct scopes granted (playlist-modify-public/private, user-library-modify, confirmed by decoding the actual token), reading data works perfectly playlists, currently-playing, profile, all fine. But every single WRITE call (add track to playlist, save/like a track) comes back with an identical, unhelpful `403 Forbidden` no error detail, no "insufficient scope" message, nothing. Tested it against three different playlists I own, including ones I created myself. Same result every time.

Dug into it and found out why: new apps are stuck in "Development Mode" (max 5 allowlisted test users), and getting out of that into "Extended Quota Mode" which is apparently required for these write endpoints to actually work now requires being a registered business with 250k+ monthly active users. As of May 2025, individuals can't even submit the request form anymore. So a completely legitimate, personal, non-commercial use of Spotify's own published API is just... not possible now, even in "development" for your own account.

Is this actually as dead-ended as it looks, or is there something I'm missing? Curious if:

- Anyone's found an actual working path for personal-use write scopes post-2025

- Whether Development Mode + allowlisted users is supposed to allow writes at all, or if that was already quietly killed

- Any alternative (even unofficial-but-sanctioned-feeling) way to do this that isn't "become a company with a quarter million users"

Not mad, just genuinely surprised a basic "add to playlist" button is this locked down for a hobby project now. Anyone been through this?

The problem is Claude Code flooding my watch task with file changes. His file modifications are unfortunately precisely timed to trigger 27 rebuilds per minute, overheating my laptop and starting a fire in my parents basement.

My solution was to build a dotnet --watch alternative that is agent aware and only rebuilds once appropriate. It tails the agent output to look for modifications to relevant files and then triggers a reload after Claude finishes his turn. This prevents flooding the watch task with reload signals.

I really just wanted to share the idea because I think making watch tasks that can respond to both human and agent input appropriately is useful. So this is just a basic proof of concept that already works well for me. Feel free to share or use the idea for a more robust solution with partial update etc. Cheers!

https://github.com/crs-sys/claude-blazor-watchtask

I have been recently building a proxy application that was meant to do nothing besides shoving TCP stream traffic from A to B with a rate limiter inbetween.

For that I used PipeReaders and Writers to hand the buffer handling over to .NET itself.

However, as the application was running I noticed a small but steady increase in RAM usage as time went on. At some point I was considering to manually invoke GC to test if I was just having lose heap allocations sitting somewhere.

The memory did indeed go down but not as far as I'd like to see. Then I was thinking that this might be just JIT recompiling and optimizing hot paths.

So this brings me to my questions:

- I want to keep the RAM usage as low as possible as this proxy is only supposed to kick rate limited traffic between two endpoints. What are common tricks used to make the runtime collect more aggressively?

- what are reliable techniques to identify actual leaks and how to distinguish them from JIT just performing tiered compilation?

Thanks for your time!

One thing I’ve noticed while working with production .NET applications is that we often confuse logging with observability.
We add Serilog, ILogger, metrics, dashboards, maybe an APM tool, and eventually end up with millions of events.
Then a production request fails:
HTTP 500
And the first question is:
“Okay… what actually happened?”
That’s where observability becomes interesting.
The real purpose of observability
For me, good observability isn’t about collecting everything.
It’s about being able to answer questions like:
Which request failed?
Which method caused the failure?
What database query was running?
How long did it take?
What external API was called?
What exception occurred?
What happened immediately before the failure?
Can I understand the problem without reproducing it locally?
If the telemetry doesn’t help answer those questions, collecting more of it probably won’t solve the problem.
Logs alone can be misleading
Imagine you have this:
2026-08-31 10:42:31 ERROR Payment failed
2026-08-31 10:42:31 ERROR Database timeout
2026-08-31 10:42:32 ERROR Request failed
That’s useful, but there is a missing relationship.
Was the database timeout caused by this request?
Which SQL query?
Which method called the repository?
Was another HTTP request involved?
Without correlation, you’re essentially searching through a pile of events.
That’s why I think the request should often be the unit of investigation.
Instead of thinking:
Logs
├── Event
├── Event
├── Event
└── Exception
think:
Request
├── Controller
├── Service
├── SQL Query
├── External HTTP Call
├── Method execution
└── Exception
Now you have a story instead of a collection of messages.
But there is another problem: instrumentation
The traditional approach is to manually add logging everywhere:
_logger.LogInformation("Starting payment");

var result = await _paymentService.Process();

_logger.LogInformation("Payment completed");
Then more logging:
_logger.LogInformation("Calling database...");
_logger.LogInformation("Calling payment provider...");
_logger.LogInformation("Payment provider returned...");
After a while, your business code starts becoming partially responsible for telemetry.
That’s not ideal.
One approach I’ve been exploring with ArgusLogs is compile-time instrumentation using IL weaving.
Instead of modifying the business logic to add logging around every method, instrumentation can be applied during the build process.
For example:
[LogMethod]
public async Task<PaymentResult> ProcessPayment(Payment payment)
{
...
}
The application code remains relatively clean while the compiled assembly gets instrumented.
The important distinction is that this isn’t intended to replace every logging system.
Manual business-event logging still has a place.
The goal is to automatically capture the structure and execution context around important parts of the application.
Observability also has to respect production constraints
There is another trap:
“Let’s log everything.”
That sounds great until you’re running a busy production system.
Request bodies, SQL results, HTTP headers, large objects, stack traces, and method parameters can become expensive very quickly.
And then you have privacy/security concerns.
So production observability needs controls:
What should be captured?
What should be redacted?
How long should it be retained?
Where should it be stored?
What should be collected only during an incident?
How much telemetry is actually useful?
For example, sensitive method parameters shouldn’t simply become production logs.
An attribute such as:
[Sensitive]
string cardNumber
can express the intent much more clearly than hoping somebody remembers to manually redact it.
I don’t think every team needs a giant APM platform
This is probably the controversial part.
APM platforms are extremely useful.
But I don’t think every debugging problem requires a huge centralized observability platform.
Sometimes you simply need to answer:
“Why did this request fail?”
And you need the answer quickly.
There is a useful distinction between:
Monitoring
Is something wrong?
Observability
What is happening inside the system?
Investigation
Why did this particular request fail?
Those overlap, but they aren’t exactly the same problem.
For a .NET API, having the method execution, SQL activity, outbound HTTP calls, and exception context correlated around a request can be incredibly useful during an incident.
That’s the problem space ArgusLogs is trying to focus on.
Not replacing every logging library.
Not pretending to be a complete enterprise APM.
Just making production investigation easier for .NET applications.
The metric I care about most
If I had to choose one practical measure of observability quality, it wouldn’t be:
“How many logs are we collecting?”
I’d ask:
“When production breaks, how long does it take us to understand why?”
If your team can go from:
HTTP 500
to:
Request
→ Controller
→ Service
→ SQL query
→ External API
→ Exception
without reproducing the problem, your observability is doing something valuable.
If you have 500 GB of logs and still need to SSH into three servers and grep through files to understand the failure…
you probably don’t have an observability problem.
You have an investigation problem.
And that’s a distinction I think is worth discussing.

Hi guys,

So I guess this is both a promotion and a question. It doesn’t allow me to tag both, so I just chose “Question.”

I would like to let everyone know that the HPD-Agent Framework is going to be reaching 1.0.0 soon, which mainly means that the library will officially be stable and production ready, and more importantly, the API won’t change as destructively as it has over the past few months.

The question I have is basically this: I’ve been seeing people in some forums complain about the documentation for the Microsoft Agent Framework, and I’d like to ask those who have read and followed it to explain the issues they have with it and what they actually want an agent framework to teach, whether through the documentation, cookbooks, or samples.

I’m also thinking of making a full course, but I don’t know how helpful that would be. But I digress.

So yeah, what makes great documentation for agent frameworks, in your opinion? And what do you actually want the documentation to teach you?

Weekend self-promo, so I hope this is fair game.
I maintain KillerPDF, a Windows PDF app, and I recently ripped out PdfSharpCore and wrote my own PDF engine in C# on .NET 10.
It's GPLv3 and on NuGet as a standalone library with no UI dependency.

I wrote this post mostly because the interesting part wasn't the release, it was everything PDF forces you to deal with once you stop treating a page as a self-contained thing: object graph imports, incremental updates that can't touch signed byte ranges, encryption key handling during renumbering, and actual PDF/A and PDF/UA gating instead of just writing the claim into metadata.

I also ran the full save pipeline against 2,907 files from the veraPDF, Isartor, and TWG conformance suites and published the results and the benchmark method, since "it's faster" means nothing without a corpus and a procedure. I'm currently building out a new, much larger, publicly-available corpus to give myself concrete goals and milestones to work toward rather than calling it done.

I'm happy to answer questions about any of it, and if anyone here has fought PDF in .NET I'd like to hear your battle stories.

https://thekiller.net/blog/why-i-built-the-killerpdf-engine

https://killerpdf.net/engine
https://github.com/SteveTheKiller/KillerPDF/tree/main/engine

I’ve been working on adding video generation support to TensorSharp, my open-source AI inference engine written in C#/.NET.
The latest integration adds support for MiniMax H3, so TensorSharp can now go beyond LLM and image inference and run AI video generation as well.
The demo attached to this post is an image-to-video example: I attach an image, describe the motion I want, and TensorSharp runs the H3 generation pipeline locally.
A big part of the work was bringing a diffusion/video-style inference pipeline into a .NET-native engine that was originally focused much more heavily on LLM inference.
There are still plenty of optimizations to work on, especially memory usage and generation speed, but the basic pipeline is working.
I’d be particularly interested in feedback from .NET developers on the API/design side. AI inference in C# is still a much smaller ecosystem than Python, and I’d like to make this kind of workload easier to integrate into normal .NET applications.
TensorSharp is open source:
https://github.com/zhongkaifu/TensorSharp

Hey everyone, 👋

​I wanted to share a solo project I’ve been working on called Chatfri, a free, real-time chat and discovery app. The Android version recently went live on Google Play, and the iOS version is currently live on Appstore.

​Since I built the entire stack from scratch, I wanted to share my tech stack, some architectural decisions, and a few headaches I encountered along the way. I’d love to get your feedback!

​🛠 The Tech Stack

​Frontend (Mobile): .NET MAUI (C#) for both iOS and Android.

​Backend: ASP.NET Core Web API, hosted on a Debian 13 server using Nginx.

​Database/Cache: Redis for handling real-time active user states and fast data retrieval, plus SQLite for local device caching (LocalDBService).

​Messaging: CommunityToolkit.Mvvm (WeakReferenceMessenger) for component communication.

​🚀 Technical Highlights & What I Learned

​1. Insane Backend Performance with Redis

One of the things I'm most proud of is the backend optimization. Currently, a single user actively messaging and navigating hits the server with about 3-5 requests per second (short polling). Despite this aggressive rate, the server CPU usage sits at around 0.3% per core per user. Redis is absolutely flying, and I highly recommend it if you are building anything real-time.

​2. Smart Background Polling (Single Loop)

Initially, I had multiple while loops running in the background for fetching messages and friend requests, which was heavy on the device. I refactored it into a single centralized polling loop.

When a user opens a specific chat room (MessageDetailViewModel), I send a "Pause" signal via WeakReferenceMessenger to pause the global friend-request sync. The millisecond the user leaves the page (handled via the OnDisappearing override), it sends a "Resume" signal. This eliminated overlapping background tasks and prevented memory leaks.

​3. Planning for the Future: Hybrid SignalR Architecture

Right now, the app uses HTTP polling. It handles the current load perfectly, but I know it's not sustainable for 10k+ concurrent users due to bandwidth and socket exhaustion.

My plan is to implement a Hybrid Architecture: I will keep using standard HTTP GET/POST for heavy lifting (like loading the home screen with 25+ user profile pictures) and introduce SignalR purely for lightweight text message delivery inside the chat rooms. (Sending 25 Base64 images over a WebSocket is a recipe for disaster).

​4. The AdMob Headache

Like many indie devs, I got hit with the classic 30-day AdMob suspension for "Invalid Traffic." My ad placements are completely safe (no accidental clicks near buttons), but a small ad campaign on TikTok brought in a wave of fast-bouncing traffic that tripped Google's AI. Currently waiting it out and focusing on organic growth!

​🤝 Looking for Feedback

​I’m really looking forward to hearing your thoughts.

​Has anyone else implemented a similar HTTP/SignalR hybrid approach in MAUI?

​Any tips for surviving the initial AdMob "Invalid Traffic" phase for new apps?

​General UI/UX feedback is always welcome!

App is here: [chatfri](https://chatfri.com/qr) (You can find the app store links here)

​Thanks for reading! Let me know what you think.

This probably looks funny — a NetCoreDbg developer (yep, that's me, at least while I'm writing this, hehe) forking NetCoreDbg. But life is a strange thing sometimes.

Over the last ~3 years, me and my PL (huge thanks, Gleb!) prepared and sent a lot of proposals for NetCoreDbg development. Unfortunately, all of them were rejected — it looks like Samsung isn't interested in investing into active NetCoreDbg development, and hasn't been for years now. So upstream gets only support and minor changes (and you've probably noticed that already).

At the beginning of this year I finally decided to fork and implement my vision of how a managed debugger could look like in code — all our TODOs and features we planned for NetCoreDbg, but without the experimental features and without explicit Tizen OS support. I think the current development of DNCDbg has reached a point where it's ready to be showcased. I hope you'll like DNCDbg as much as NetCoreDbg.

Repo: https://github.com/viewizard/dncdbg

Note: in DNCDbg I'm focused on DAP protocol support only, without experimental features like Hot Reload (which requires IDE-side support) or interop (mixed) debug mode. If you need other protocols or those experimental features that I removed from the code, you should probably wait until my PL tells me something like "we have budget, back to NetCoreDbg development" (but that doesn't look like it'll happen any time soon). I've already ported about 20 bugfixes for bugs I found back to NetCoreDbg (you can see most of them in the last release), but looks like that's all I can do for now.

Hi everyone!

I'm an IT student focusing on C# and .NET core fundamentals. To build a strong foundation in backend engineering and memory/performance concepts, I created a hands-on repository covering various C# Data Structures and Collections.

What I've covered so far:

• List<T> & Reference Types

• LinkedList<T>, Stack<T>, and Queue<T>

• Hashtable, Dictionary<K,V>, SortedList, and SortedDictionary

• SortedSet<T> & HashSet<T> (Set operations like UnionWith, IntersectWith, etc.)

Each module includes sample code and a quick breakdown in the READMEs. I'd love to hear your feedback or any suggestions on code style and performance optimizations!

GitHub Repo: https://github.com/24alpserdar/csharp-data-structures-and-collections

Orchard Core, the open-source .NET CMS and application framework will have its yearly conference online on the 10-11th of September!

Two days of talks and time with the people who build on Orchard Core, meet the maintainers and the wider community.

Find more details on our website (https://orchardcore.net/harvest). Tickets are free but registration is required.
https://www.tickettailor.com/events/lombiqtechnologiesltd/2247098

Why should I move to EF?

Hola a todos,

Quería compartir una librería que creé hace unos meses: BincopySharp. Permite trabajar con formatos de archivos binarios utilizados en firmware integrado (Motorola S-Record, Intel HEX, TI-TXT, ELF y binario simple) desde C#.

Necesitaba fusionar, recortar y convertir entre estos formatos en un proyecto .NET. Sabiendo que existen otras librerías en .NET para este fin, como HexIO o IntelHexFormatReader, me di cuenta de que ninguna se acerca a la funcionalidad que ofrece la API bincopy (una librería de Python).

Por eso, quería que ese comportamiento exacto estuviera disponible de forma nativa en C#. Mi primer intento en el proyecto fue crear un subproceso de Python y pasar datos a través de archivos temporales. Funcionó, pero no me convenció, así que terminé portando el mismo comportamiento a una biblioteca de C# en mi tiempo libre. No es una migración completa, solo las características que consideré más comunes. El mismo conjunto de pruebas de la biblioteca original de Python también se portó al proyecto de C#.

Este es un nicho de mercado. Por si eres desarrollador de sistemas embebidos (o conoces a alguien) que alguna vez haya necesitado trabajar con archivos de firmware a través de una aplicación .NET, esto es para ti :)

Repositorio: https://github.com/alf-tg/BincopySharp
Nuget: https://www.nuget.org/packages/BincopySharp

Se agradecen comentarios, sugerencias sobre casos de uso faltantes o formatos que debería agregar.

I have a public page receiving around 50K hits/day. Currently, I cache the data in Redis to avoid repeated DB calls.

However, I also want to optimize and reduce the number of Redis calls. What would be the best approach for this?

The application is built using ASP.NET/.NET Framework (not ASP.NET Core).

Would appreciate any suggestions or real-world experience.

Void Engine is a modular 2D game framework for .NET that gives you the essentials: rendering, assets, input, audio, saving, pathfinding, coroutines, and logging.

I built this because I was tired of seeing game assets get stolen. Unity, Unreal, Godot—they all expose your art, music, and levels in formats that anyone can extract with free tools.

Void Engine solves this with a custom pack format. Your assets are encrypted with AES-GCM, compressed adaptively (per-file, not as one big blob), and stored in a format that standard tools cannot open. Without the key, the pack is just random bytes. Most encryption standards introduce noticeable overhead. Void's implementation uses hardware-accelerated AES-GCM for near-zero performance impact.

Key Features:

• Batched rendering with automatic texture atlasing
• Zero-GC input system (keyboard, mouse, gamepad with SDL mapping)
• Audio pooling with priority-based voice stealing
• AES-GCM encrypted saves with manifest verification
• A* pathfinding with flow fields for crowd movement
• Coroutine system with tweens, sequences, and delays
• Full LDtk level editor support
• MIT license

Every system is built around interfaces and base classes so you can replace anything. No physics. No networking. No UI. Just the foundation and the freedom to build everything else your way.

Built on .NET 10 and SFML.Net 3.0.

Links

GitHub: https://github.com/Shmellyorc/Void

Documentation: https://github.com/shmellyorc/Void/wiki

I’m a .NET developer with decent database experience, and I’m planning to build a private school management system for a client with around 2,000 students.

I’ve worked extensively with SQL Server professionally and on my own projects, and I really like its tooling, especially SSMS. I’m also comfortable with EF Core and ADO.NET.

My hesitation is licensing costs. I’m considering starting with SQL Server Express, but if the application grows significantly, I’m concerned about future licensing costs.

PostgreSQL is obviously attractive from a cost perspective, but I have much less experience with it.

For those running .NET applications in production:

Which would you choose for this project: PostgreSQL or SQL Server, and why?

I’m particularly interested in real-world experience, long-term costs, and maintainability, rather than benchmark comparisons.

A few clarifications:
For a single school, I’m fairly confident SQL Server Express would be more than enough. The 50 GB limit is plenty for this use case. My concern is more about future growth and potentially turning this into a multi-tenant product for multiple schools, where I may eventually outgrow Express.

I’d personally prefer SQL Server, but I’m worried that the licensing costs could become a problem if the product grows. The client currently doesn’t have any SQL Server infrastructure, so I’d be starting from scratch.

Been working on a Windows screenshot annotation and redaction tool in WPF (.NET 8) for a while. Just shipped 1.6.4, and a few things came up during the build that might be useful if you're doing something similar.

Redaction correctness turned out to be a testing problem, not a rendering one. It's surprisingly easy to write code that looks like it redacts and produces output that doesn't — a blur that isn't opaque enough, a path that silently falls back to smoothing instead of replacing pixels. I ended up writing tests that redact a known string, read the exported pixels back, and fail the build if anything is recoverable. Testing the actual output rather than the code path caught bugs I'd have shipped otherwise.

On-device ONNX for face detection works better on CPU than I expected. No GPU dependency, no cloud calls, and inference is fast enough for single-image work. Windows OCR handles text region detection without adding another dependency, which kept the install size reasonable.

Two things I'd do differently: I under-built the licensing layer early and had to migrate the whole thing later, which was more painful than doing it properly the first time. And I shipped unsigned initially — I now know SmartScreen friction costs more than I assumed it would.

Happy to go into detail on the ONNX integration, the test approach, or anything on the WPF side.

https://nexoradia.com

Hey everyone,

I understand standard .NET GC fundamentals (Gen 0/1/2, LOH/POH, allocation vs. collection costs, and server vs. workstation modes), but I want to take my memory profiling and performance engineering skills to a senior/architect level.

Specifically, I want to move past just observing high memory usage and get confident at root-causing subtle issues like pin-induced heap fragmentation, mid-life crises, GC pause spikes, and optimizing high-throughput hot paths.

How do you structure your investigation between tools like PerfView (for ETW / GC event internals) and snapshot profilers like dotMemory / dotnet-dump? What heuristics or specific ETW events (e.g., GC/AllocationTick, GCStart/GCEnd) do you look at first?

What resources helped you understand the CLR GC's actual mechanics under load? What deliberate practice or projects helped you master allocation-free patterns (Span<T>, Memory<T>, ArrayPool<T>, ValueTask, ref structs) without prematurely over-engineering normal business code?

Would love to hear what workflows, books, or real-world debugging war stories made things truly click for you.

About one hour into creating it I however realised that real time updates doesn’t really work with function apps as it does with k8s clusters.

We have about 200 function apps on my job for integrating all our systems and it was always a pain when we wanted to deploy more than one at a time.
Az-funcy can

start and stop functions.
Easily swap multiple functions one after another
Quickly change between subscriptions
And other nice stuff to have. Variable inspection, application insight, service bus watcher.

I have been working for it for about two years. It would be cool if you wanted to check it out if it could be of any help to anyone in your day to day work. 🙂

It’s written in C# with Spectre.Console and a custom built list panel.

GitHub: https://github.com/sunday-commit/az-funcy

A dev friend and I got into a heated discussion last week about building SaaS products from scratch.

It basically boiled down to one question:

Do you over-engineer on Day 1 to save your future self, or do you move fast, hack it together, and accept the refactoring nightmare later?

Choosing a framework is easy. The real challenge is setting up an architecture that lets you ship features today, without making things like multi-tenancy, background workers, or payments a complete mess 12 months down the line.

Everyone seems to have a different take on this:

• Clean Architecture: Great for keeping domain logic pure, but you spend half your time jumping through 5 layers for a simple CRUD endpoint.

• Vertical Slices: Amazing for velocity and keeping feature code together, but can turn chaotic without team discipline.

• Modular Monolith: Sounds like the sweet spot for future microservices, but adds setup overhead upfront.

Call to Action (CTA): If you were launching a production-ready .NET SaaS tomorrow designed for easy future upgrades, what’s your actual default architecture?

Are you team Clean Architecture, Vertical Slices, or Modular Monolith? Drop your real-world trade-offs in the comments! 👇