Iron Software at .NET Conf Thailand 2025: WebAssembly, AI-Powered Development, and the Road to .NET 10

WebAssembly Changes Everything

WebAssembly isn't just a browser curiosity anymore. With .NET 10, C# compiles directly to WebAssembly, which means:

• No runtime installation required. WebAssembly is already in every modern browser, phone, and edge device.
• Near-native execution speed. We're now in the same performance ballpark as Rust and C++, without the cross-platform compilation headaches.
• One codebase, everywhere. The same .NET code runs on servers, desktops, mobile devices, and inside web pages.

For Iron Software, this unlocks new deployment possibilities. Our libraries can now reach environments that previously required complex native bindings or JavaScript workarounds.

AI as the "Mega Typewriter"

Jacob also shared how our team uses AI in daily development, not as a replacement for engineers, but as a force multiplier.

The approach: use multiple AI models together, each playing a different role.

• OpenAI for repository analysis and understanding architectural weaknesses
• Claude Code for hands-on implementation (it's "out of the sandbox" and can actually execute)
• Gemini Pro for planning next steps and reviewing what the other models produced

The key insight? AI needs constant feedback. Test-driven development creates that feedback loop, red tests become green tests, and hallucinations get caught before they ship.

"A sprint takes 30 minutes rather than a week. You have to be the senior programmer here, you've got a team of junior programmers. This is your work, not the machine's work."

For DevOps specifically, AI shines at the tedious-but-critical work: generating unit tests, hitting 90% code coverage in hours instead of weeks, and automatically fixing broken builds across platforms.

The Migration Checklist

1. Install Visual Studio 2026 and .NET 10 SDK. Visual Studio 2022 only supports up to .NET 9, so the upgrade is required.

2. Update target frameworks. Change every .csproj file in your solution to target .net10.0.

3. Update NuGet packages. Dependencies have their own compatibility requirements. Check for updates and test thoroughly.

4. Replace Swagger with OpenAPI. Microsoft has moved away from Swagger in favor of the native OpenAPI implementation. This means:

   • Install Microsoft.AspNetCore.OpenApi
   • Install Swashbuckle.AspNetCore.SwaggerUI (for the UI)
   • Update Program.cs to use builder.Services.AddOpenApi() instead of AddSwaggerGen()
5. Adopt the new .slnx solution format. The old .sln files were bloated with GUIDs and configuration noise. The new XML-based format is clean, readable, and version-control friendly.

Best Practices for Any Migration

Shadman also outlined a framework that applies beyond .NET 10:

• Prepare: Audit your current dependencies before touching anything. Know which packages support your target framework.
• Modernize: Remove deprecated APIs, enable nullable reference types, and refactor legacy async patterns.
• Test: Add unit and integration tests before migrating. Validate performance and memory usage against your baseline.
• Deploy: Use CI/CD pipelines with staged rollouts. Start with 5-10% of servers and expand as confidence grows.
• Monitor: Application Insights and OpenTelemetry help catch issues that only appear in production.

Collections Got Faster

.NET 10 introduces "array devirtualization", the compiler now accesses collection data directly instead of going through an interface layer. In theory, this cuts interaction overhead in half.

Jim ran his own benchmarks on document processing operations (the kind Iron Software libraries handle constantly):

These aren't synthetic microbenchmarks. They reflect real patterns: iterating through PDF pages, counting words, processing characters.

The Compounding Effect

No single optimization is a silver bullet. But .NET 10 includes hundreds of improvements that compound:

• Stack allocation: Objects that don't escape a method can skip the heap entirely, eliminating garbage collection overhead. Some benchmarks show 68% improvement.
• Smarter inlining: Methods with try-finally blocks can now be inlined, unlocking optimizations that were previously blocked.
• Reduced GC tracking: Fewer cases where the garbage collector needs to monitor references.

The bottom line: same infrastructure, higher throughput, lower cost.