Why I'm moving from C# to Rust for High-level Apps

I recently shared some performance benchmarks of moving my blog from C# to Rust - Rust came out to be 4x faster and use 4x less memory.

I've since gotten several questions about why I'm choosing Rust over C# or any other languages so wanted to share my thoughts here.

Why am I looking for another programming language?

For the past several years I've bounced around programming languages - mainly Python, F#, C#, and TypeScript. They're all fine, workable languages but they all have their tradeoffs - there is no perfect programming language (yet).

But I do think there's better languages than others depending on your situation:

• How you like to structure logic
• What you're trying to do / build
• What the people who pay you to build things use / want to use
• Your values when it comes to tradeoffs - what you're willing to sacrifice and what you're not willing to compromise

I never really felt like any of these languages fully fit what I wanted. F# got really close but it also has its edges.

• Python - Python is bad. Meaningful whitespace, non uniform standard library, slow runtime, meh tools (though large recent improvements), unsound types, types just lints, etc. (ofc I still wrote it professionally for 5 years, it was what I was paid to do).
• F# - F# is a great language but the ecosystem and community are tiny and at this point I don't really see that changing any time soon. I've got my own gripes with the syntax (meaningful whitespace, too many implicits) and various edge cases. The lack of docs / community is a long-standing challenge but now exacerbated with the rise of AI which relies on this for a lot of its training and quality.
• C# - A solid language but still lacks expressive types (maybe coming with native unions this year) and has a lot of boilerplate.
• TypeScript - A great upgrade to JS and arguably the best middle ground language but its unsound types and constantly churning ecosystem are frankly exhausting.

So I tried a lot of languages but still hadn't found my missing S-tier language.

Why Rust?

I've always been a bit intimidated by Rust. It's a systems-level programming language sold as a successor of C - I have little interest in manual memory management, the borrow checker and lifetimes stuff seems complicated, and the learning curve is infamous. So it felt like something with a lot of required learning with little gain - I don't want to build systems-level programs and perf is rarely the bottleneck in my systems, it's typically the speed and quality with which I can ship them.

Despite this I did try to learn Rust several years ago as part of a project to build browser-based crypto miners, back when that was cool. I remember attempting to write a small CSV parser to do some analytics on a data export I had and got absolutely nowhere in an hour. Then I built the same thing in Python and had it finished in 15 minutes. So I did try Rust before and had a bad experience.

But fast forward to 2026 and several things have changed that brought a new perspective on Rust:

• I'm doing a 12 week batch at Recurse Center, all centered on exploring technologies and building experiments - learning Rust fits in nicely here
• AI is really good now and I use it all the time which means I have a 24x7 tutor to ask when I get stuck and it can reasonably code a lot of my projects
• Rust is no longer a niche language, now being used by ~15% of the market (a top 15 lang) according to the Stack Overflow dev survey, just behind Go and PHP. Not to mention it's scored the most admired language several years in a row. This high usage means it has more code examples and docs out there which in turn leads to better training and performance from AI.
• I've been learning functional approaches to things for the past few years through F# and bringing them over to my usage in Python, C#, and TypeScript. This may seem random but this functionalish approach is actually a key part of High-Level Rust where you get most of the benefits while limiting pain from async lifetimes and ownership models.

So the stars kind of aligned when I got nerdsniped by a fellow Recurser mentioning Rust as a good high level language. It has expressive types, you don't really need to do manual memory, and it has a large ecosystem and community.

So I did another analysis of available languages in The Missing Programming Language and confirmed that Rust ranks pretty high. Not the highest (C# and Kotlin take that spot) but it did score well on things that were hard to change in other langs like performance and types (types are the bedrock of languages so retrofitting these after the fact takes years and often never achieves what they could if built correctly from the start). The only thing Rust really lacked was good devx due to its infamous learning curve but that felt like something that was relatively elastic - with increasing skills, the right tools, and a standard approach it felt like maybe that devx could be a mixed and eventually a yes.

So I decided to take a week and figure out if the high-level lang thing was real.

My early conclusion after several weeks with the language is yes, Rust is a great high-level language if you abide by a few rules.

High-Level Rust is:

• Immutable data with functional pipelines - ala my time with F#
• Use DDD with traits as interfaces for dependency injection
• Clone often, but avoid expensive clones (they're v bad in Rust) and use smth like LightClone to get compile-time safety for this

With this approach I was able to get the devx up to at least a mixed which made it competitive with the other candidates.

Why Rust over C# / F#?

It's all about the language core. I think C#, F#, and really dotnet are great langs/runtime. They're powerful, performant, and have a great ecosystem behind them. But I do think there's been some shortfalls over the years.

• F# has not gotten the love it deserved and the community, ecosystem has been affected by it. I also disagree with some of the design choices and prefer explicit > implicit even if it's verbose.
• C# does not have the foundation of expressive types it needs to compete as a modern language. Again native unions may fix this for it this year but the lang itself will likely remain verbose for decades to come as they attempt good backwards compatibility.

I think Rust got a lot right at the outset:

• Tooling - cargo and clippy are really good out of the box. Dotnet is getting better but .csproj/.fsproj still read like they're out of the 90s not to mention the unintelligible format that .soln files are in.
• Types - It has expressive types with things like discriminated unions, exhaustive pattern matching, and deep immutability baked in. Maybe no HKTs which functional purists from Idris and Haskell might prefer, but very good types.
• Performance characteristics - Rust's performance characteristics are hard to beat by any language. If you stick to the paved road and avoid heavy full clones in hot paths, you've got a near-metal performance profile on your hands. C#, F#, and dotnet are genuinely fast but Rust is simply faster if you play by the rules.

It's not all good - the devx is an issue, functional purists and low-level experts alike hate the suboptimal types, ergonomics, and memory misses. But largely it got the main things right that I run into day to day.

So it's not really one thing and it's not even anything that big. But for my values and what I'm trying to do, Rust seems like a better fit for me even if it may not seem like it on the surface: webapps, clis, desktop guis, wasm targets.

Next

So why Rust? Because it's the best language I've found to fit my buckets. It scores a 4.5 / 5 on my benchmarks and I think the remaining 0.5 is smth I can largely fill by improving my skills and leveraging AI.

So far, I've really enjoyed this choice. Rust is solid at building webapps and AI is genuinely good at writing passable Rust without running into ownership and lifetime issues - especially when we're building with High-Level Rust.

I have had to build a few tools to help me like LightClone for compile-time enforcement of cheap clones and am currently working on a library to help against tokio async starvation but these are edge case issues vs things I run into day to day.

With AI I think the question shifts more from why use X language to why not use X language. AI is genuinely good at writing most mainstream languages so now it's less about your own expertise in a language and more about the attributes you want in the foundation of your software. For me, right now, Rust is the language that best fits what I want to do and how I like to build.

If you're curious about how I build webapps with Rust, you can check out CloudSeed my fullstack Rust project boilerplate.

And if you want to see my agentic AI engineering workflows, you can find the full workflows I use in the HAMY LABS example repo which is available to HAMINIONs Members.

If you liked this post, you might also like:

• High-Level Rust: Getting 80% of the Benefits with 20% of the Pain
• The Missing Programming Language - Why There's No S-Tier Language (Yet)
• CloudSeed Rust - A Fullstack Rust Boilerplate for Building Webapps in Minutes