roflcopter69

That actually sounds like a promising idea. Thanks for putting so much thought into this.

Hi! Love to see that C# language designers are here on HN :)

Just wanted to add just another opinion on a few things.

I think many people already mentioned it, but I also don't feel to good about non-boxed unions not being the default. I'd personally like the path of least resistance to lead to not boxing. Having to opt-in like the current preview shows it looks like a PITA that I'd quickly become tired of.

Also, ad-hoc union types could be really nice. At least in Python those are really nice, stuff like `def foo(x: str | int)` is just very nice. If I had to first give this union type a name I'd enjoy it way less.

But I'm aware that you are trying your best to find a good trade-off and I'm sure I don't know all the implications of the things I wish you'd do. But I just wanted to mention those to have another data point you can weigh into your decision process.

Of course the "wait 7 days" are not a silver bullet, but it gives automated scanners plenty of time to do their work. Those automated scanners surely catch this `eval(base64.decode("..."))` stuff that some of those attacks used so in my book this dependency cooldown is a net win. I guess the skilled malicious actors will then up their game but I think it's okay to kick off an arms race between them and the security scanners in the dependency world.

I tried Swift a few months ago in a project that made use of a bunch of bigger dependencies and I was instantly shocked by the compilation times. It's quite unimaginable to me using Swift for everyday work because of that. Especially when coming from the fast compile times of Go. But it's really unfortunate because I really enjoyed writing Swift because it feels like a very well made language. But iterating on some code and trying to get quick feedback is pure pain.

About the lag, I didn't bother looking into it, but I suspect they log every single action you do and require that the request to their servers was confirmed before allowing to do the next action. They probably face a lot of traffic right now, which could cause the lag. Just speculation though.

I can't help myself but see this as a very strangely written article that does not meaningfully contribute anything? Did the author didn't bother to do some basic research and just dumped a bunch of thoughts, speculation and questionable code/command snippets?

To quote from https://docs.modular.com/mojo/roadmap/

  Mojo may or may not evolve into a full superset of Python, and it's okay if it doesn't.

Definitely pixi imo. At least for me it works just as well as uv and imo does even more than uv by giving you the ability to mix dependencies from pypi.org and Conda. And the great thing about Conda is that they still build PyTorch for Intel Macs or OpenCV for macOS 11+ which is not the case for the wheels you'll find on pypi.org so it's really great if you want to build software that is shipped to a variety of old platforms.

Can highly recommend pixi. It really is the "uv but for Conda" and actually quite a bit more imo. Don't know how relevant this is for you, but many packages like PyTorch are not being built for Intel Macs anymore or some packages like OpenCV are built such that they require macOS 13+. That's usually not too much of a problem on your most likely pretty modern dev machine but when shipping software to customers you want to support old machines. In the Conda ecosystem, stuff is being built for a wide variety of platforms, much more than the wheels you'd find on pypi.org so that can be very useful.

So I can really recommend you trying pixi. You can even mix dependencies from pypi.org with the ones from Conda so for most cases you really get the best of both worlds. Also the maintainers are really nice and responsive on their Discord server.

+1 for Conda. I also have to mention pixi (https://github.com/prefix-dev/pixi) which kinda is a uv for the Conda ecosystem. Highly recommend!

Maybe a bit of a weird analogy, but y'all know about the basic advice to not come back to your abusive ex? Don't trust Microsoft to always respect you as an user, even if they now are trying to tell you they'll change and do so again. It's all just damage control PR speak.

Thanks for working on this mr_Fatalyst, this looks very promising. I'll keep an eye on this. Can't wait to dump the mess that is SQLAlchemy. Btw, you're getting a lot of stars on GitHub right now ;)

This is the way. For now, pyright it's also 100% pyright for me. I can recommend turning on reportMatchNotExhaustive if you're into Python's match statements but would love the exhaustiveness check you get in Rust. Eric Traut has done a marvellous job working on pyright, what a legend!

But don't get me wrong, I made an entry in my calendar to remind me of checking out ty in half a year. I'm quite optimistic they will get there.

Sounds interesting! Have you published this somewhere? I wonder how well this works when you want to compile some complex dependencies. Have you compared compile times between your solution and when using CMake?

Thanks for the Lua bindings suggestion!

It's just that I quite dislike using such a scripting language. It's personal preference, for sure, but here's a bit more context https://news.ycombinator.com/item?id=47220602

Oh thanks, that looks very intriguing! The maintainer seems to be a Microsoft employee so there's that? I wonder though, is this a niche hidden gem or really something that more people should consider using? Also, what about compatibility with platforms like Android, iOS or consoles? That'd be very important for gamedev.

> C++ is really not very amenable to this because every change to the contents of a class messes up your entire memory layout

I think even `dotnet watch` at some point nopes out when you change too much. I think they call it "rude edit" and ask you to completely restart the program in that case. So I don't expect every possible C++ edit to be manageable by hot reload. But changing a few if conditions or constants should be fine or not?

I'm more and more questioning scripting languages in games. What are the main reasons to use something like Lua? I think it's having not to rebuild the engine, no compile times, changing stuff while the game is running and being more accessible to non-programmers. But I think it's rather infuriating, all those points could be less relevant if the tooling for "real" programming languages was better. And with coding agents becoming more wide-spread I guess accessibility to non-programmers also becomes less of a point. I guess it's just my personal dislike for scripting languages in games, but really, it would be so much nicer imo if there was only need for one language that does it all. But seems like a difficult thing to achieve.

I myself don't have much of a dotnet gamedev stack going on unfortunately. Although I've been dabbling with MonoGame and have been enjoying it so far. MonoGame matured quite a bit since I previously used it which was more than 5 years ago!

Unity indeed is still using Mono instead of CoreCLR and is kinda stuck in that sense. But to be fair, they are trying to migrate to CoreCLR which will let them profit from all the crazy optimizations that Microsoft has poured into the runtime and ecosystem.

Godot is kind of a hate love for me when it comes to C#. Godot gives me the most hope that there can be a free, community-driven but powerful game engine and it having C# support built-in seems great at first glance until you realize that GDScript, which is veeeeery dynamic language, pretty much nullifies a lot of the advantages you'd get from using C# because you find yourself doing weird type system stuff that GDScript imposes on all the other languages. The best you can do is doing as much as possible in C# and use Godot as kind of a input and rendering abstraction layer. But then you're missing out on a lot of the functionality that Godot offers which should raise the question why use a game engine in the first place. It's difficult, at least for me. Others might have figured it out much better.

Thanks for the reply!

> I quite like modern C++, so I really tried to make it work for gamedev, but I think you can't really do it.

What exactly do you mean? What parts of modern C++ did not work for you?

> You can use all the modern C++ features that are not in the standard library though!

> I just decided to not use any of the C++ standard library (I just use a few C headers)

So what do you do with C++ that C alone couldn't do?

I see `dotnet watch` being mentioned for code hot reload which is such a great feature for quickly iterating on a game. Not having to restart the whole game just because one has changed a few if statements and values really helps staying in the flow.

But I'm still not too enthusiastic about having GC in C# which is why ideally I'd like to start making a small 2D game just with SDL3 and C++ but how could I get this nice hot reload workflow there? I don't have the money to pay for expensive proprietary tools like https://liveplusplus.tech so what can I do? I guess there's the "game as dynamic library" trick from Handmade Hero (see https://www.youtube.com/shorts/seWAIURXxH0) so maybe that would work good enough? Maybe https://github.com/fungos/cr would do most of what's needed here?

Also, how does one even do modern C++ these days? Is it possible to have big C++ code bases that still compile fast these days? Is CMake 4 good™ now? Are modules really there yet? I rely on clangd as LSP for working with C++ but I read that clangd still fundamentally struggles with C++ modules https://chuanqixu9.github.io/c++/2025/12/03/Clangd-support-f... and it's so bad that there has even been some effort going into making a new C++ LSP https://github.com/clice-io/clice

I read that article a while ago and highly enjoyed it. C# truly has become a very good language for game development and since NativeAOT has become a thing, we will less and less rely on hacks like IL2CPP or BRUTE which transpile the C# IL to C++ such that it can run on JIT restricted platforms like consoles or iOS.

I'd really love to go all-in with C# and SDL3 to make an engine-less cross-platform game but I still miss a good way to make complex game UIs without doing everything from scratch. Does anyone have a good suggestion for making non-trivial game UIs without using a full game engine? So far, I only found https://github.com/vchelaru/Gum and https://github.com/mikke89/RmlUi but I think there's not really something super mature and feature packed, or is there? I'm aware of https://github.com/ocornut/imgui, as the article also mentioned, but that's more for debug UIs, right?

No snark, just honest question, is this a severe case of https://en.wikipedia.org/wiki/Chatbot_psychosis ?

How much of the RAM usage is by gopls (The Go LSP)?

Thanks! That helped. Really strange though, that the slash commands inside the CLI do not allow for such a detailed configuration. It allows for the sandbox and approvals options but there's only "default" and "just allow everything" while the CLI flags or the config.toml allows for more nuanced options.

There's one really confusing thing in Codex CLI from my perspective. How do I make it run unsandboxed but still ask me for approvals? I'm fine with it running bare on my machine but I like to approve first before it runs commands. But I only see how I can configure to have both or none. What am I missing?

Fixed some of the things, indeed. But don't let this blog post fool you. When using discriminated unions, Pydantic exports JSON schema with `oneOf` while the google-genai expects `anyOf` so that does not work out of the box. Also it still does not support basic stuff like when you have this in you Pydantic model: `foo: Literal[1, 3, 5]`

It's still far from what I'd expect should be supported.

Not so fast! Check this out https://github.com/googleapis/python-genai/issues/460

In my experience, you can only use Gemini structured outputs for the most trivial of schemas. No integer literals, no discriminated unions and many more paper cuts. So at least for me, it was completely unusable for what I do at work.

Hi! I've been following your work on GodotJS for a while now. Really cool stuff man, thanks for all the improvements you landed in GodotJS!

I think most of the people using Godot are not aware how powerful and ergonomic GodotJS actually is. All the intellisense and completion suggestions goodness when using GodotJS is a godsent.

Can you tell us a bit more about how making breaka club with GodotJS has been going for you?

- Are you using Godot as kind of a rendering frontend while your TypeScript code is rather self-contained and only interacts sparingly with the APIs exposed via GodotJS or is everything deeply intertwined? I'm curious because I'm still looking for a good GDScript replacement. I really dislike GDScript so much :(

- How has performance been? I'd imagine V8 with JIT be a lot faster than GDScript and probably within 2-3x of C#? But I guess one wouldn't be able to use V8 JIT on consoles or iOS? I wonder if the performance hit would be tolerable.

- Do you still have high-performance code you write with e.g. godot-cpp and if so, how's easy is it to make those things interact?

- I saw that there have been thoughts about migrating GodotJS to a GDExtension but it's not easy it seems? Would be a great long-term goal imo because not having to use a custom engine build and instead just plug in a GDExtension would be pretty convenient.

- I assume that one cannot use stuff like the node file system API or such things and one has to restrict themselves to JavaScript/TypeScript code that would also run in the browser?

Sorry for the flood of questions, no need to answer them all. Still curious about all of those things :)

Yes I think there's still a lot of potential upside.

But check out this collaboration between Blender and Godot https://godotengine.org/showcase/dogwalk/ I could imagine that in the not too distant future we might really have a completely open tools stack for making up to AA games (minus console SDKs which always are under NDA I guess).

> StS devs cannot write normal C# code, you have to really work around the C# integration to avoid lag spikes

Do you have any sources for this? A while ago I had a small chat with the StS devs on the Chickensoft Discord server and they didn't mention this. Instead they were overall just very positive about their Godot + C# experience.

> The other huge problem is the terrible external editor support

Have your recently tried JetBrains Rider for Godot + C# development? Lately, they've been quite actively improving the Godot integration https://github.com/JetBrains/godot-support and also showing some significant commitment https://godotengine.org/article/jetbrains-joins-dev-fund-sup... and tbh I can't share your experiences since I'm using Rider. Even hot reload works really well without losing the running game state.

> There's a good reason that there are barely any games using it, and they're all extremely technically simple

Well, as of now when checking https://steamdb.info/tech/Engine/Godot/ there are 6,109 games made with Godot engine on Steam with 2,568 of them having been released in that last 12 months so there is a strong growth going on right now. But I agree that most of those look technically simpler.

> but rather a million DX papercuts that a good ambitious developer would just never accept

I think you're generalizing a bit too much here. You're implying that the StS devs or the devs of Road to Vostok are not ambitious?

I don't know man, there's more nuance to this. Don't get me wrong, I'm aware that Godot + C# still has a bunch of shortcomings and there's still some catch up to do but overall it's imo already quite pleasant to use.

Also, let's not forget he's the one who brought Swift to the Godot engine https://github.com/migueldeicaza/SwiftGodot

Related, for everyone interested into Godot + Swift, check out https://github.com/johnsusek/SwiftGodotBuilder I think Swift might soon be a crazy ergonomic language to make Godot games.