C# already provides many tools for your performance-critical code though. You can use pointers in unsafe. You can allocate unmanaged memory with Marshal. You can avoid copy with Span. You can even manually vectorise with Vector.IsHardwareAccelerated and such.
You can also distribute apps without .NET runtime with NativeAOT.
I'm sure there are people who want a C# without GC, but for me it's just... sufficient enough.
> I'm sure there are people who want a C# without GC
There's also C++ and although it is a monstrosity the practical thing would be to use that.
If you want a serious alternative to C++ I don't see it in C# without GC. On the other hand I have seen a lot of C++ code where normal C# would be much better suited.
Also people expect when they use a C# compiler that existing programs and libraries written in C# will be usable, but this doesn’t appear to support the same standard library APIs. So why use C# at all instead of a language with an ecosystem that has the properties you want?
I mean, unless you don’t need any memory to be released during a run, everything needs to be rewritten to use memory management through arenas, which is a whole new memory management paradigm even for most people used to languages which require either manual memory management or highly specific lifetime specifications. So, yeah, no nontrivial existing code is usable even before you consider that none of the libraries supplied by the runtime that most code relies on are available.
.NET runtime also has generational GC and escape analysis (so objects can be allocated on the stack if they have a known lifetime). Generational GC essentially give you a super fast bump allocator for short lived objects: faster than malloc.
Even without unsafe we can allocate objects once and just reuse them. But why would you? C# is the go to for interfacing with native code and unmanaged memory. ( C# is way ahead of Java tho JDK 25 is beginning to catch up). I miss C#.
Figure out what parts of your app needs to be “downcoded” and optimize that. Enjoy bump allocators and plentiful libraries for the rest of it.
I wrote graphics applications in C# that used 3GB of memory back when we had to tell XP, at boot, to not use half the 32bit address space for itself. Most of it was in unmanaged space. C# is awesome.
Which would be a problem if I needed to write code today and send it back to the 1990s to be run, but I have about as much need to compile to DOS as I need to produce punch cards to load into ENIAC.
I... guess so? But the last time I had users who use DOS was in my previous life. NativeAOT supports iOS though, which is a reasonable target for the current-life me.
You're being sarcastic but it's likely necessary. There will be so many vulnerabilities found in legacy codebases and not enough people who understand them to patch the holes. We'll have to rely on LLM to update them and the once well-understood codebase would be more and more like a vibe-coded one.
Because benchmarks aren't everything? If you see Neon and Hydrogen get the same score in a benchmark you should question if the benchmark measures what we care instead of suspecting that Neon and Hydrogen are equally powerful.
I'm currently doing a round of fairly simple changes - refactoring some code based on different memory allocation strategies. Neon (high) is working on a single file < 1000 lines, Opus (low) reviews, I'm manually coordinating, using their own harnesses, agy/CC.
n = ±10, but Opus always catches a subtle bug, a leftover comment, a missed edge case, naming inconsistency, tooling gap. Which Neon seems oblivious to. So far 100% of its reviews have been correct; accepted, fixed and validated by Neon.
Performance is highly dependent on the task/domain, yes, but you'd expect at least one of those four models, the more expensive one, to catch up to Opus in the coding department, but that does not seem to be the case.
I made two new worktrees, hard reset to the commit preceding a simple fix. The issue: "temporary buffers (out_buf, cps, out_cps, src_cps) are manually freed across multiple return branches. Pairing each acquisition with defer mem::free(...) — or using @pool() + mem::temp_array for the short-lived out_buf / out_cps scratch arrays — removes the branch-by-branch cleanup".
---
## Round 1
Neon implements. ~6 minutes.
Opus reviews. 30s. Prompt is "review the unstaged changes", empty context.
- The heap_buf + defer if (heap_buf != null) combination is clunky, much like the committed flag was. C3 has a built-in way to do this [shows example]
- if no character actually changes, return the string itself to skip the buffer
- Allocator mismatch: unicode_normalize_simple in src/unicode_wrapper.c allocates with libc realloc, but result_cps is released with mem::free
All three accepted and fixed. This is an accurate re-enactment of what happened an hour ago with the same fix.
I'm not really surprised that Neon struggles with C3, as it's a medium model, but with improvements done to actually feel better than Carbon while using it.
Are you running it through Antigravity?
I'm doing some disassembly and modding for older RTS games now and it's been really good at just chewing through the Ghidra output, as I'm paying for Google sub either way due to YT and Drive it's a good deal. Didn't use it on some of the more obscure ESP32 & atmega legacy bs I'm doing for my father in law, though.
On the other hand, I worked with Opus 5.5 high on a project in Zig. I then asked Sol 6.1 xhigh to review. It found several bugs including 2 critical ones, which Opus acknowledged.
Claude's proof just uses Mathlib's formalization of Riemann's Hypothesis. It's the closest thing you can find to an "agreed" one. It's not like that Claude tried to formalize it from human language from scratch.
> if your Rust program compiles then it’s correct” but that never meant your business logic is correct.
These are two completely different things. Lean doesn't check the "business logic." It checks "types."
In layman's terms:
a.foo();
If this compiles, you know that `a` has a type on which `foo()` is callable (type). You don't know what `foo()` does or what it's supposed to do (business logic).
When writing programs that do things to a spec, it would be a fallacy to suggest that just because the program compiles, it implements the spec. Maybe it's a sound implementation of a different spec.
This is directly analogous to formalizing mathematics - it is totally legitimate to want to verify that the statement actually proven is genuinely the Riemann Hypothesis as expressed in natural language.
As it happens, the statement of RH was already formalized and checked by humans to be faithful (but not proven...) in mathlib, which is why the proof was believed so widely, so quickly.
The lines between the two are blurred in type theory (which Lean is based upon) where you can express your business logic in the types. Look up “propositions as types”.
Thus the type checker actually does verify the logic of it all.
Yeah, I failed to understand what's so funny about this...
If anything I find it worrisome, as people seem to believe human mistakes are somehow inherently better than LLM-corrected statements. I've even seen people praise typos because they make prose "more human."
The only way to keep programming a high-earning professional is to make it a licensed job. Like doctors. You'll have to have a formal degree and get a license to push any code to production, or you go to jail. That's the only possible future where programmers still earn significant more than most desk jobs.
That'll force most of us to leave the industry, of course.
"you can't sell phones without X% domestic software", "you can't share security vulnerabilities overseas", "part of X compliance policy is domestic sign-off", etc
is this a good idea? Different answer than if it'll work. But a market like the US has limited window of time where it's a sufficiently major economy that putting tariffs and policy up to protect an industry may pay off. The US has by far the biggest software industry, so protect it (the labor force) while you can.
So I couldn't just casually make an app? That's always been the problem with licensing. Some company has a bunch of licensed engineers buildings some software app, and then a bunch of kids comes along and makes something similar and it's better so people give the kids their money instead of the licensed engineers.
You can, but you can't sell it on major platforms. Just like you can build your own house on your own land without a contractor license, but if you sell this service to someone else a license is needed.
Yes, OpenAI would be really stupid to do such things intentionally. They should want ANT to go well, at least for a while. ANT is an anchor point for AI labs' values now.
The threshold has been crossed already. It should be mandated to use AI to review human-written code, at least for vulnerability. Code hasn't been reviewed by _(insert what you believe is SOTA here) shouldn't be pushed to production.
There's a leap from "you must get the AI's review" versus "if the AI disagrees with you, you are wrong".
IMO crossing the second threshold will be the de facto death of human accountability. Every engineer, lawyer, doctor, or executive can just say "not my fault, the AI told me to do this".
I don't think we're currently at "if the AI disagrees with you, you are wrong." However we're certainly at "if the AI disagrees with you, you really need to stop whatever you're doing to think twice, thrice and perhaps get a second opinion from an expert."
We've already got the second issue with automated systems as is. More and more companies and government services seem to basically just let the system handle everything and provide little to no mechanism for arguing against those automated decisions.
That's how Google moderates YouTube, and how most modern social media services seem to be 'moderated' in general.
I think the text was originally written entirely by AI (the structure is typical). Then it was partially rewritten.
Some clues that caught my attention on their own:
“Each test launches a real instance of GIMP and performs a small task. Then it reads the result from GIMP. If the result is incorrect, the test fails and tells us what went wrong.”
That’s classic Claude; just like what I read every day. His approach to humanizing everything
And Pangram IS conservative in its estimates of results. With a text this long, I have no doubt about its accuracy.
Where did you get that quote from? It definitely looks like an LLM rewrite of a human-written paragraph from the post
> Each test starts a real GIMP and does one small task. Then it reads the result from GIMP. If the result is not correct, the test fails and tells us what went wrong.
Huh? It does appear both in the Pangram check and in the blog, and in the first commit in the history too. Right after the "What the tests do" heading.
That's not how it works. A 40% score means Pangram detects 40% of this text as AI (and the rest as human) at its usual confidence, rather than assigning a 40% probability to it being AI.
You can also distribute apps without .NET runtime with NativeAOT.
I'm sure there are people who want a C# without GC, but for me it's just... sufficient enough.
reply