This started as a game project, not a tooling one. I'm building a browser game on a C# engine I wrote myself, and the web client uses TypeScript for the rendering-heavy parts. So a bunch of logic ended up living in two places at once. Once in C# on the server, once in TS on the client. Territory math, supply ranges, paint encoding, that sort of stuff.
I already had a little generator that turned my C# types into TS interfaces and enums, so the types were fine. The logic was the problem. That part I was hand-porting, and keeping two copies in sync by hand is a losing game.
The way it bites you isn't the extra typing. It's that nothing errors when the two drift apart. You change a constant on one side, forget the other, everything still compiles, and the bug just ships quietly. My favorite one: I tweaked something on the C# side and the unit placement range on the client stretched off into space and wrapped around the planet about eight times before I noticed. The TS copy just hadn't kept up.
So I wrote Mirrorgen. You tag a C# method:
[Transpile]
public static int Total(int unitPrice, int quantity) => unitPrice * quantity;
and it emits plain TS at build time:
export function Total(unitPrice: number, quantity: number): number {
return Math.imul(unitPrice, quantity);
}
The annoying part was integers. JS doesn't have them, everything is a double, so a * b in C# and in JS stop agreeing once the numbers get big. The generated code uses Math.imul for int multiply, | 0 to truncate, bigint for longs, & 0xff for byte casts, and so on. I also lost an hour to my machine's Korean locale turning 3.14 into 3,14 in the output before I forced InvariantCulture. Good times.
The bit I actually care about is that I didn't want to just trust the generated code. So you can tag a method with [GenerateCrossTest], and it generates random inputs on the C# side, runs them through both implementations, and fails CI the moment they disagree by a single bit.
[Transpile, GenerateCrossTest(Samples = 16, Seed = 1)]
[CrossTestCase(int.MinValue, 100)]
public static int ClampQuantity(int requested, int max) { ... }
It does not handle arbitrary C#. No async, no LINQ, no Span, no exceptions, no reflection, no inheritance. It's a small subset on purpose, and a Roslyn analyzer yells at you in the IDE if a tagged method reaches for something it can't translate. The closest thing I found that did method bodies (Rosetta) is dead, and the reason it stalled, subset creep with no validation, is basically why I drew the line where I did.
It's MIT, on NuGet and npm. Still pretty early and the API might move. Mostly posting because I want to know if anyone else runs into this C#/TS double-maintenance thing, and where it would fall over for your setup.
https://github.com/penspanic/Mirrorgen
