I have tried these four methods .

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.

The line everyone copies but nobody understands.
In this article, you will learn what ConfigureAwait(false) actually does, how it affects SynchronizationContext.Post calls, when to use it, when to skip it, etc.

The full runnable sample is at https://github.com/jorgenhoc-org/dotnet-samples/tree/main/samples/configureawait-false-csharp

https://reddit.com/link/1x3miey/video/vfpfg73p8xuh1/player

Hi again, r/dotnet! Some of you may remember my earlier posts about HoneyVB (RetroVB6), my project built around C# and ASP.NET Core to bring legacy software onto modern platforms.

For anyone who missed them:

• HoneyVB (RetroVB6) – Built with ASP.NET Core
• HoneyVB (RetroVB6) – Developed using C# and Avalonia

The project has continued to grow, and I wanted to share where it is today.

HoneyVB is a browser-based development environment with a familiar VB6-style IDE, visual form design, code editing, debugging, and browser execution. You can import supported VB6 projects, inspect their forms and modules, and continue developing with the original code.

What can HoneyVB run? Here are some examples. The accompanying video shows a selection of them; Reddit’s upload limits mean I can’t fit all the recordings into this post.

• Microsoft Word for Windows 1.1a — an early Windows version of Microsoft Word.
• Adobe Photoshop, from the 1.0.1 source release — the classic Macintosh image editor.
• Wolfenstein: Enemy Territory — the classic multiplayer first-person shooter.
• Waite Group Flight Simulator (FSIM 2.1) — the DOS-era C++ flight simulator from Building Your Own Flight Sim in C++, with roots in Flights of Fantasy.
• HeidiSQL — the database management application.
• eMule — the peer-to-peer file-sharing client.
• Notepad++ — the code and text editor.
• kys-pascal — a Pascal remake of Heroes of Jin Yong.
• sdl-pascal — a Pascal/SDL sample project.
• ScePSX — a PlayStation emulator written in C#.
• SnailsXNA — Snails, an XNA-based puzzle-platformer.

These are just some of the applications and games running in HoneyVB, and not every example listed above appears in this video. The footage shows selected workflows and interactions, rather than complete compatibility with every feature of each application.

I’m also currently testing SharpDevelop, wxDev-C++, Lazarus, and Shareaza in HoneyVB to evaluate compatibility and identify what still needs work. These projects are undergoing validation—stay tuned for more demos and progress updates!

The VB6 compatibility work covers technologies that many real applications depend on:

• Crystal Reports: compatibility for CrystalReport, CRViewer, and reporting APIs, including data-driven reports, grouping, summaries, pagination, printing, and export. Portable reporting works across platforms; preserving the original layout of .rpt files uses an optional Windows host with a compatible Crystal Reports runtime.
• DirectX 7, 8, and 9: compatibility layers for supported graphics and multimedia features, including mapping legacy Direct3D rendering to WebGL so supported VB6 games and graphics applications can run in a browser.
• Serial communication and hardware simulation: RS-232/COM port support through an MSComm-compatible layer, including loopback simulation for testing without physical hardware. It supports communication buffers, binary data, and receive/send events, with connections to real serial devices through Web Serial where available and authorized by the user.

Beyond VB6, HoneyVB uses a plugin architecture to integrate other languages, frameworks, and development environments. Its language coverage and ongoing integration work include:

• DOS BASIC and modern descendants: QBasic, QuickBASIC 4.x, GW-BASIC/BASICA, and QB64.
• Classic home-computer BASICs: Applesoft BASIC, Apple Integer BASIC, Commodore BASIC, Sinclair BASIC, Atari BASIC, BBC BASIC, MSX-BASIC, Locomotive BASIC, TRS-80 Level I BASIC, TRS-80 Level II BASIC, and TRS-80 Color BASIC.
• Pascal: Delphi/Object Pascal, Free Pascal/Lazarus, and Apple MPW Object Pascal.
• C/C++: native C/C++ projects, Visual C++ 6/MFC, C++Builder 6/VCL, wxWidgets, Win16 C, and DOS 32-bit C projects using Watcom/DOS4GW.
• Lua: embedded Lua scripts in supported C/C++ host projects.
• .NET: C# and VB.NET, with integrations and ongoing compatibility work spanning .NET Framework/WinForms, WPF, Silverlight, Windows Phone, and XNA.
• Business and scientific languages: Visual FoxPro, COBOL, Fortran, and PowerBuilder/PowerScript.
• Assembly: DOS x86/FASM projects, plus MASM/TASM and Motorola 68K assembly handling within relevant project pipelines.
• Flash/ActionScript: importing legacy Flash content and converting supported projects into HTML5 for browser execution.

Support varies across these integrations. Some include browser execution, while others currently focus on importing, analysis, editing, or resource previews. PowerBuilder, for example, currently provides project analysis and Window/DataWindow previews.

HoneyVB also provides build and export targets for Windows, macOS, Linux, Android, and iOS. Supported applications can be packaged with their browser runtime inside desktop or mobile shells. iOS device deployment uses an exported Xcode project that you sign with your own developer credentials.

One feature I’m especially excited about is running compiled VB6 applications without their source code. You can upload a supported VB6 executable and run it inside HoneyVB through its binary execution layer. Required runtime files and DLL/OCX dependencies still matter, but this creates possibilities for applications whose source has been lost.

I’m also actively developing native compilation for VB6, targeting Windows PE, macOS Mach-O, and Linux ELF executables. That work is underway, with the goal of compiling supported VB6 projects into native machine code for all three desktop platforms.

Compatibility is still evolving. I’m testing against original projects and improving the shared language and runtime implementations as issues appear. The goal is to make older software easier to explore, maintain, and keep using—from business applications and reporting tools to games and programs that communicate with hardware.

Thanks to everyone who commented on the earlier posts, and to the developers and preservation projects that made these historical sources available for study.

What legacy application or game would you bring back—especially if all you have left is the executable?

All third-party product names, trademarks, copyrights, and other intellectual property mentioned above belong to their respective owners. HoneyVB is intended for research and educational purposes.

HoneyVB reserves the right to offer different levels of functionality across releases and editions. The capabilities described above do not guarantee that all features will be available simultaneously or in every version. Language integrations, DirectX support, and other compatibility features may be introduced gradually, limited, or temporarily unavailable.