I built Ringside at Knight AI+AV, a free Windows utility that displays Claude Code and Codex usage limits. Sharing the source because the desktop packaging and integration choices may be useful to other .NET developers.

- The UI is WPF on .NET 8, published self-contained for win-x64.

- The optional Claude Code status-line bridge is a separate NativeAOT console app. It saves the supplied limit numbers, then chains the user's existing status-line command.

- The Codex reader keeps a byte offset for each session log and processes newly appended complete lines, rather than rereading the whole file on every poll.

- Velopack handles the per-user installer and updates from GitHub releases. The updater checks for and downloads updates; automatic checks can be disabled.

- The repository includes xUnit tests, and the build script runs the test project before publishing the application.

The widget also uses a tool-window style to stay out of Alt+Tab and avoids taking focus from the editor. Windows 10 and 11, 64-bit; MIT licensed.

Source: https://github.com/KNIGHT-AI-AV/ringside

If you've shipped a WPF app with a small native helper, I'd be interested in the packaging or upgrade edge cases you ran into.

I have tried these four methods .

Edit :

Task : - An azure timer function that emails excel and image attached.
One of the worksheets of the generated excel has to be attached to email body as image for preview purpose.

Data --> Excel = ClosedXML
Excel --> Image = ??

I figured the issue is from .net because I downgraded the app and it still has the same issue. I've tried to download it. Download multiple corenet versions. Tried to use desktop and core. Looked at the console and saw that I have the dotnet downloaded and listed. ​Shutdowned and deleted dotnet. Does anyone know the problem?

Hello,

I want to create a simple Windows desktop 3d viewer, able to display STL / 3MF meshes and allowing for simple operations on the meshes (split, crop...).

I wanted to avoid building the app over low level APIs such as Silk.net or OpenGL...

I tried HelixToolkit, but I find it very buggy and not as customizable as I would need it to be (for example, you cannot really change the form and size of manipulator gizmos...).

Would anyone have a recommandation for me?

Ideally, I would have the 3d viewport embedded in a simple WPF or WinUI app.

Thanks for your help!

Internal app: Domain / Application / Infrastructure / API (ASP.NET Core minimal APIs), plus Blazor and MAUI clients talking to the API over HTTP. Program.cs is the composition root and wires Infrastructure (AddInfrastructure()).

I've already found: Uncle Bob's Dependency Rule only forbids inner circles from mentioning outer ones — it says nothing about peers in the outer circle. Microsoft's architecture guidance says the UI project may reference Infrastructure for DI, "but developers should limit actual references to types in the Infrastructure project to the app's composition root", and the UI layer "ideally shouldn't know about the implementation types".

So the law seems clear, the guidance says "ideally". My question: in real production apps, does API code outside Program.cs (endpoint handlers, controllers) inject Infrastructure types directly — e.g. DbContext? Is "composition root only" a real-world norm or a template convention? Please share what your production codebases actually do — examples, not just templates

I’ve spent about 7 years building enterprise apps with .NET (ASP.NET Core, WPF, Xamarin/MAUI, SQL Server, Azure) and I currently work at a product-based fintech company.

Over the past year I’ve gone deep on Semantic Kernel and Microsoft Agent Framework. I’ve built working prototypes, including a voice receptionist agent and a WhatsApp order-confirmation bot with RAG, but none of it is running in production with real users yet.

I’m trying to decide where to put my time over the next 2 to 3 years:

1. Certifications vs. shipping: I’m considering AI-103 (Azure AI Apps and Agents Developer) and AI-105 (Multi-Agent AI Solutions Expert). For those who hire or have made this transition, do these carry real weight, or does one production AI system matter far more?
2. Positioning: Is it better to brand myself as an “AI engineer” in the Microsoft ecosystem, or as a senior .NET engineer who ships AI features? Which one is actually getting hired or paid right now?
3. Getting production experience: For people who made this jump, how did you get your first real AI system in front of users? Through your employer, freelance clients, or your own product?

I’m not looking for reassurance. I’d especially like to hear from people who’ve shipped LLM or agent-based systems: what did production teach you that the demos and courses didn’t?

I sometimes feel that I am continually in a learning phase. Maybe I should start building something useful.

I woke up to this:

Anybody knows why so many?

Traditional UI automation scripts break whenever a CSS class or layout shifts. At the OpenAI DevDay hackathon in Kochi, we built an experimental Windows desktop copilot called StepSight that operates purely on visual screen understanding (Windows Graphics Capture + Multimodal Vision).

Key features:

Tech stack: C# (.NET 10, Avalonia 12), Python 3.12 (FastAPI), AWS (ap-south-1), and Gemini Vision.

Source code: https://github.com/nive62tech/step-sight/tree/implementation/desktop-guide
Build log: https://inaiyarhasnain.vercel.app/projects/stepsight

Curious to hear your thoughts on vision-only desktop automation vs accessibility tree APIs!

I just updated my entity conversion tool for Sins of a Solar Empire: Rebellion, so I figured I'd share it here in case it's useful to other modders.

What does it do?

When Ironclad developed Sins, they shipped many of the game's data files in a binary format. This means you can't read or edit them directly as plain text. They later released a tool called ConvertData as part of their Forge Tools 3 package, which allows you to convert these files between Binary and Text formats. However, it's a command-line application with no GUI.

I built a GUI and wrapper around these tools to make the process easier. You can select individual files, multiple files, or entire directories. I've tested it against every .entity file, and the conversions work correctly.

The tool automatically detects whether a file is Binary or Text and outputs the converted files to separate Output TXT and Output Bin directories.

The game can read .entity files in Text format, but doing so increases file sizes and slows down loading times, so Binary is still preferable for normal gameplay.

XSI to MESH conversion

Ironclad also included ConvertXSI.exe with the game. This tool allows modders to convert older XSI files into the more modern .mesh format. I've added a separate tab for this functionality as well, although the original application only supports converting one file at a time.

Entity to JSON conversion

I've also included my own library for converting .entity files into JSON. This is primarily something I developed for my own use while working on a C# script extender for Sins of a Solar Empire: Rebellion. I need to parse the game's data files and access entity properties at runtime.

Currently, the library supports the following entityType values:

• Fighter
• Frigate
• CapitalShip
• PlanetModule* (all 7 types)
• SpaceMine
• Planet

I figured I'd release the library alongside the converter in case other modders find it useful for parsing and working with entity data.

A technical note about the JSON serialization

I implemented custom data types for integers, floats, and booleans to handle some quirks in Ironclad's serialization format. Some fields contain normal values, while others use "" as a placeholder.

By default, fields that don't have values are initialized to null and omitted during JSON serialization. My custom types let me preserve the distinction between an empty field and an omitted field by tracking a separate IsEmpty boolean. This allows the serializer to write the original "" placeholder back into the entity file when converting the data back, rather than accidentally leaving the field out entirely.

A note about the included tools and licensing

I did not create ConvertData_Rebellion.exe or ConvertXSI.exe, and I do not own the rights to either of them. Those tools belong to their respective rights holders, Stardock/Ironclad. I've simply provided a more convenient interface for using them. They remain separate binaries and are not bundled into my own application, so they can be used independently if desired.

The .entity-to-JSON conversion library, on the other hand, is entirely my own work. You're free to republish it, and I don't require attribution. However, commercial redistribution is not permitted.

You can grab the tool here:

Entity Converter v0.2.0 on GitHub

Hopefully, this makes life a little easier for anyone working on Sins modding!

Developers are reporting a windows update is bumping SDK to 10.0.400 and builds are failing for various products in azure devops, on developer laptops, and in a custom pipeline for one of the apps. The only common denominator is 10.0.400. What's going on here?

I spent two and a half years moving a financial system from Visual FoxPro to C# and .NET Core as the only engineer, with no written spec. A few things I wish I had known on day one:

• Empty dates are not null. FoxPro allows an empty date. Decide per column what it means before you load anything.
• Deleted rows are still in the file. Deleting only flags a record until the table is packed. Filter them during the load or they come back.
• Rounding differs. Math.Round(2.345m, 2) gives 2.34 in .NET. FoxPro and T-SQL give 2.35. Use MidpointRounding.AwayFromZero for money.
• String comparison is by prefix unless SET EXACT is on, so "OPEN" can match longer values.
• The OLE DB provider is 32-bit only, so the loader has to run as a 32-bit process.

I wrote up the full order of work (inventory, data model, domain layer, reports, retirement) here: https://theadnansaleem.com/articles/visual-foxpro-to-dotnet-migration-guide

Happy to answer questions if anyone is facing one of these.

https://github.com/stepwisehq/typescript-dotnet

I know, I know! Another agentic coding port 🥱 🤮

But the lazy Rust port that popped up last week triggered me a bit claiming Codex failed with $400k spend and Opus succeeded you could do it for $20K(!!!).

I wanted to see if Codex could be used to do a port efficiently. I was also curious how performant a dotnet AOT port could be compared to the Golang project(I've wondered about this for a while).

This cost about $75-100 on my Pro 100 plan. It was optimized to about +13% wall time compiling the vscode project.

The same Where, Include and OrderBy, written again and again.

Here's how I turned each one into a single, named, reusable query with the Specification pattern.

I've been an architect on packaged ERP and HR products for over twenty years, and the thing that has cost the most was never a hard feature. It's that the same fact gets restated over and over.

Adding a "Required Date" field to orders in a typical EF Core + ASP.NET Core + SPA stack lands it in about thirteen places: entity, type mapping, migration, query projections, DTOs, mapper, validation, OpenAPI, front-end types, the form, the list, localization and test data. Generators handle some of them, but that only makes the restating faster. And when the back end and front end are different teams, half of that list turns into coordination rather than typing. Multiply it by a few thousand tables and by every customer's customizations, and it stops being an inconvenience.

What I ended up with is making a structural description the source instead of code. The database columns, CRUD SQL, screens for each front end and validation are derived from definitions, and the front end fetches the definitions at runtime instead of keeping its own copy of the types. In a sample app built on Northwind, the same field is three definition edits and no code. Customization becomes a layer of data on top of the standard definitions, so one tenant's change doesn't have to go through compile and deploy.

Dashboards, reports and anything that isn't form-shaped fit badly. The team boundary doesn't go away either, it moves to the rendering layer that reads the definitions.

I wrote a 30-post series on the mechanisms and the trade-offs. It was originally written in Chinese for a Taiwanese tech writing challenge, and the English version is a translation: https://medium.com/@jeff377/erp-architects-notes-designing-a-definition-driven-framework-series-index-7753228c4d33

For those of you working on large line-of-business systems: do you accept the restatement and lean on generators, or have you moved the source of truth somewhere else?

Currently I am working in a very old legacy code base with more than 30 years old of spaghetti code and business rules in every .asp file and store procedures.

Yes it is a mess. And I don't know if someone has the same problem that I have... The visual studio doesn't help me with the basics of highlights, colors and syntax with VBScript in asp classic. Sometimes it is impossible to know where an if begins and ends in one file with 6k lines (yes for real).

So I made this plugin to help me with my current job.

https://marketplace.visualstudio.com/items?itemName=AspClassicSyntaxHighlight.AspClassicSyntaxHighlight

Is the vibe code project? In parts, yes. My real concern was doing a good structure of the project and performance. The first hit of opening the files is more demanding because it's using cache. After that it is more smooth.

I am cleaning the git to make it public soon.

If you guys want to try i will appreciate it.

Sorry for my mistakes, English isn't my first language.

Thanks.

Most tenant data leaks I've seen in B2B SaaS weren't attacks. Someone wrote a new query and forgot .Where(x => x.TenantId == tenantId). Here's the setup I now use on shared-table multi-tenancy (one database, a TenantId column) to make that mistake fail closed by default. It uses EF Core 10's named query filters.

1. Resolve the tenant once per request

A middleware sits between UseAuthentication() and UseAuthorization(). It picks the workspace in this order: the X-Tenant-Id header, then a cookie, then the user's oldest membership. It then checks the membership in the database and stores the result in a scoped TenantContext. If someone forges the header, the request just gets no tenant. Nothing downstream reads headers or cookies again.

2. One interface, one filter on every entity

```csharp public interface ITenantScoped { Guid TenantId { get; } }

public abstract class ModuleDbContext(DbContextOptions options, ITenantProvider? tenantProvider = null) : DbContext(options) { // A property of the context, not a captured value: EF Core parameterises it per query. protected Guid? CurrentTenantId => tenantProvider?.TenantId;

protected sealed override void OnModelCreating(ModelBuilder modelBuilder)
{
    ConfigureModule(modelBuilder);

    foreach (var type in modelBuilder.Model.GetEntityTypes()
                 .Where(e => e.BaseType is null && !e.IsOwned())
                 .Select(e => e.ClrType)
                 .Where(t => typeof(ITenantScoped).IsAssignableFrom(t)))
    {
        ApplyTenantFilterMethod.MakeGenericMethod(type).Invoke(this, [modelBuilder]);
        modelBuilder.Entity(type).HasIndex(nameof(ITenantScoped.TenantId));
    }
}

private void ApplyTenantFilter<TEntity>(ModelBuilder b) where TEntity : class =>
    b.Entity<TEntity>().HasQueryFilter("Tenant",
        e => EF.Property<Guid>(e, nameof(ITenantScoped.TenantId)) == CurrentTenantId);

} ```

Things worth noting:

• No tenant resolved means the query compares with null and returns nothing. It fails closed, not open.
• The filter is named. EF Core 10 lets an entity have several named filters, so IgnoreQueryFilters(["SoftDelete"]) lifts only soft-delete and keeps tenant isolation. Before EF Core 10, IgnoreQueryFilters() was all-or-nothing, and that was the most common way isolation silently broke.
• The filter goes on root types only. EF Core applies it to the whole inheritance hierarchy. Each table also gets an index on TenantId, since every query now starts with it.

3. Query filters don't protect writes

An entity loaded with IgnoreQueryFilters(), or attached by hand, can still be saved. So SaveChangesAsync runs a guard:

```csharp private void GuardTenantWrites() { // Background jobs (no HTTP request) are trusted system code. if (tenantProvider is null || (CurrentTenantId is null && tenantProvider.IsSystemContext)) return;

var tenantId = CurrentTenantId;
var foreign = ChangeTracker.Entries<ITenantScoped>()
    .Where(e => e.State is EntityState.Added or EntityState.Modified or EntityState.Deleted)
    .FirstOrDefault(e => tenantId is null || e.Entity.TenantId != tenantId);

if (foreign is not null)
    throw new InvalidOperationException(
        $"Cross-tenant write blocked on {foreign.Entity.GetType().Name}.");

} ```

It throws rather than filtering silently, because a cross-tenant write is always a bug and should show up in logs and tests.

4. What still goes around it

And two tests: create two workspaces, write in one, and assert the other can neither read nor update it. Add an architecture test that every entity with a TenantId property implements ITenantScoped, so a new entity can't opt out by accident.

How are you handling this? I'm curious whether people here have gone with PostgreSQL row-level security instead of (or on top of) EF filters, and how that played out with connection pooling.

Disclosure: this comes from a .NET 10 starter kit I sell (PRYZMA SaaS Starter). There's a longer write-up if anyone wants it, but I'm happy to answer everything here.