C# news and engineering summaries

OpenCiv3, previously known as C7, is an ambitious open-source project aimed at reimagining the classic 4X strategy game Civilization III using the Godot Engine and C#. This community-led initiative seeks to modernize the game by removing arbitrary technical limits, fixing legacy bugs, and enhancing modding capabilities while supporting modern platforms like Windows, Linux, and macOS. The project has recently achieved a significant milestone with the v0.3 "Dutch" preview release, which introduces a standalone mode featuring placeholder graphics. This allow users to experience the game without requiring original media files, though original assets remain supported for a more polished visual experience. Currently in a pre-alpha state, OpenCiv3 is licensed under the MIT License and actively encourages community contributions via GitHub to help complete its gameplay mechanics and content.

Developing native Windows applications today is fragmented and frustrating. Despite the promise of the Windows App SDK and WinUI 3, developers frequently must resort to low-level Win32 API interop and struggle with complex packaging. Due to poor tooling and lack of prioritization by Microsoft, many prefer web-based frameworks like Electron or Tauri for modern development.

Anders Hejlsberg, the creator of C# and TypeScript, recently shared insights on the development of TypeScript 7.0 and the role of AI in software engineering. The upcoming version marks a significant shift as the team ports the compiler from TypeScript to native Go code to achieve a 10x performance boost through native execution and shared memory concurrency. Hejlsberg defended the choice of Go over Rust or C#, citing its similarity to JavaScript and better support for the existing codebase's cyclic data structures. Regarding AI, he noted that while it initially failed to provide deterministic results for code migration, it has become invaluable for porting pull requests and enhancing language services. He predicts that AI will fundamentally transform development tools by shifting from simple IDE assistants to autonomous agents that utilize Model Context Protocol (MCP) to interact with semantic language services.

In this technical narrative, Leónidas Neftalí González Campos recounts a significant optimization challenge involving a REST API built with C# and the ABP framework. The issue centered on a 'Users list' endpoint that appeared to crash but was actually just extremely inefficient, taking over five minutes to complete bulk operations. The root cause was a '2-year-old hotfix' where developers used a foreach loop to await individual database inserts one by one. By bypassing the outdated ABP repository and directly implementing Entity Framework Core's AddRange and SaveChangesAsync methods, the author reduced execution time from five minutes to 300 milliseconds. The story highlights the dangers of technical debt and a 'feature factory' management culture that prioritizes speed over quality, emphasizing that significant gains often come from removing suboptimal practices rather than complex innovations.

A developer created an exceptionally fast C# CSV parser by leveraging hardware-accelerated SIMD instructions like AVX2 to process UTF-8 data. By optimizing memory access, minimizing cache pressure, and avoiding excessive micro-optimizations that hinder JIT compilation, the library outperforms existing solutions in most benchmarks, balancing manual instruction control with runtime-driven optimizations.

Slay the Spire 2 suffers from 'correlated randomness' due to the C# System.Random implementation, which produces predictable outputs across different game RNGs initialized with similar seeds. This flaw allows players to anticipate events, such as curse distributions or combat outcomes, significantly impacting gameplay. Developers are encouraged to replace the standard library RNG with a nonlinear or counter-based alternative.

Moongate v2 is a modern Ultima Online server project built with .NET 10, prioritizing a clean, modular architecture and NativeAOT compatibility. It features deterministic game-loops, Lua scripting, and a sector-based world streaming strategy. The project emphasizes performance benchmarks, specialized packet tooling, and thread-safe networking to provide a maintainable foundation for high-concurrency shards.

A developer created a C# application to monitor and log the removal of stories from the Hacker News Front Page, aiming for greater transparency in moderation. The project explores how titles are modified and how stories disappear from the top rankings, often due to user flags or duplicate status. The author highlights the difficulties of moderating a high-traffic site while advocating for public logs of penalized content.

C# 15 introduces union types in .NET 11, allowing developers to define a closed set of types that a variable can hold. This feature enables exhaustive pattern matching, eliminates the need for unsafe object types or complex hierarchies, and simplifies handling unrelated types. It supports custom implementations for performance-sensitive scenarios and improves overall type safety.

.NET 11 introduces native 'union' types in C# 15, enabling a type to represent multiple potential values. These structures simplify handling various types via switch expressions with compiler-enforced exhaustiveness. Developers can implement custom, non-boxing versions to optimize performance, marking a significant advancement in C# functional programming capabilities.

OpenCiv1 is an open-source project that recreates the classic Civilization 1 game using C# and .NET 8. By replacing original code, graphics, and audio with new, copyright-free assets while maintaining the original logic, the project ensures cross-platform compatibility. It legally requires users to own the original game files to function as a modern, playable engine.

C# is evolving its memory safety model to follow patterns similar to Rust and Swift. The new 'unsafe' keyword will serve as a visible, enforceable contract for memory operations rather than just a context marker. This model requires 'unsafe' inner blocks, documented safety obligations, and compiler-enforced propagation, aiming to make memory safety explicit and reviewable by developers and AI.

A researcher discovered a critical vulnerability in MSI Center that allowed unprivileged users to execute arbitrary commands with LocalSystem privileges via an insecure named pipe. Despite initial communication issues with MSI's full support mailbox, the company verified the flaw and issued a patch to address the privilege escalation and potential Remote Code Execution risks.

The author documents the decade-long process of upgrading their game, Gun Rocket, through various Unity Engine versions to modern standards. By navigating dependency changes, deprecated APIs, and structural shifts like the introduction of the Package Manager, the project serves as a practical guide for technical preservation and engine migration, emphasizing the value of simple, maintainable software architecture.

This article explains how to use Swagger and OpenAPI as a source of truth for automated contract testing. It details building a C# validator using NSwag and NUnit to verify that API requests and responses conform to defined schemas, ensuring providers and consumers remain synchronized without breaking production environments.

In this technical breakdown, developer Maddy Thorson explains the simplified physics engine used in the hit platformers Celeste and TowerFall. The system is built on two primary C# classes: Solids, representing level geometry, and Actors, which are interactive objects like players and enemies. By utilizing integer-locked axis-aligned bounding boxes (AABBs), the engine ensures pixel-perfect movement while avoiding performance-heavy overlaps. The summary details how Actors move using remainders for sub-pixel calculations and how Solids handle complex interactions like pushing or carrying Actors. This elegant design prioritizes specific constraints, such as pushing taking priority over carrying, and implements a 'Squish' mechanic for instances where Actors are trapped between geometry. This approach demonstrates how simple constraints can create robust, feel-good movement in modern indie games.

The author explores using DNS TXT records as a serverless file storage system by encoding, splitting, and uploading data to be reassembled at runtime. By patching a C# DOOM engine to run entirely from memory, the author successfully executes the game via ~2,000 DNS queries using a PowerShell script, demonstrating significant, persistent, and stealthy protocol abuse.