Actual curl rewrites in rust
119 points by dasm
119 points by dasm
I don't think any rewrite of curl in Rust will survive mainly because Rust already has a Rust-native HTTP ecosystem and doesn't need yet another HTTP library (and also has most of the other protocols covered). curl is a great achievement for C, and C needs it. Rust doesn't.
it would be interesting to see, rather than a "rewrite of curl", instead a feature compatible piece of software which is instead built upon the HTTP libraries we already have in rust. I.e. same CLI surface but completely separate implementation
I have the impression that the "real" "most usage" of curl is through the libs more than through the CLI.
Like yeah the CLI is used a lot but the reason it's "everywhere" is embedded usages... I think.
("C binding compatibility" is a target though)
But isn’t the magic of curl all the things it does beyond “do this verb at this url with some or no payload”?
Yes, for any given use case there is often a better option than libcurl. But when you add a second requirement then you often find that the library that you chose can't do it. And then you either depend on two different libraries, or just use libcurl.
I find the following statement highly misleading, and possibly misinformed about Rust:
out of the 81 vulnerabilities we have confirmed in curl so far during 2026, 14 were the result of mistakes that most likely would have been avoided had we used a memory-safe language such as rust. That’s 17.3%.
A Rust implementation of curl would thus still have had 67 of those vulnerabilities.
It seems to imply that the only benefit of Rust is preventing pure-memory-safety bugs (buffer overflows, use-after-free), which completely ignores the main benefits of the language:
But the most misleading part is taking AI slop rewrites of Curl as the benchmark. A good benchmark should be an established HTTP library in Rust, such as reqwest -- which according to the RustSec Advisory Database didn't ever have any reported vulnerability. Of course that's misleading too as this doesn't include transitive dependencies such as rustls (5 low/medium vulnerabilities this year). And there may be an issue of under-reporting of vulnerabilities and/or staffing of the RustSec project. But I'd say the comparison is at best inconclusive (I cannot tell if reqwest had more or less relevant vulnerabilities than Curl this year).
What I'd really like to see is a deep dive comparison of a sample of these vulnerabilities: take 10-20 Curl vulnerabilities from this year, and for each one have a fair assessment of whether it would be prevented by the Rust compiler, avoided by idiomatic Rust (i.e. going beyond what the compiler outright rejects), and whether similar bugs have slipped through actual libraries like reqwest.
Of course, one could also argue that reqwest isn't as feature complete as Curl (I haven't checked -- my anecdotal evidence is that reqwest has been sufficient for my side projects). But that would be a very different story as it would become a choice/tradeoff between more features vs. less attack surface.
A good benchmark should be an established HTTP library in Rust, such as reqwest -- which according to the RustSec Advisory Database didn't ever have any reported vulnerability. Of course that's misleading too as this doesn't include transitive dependencies such as rustls
I think that's misleading too :p It's sensible to put something like rustls out of scope, but reqwest has much more substantial dependencies. http had two high/critical vulns. hyper - a related HTTP library from the same author as reqwest - had several more. For HTTP/2, it seems to use h2, which had some low severity vulns too. QUIC is supported via quinn, which apparently has a high severity soundness bug.
Apparently, because that's the one bug I decided to take a look at. It seems to have been making some unjustified assumptions about the layout of some structs - it doesn't seem like it ever approached being exploitable, yet it was slapped with Attack Complexity: Low, Confidentiality Impact: High, CVSS 7.5. This makes me doubt the accuracy of the other severities.
But, back to the point - since Rust developers seem to split their software up into much tinier pieces than C developers, I don't think it makes sense to just look at the advisories for a single crate.
...but I'm also not sure how interesting a better comparison would be. I think it's fairly obvious that, on the long term, a HTTP library written in a memory safe language with a solid type system will be more robust than one written in C.
Projects "rejecting" Rust probably don't do so because they aren't convinced of the benefits of better languages, but because they don't like the tradeoffs made by Rust et al (see: sibling threads). Comparing vulnerability counts won't change their opinion.
yet it was slapped with Attack Complexity: Low, Confidentiality Impact: High, CVSS 7.5. This makes me doubt the accuracy of the other severities.
Back when I paid attention to the RustSec issue tracker, they often regretted CVSS as a poor metric with little practical usefulness.
It's definitely not as featureful.
reqwest seems like it's "just" an HTTP library. Which is great if that's what you want, of course. I definitely get that for a lot of people that's why they use curl or libcurl in the first place, so definitely a reasonable starting point! (i'm not sure i've personally used curl in anger for anything other than HTTP; at work we also use curl for FTP, TFTP, and possibly SCP/SFTP although I can't be sure of those last two).
curl supports around 25 different url schemas according to the man page. So another check might also be useful to look at which url schemes those vulnerabilities affected. From a quick check there were definitely ones against SSH, IMAP, SMB, LDAPS etc. Maybe 15%-20% of them?
From a quick check curl etc also supports a wider range of HTTP related features around auth and proxy handling. It also looks like curl is much more tolerant of bad HTTP server designs, where the server responses are not strictly HTTP compliant, whereas reqwest seems to be pretty strict in terms of compliance. It'd be lovely (and probably a better outcome) if everything was compliant, but in reality that's just not things are , particularly in embedded stacks which aren't going to get overhauled.
I'm not an expert in either, this was just a quick check. But yeah, looks like the attack surface on curl is huge compared to reqwest.
I've not done anything with Rust yet, but it's something that's on my list of things to investigate rewriting parts of our C stack at work.
I threw an LLM at it: roughly 24–35 of the 69 published 2026 curl CVEs would likely have been avoided by idiomatic Rust or Rust-ish design choices (8 of those are the memory bugs already counted). A straight line by line c port would keep almost all of the non memory bugs.
People seem to forget that rust isn't as portable as C, and until it gets quite a bit further, every request to rewrite something is a request to desupport many platforms.
The same rewrite-everything-in-rust people are almost invariably OK with saying that only the important platforms and processor architectures matter, and haven't got a clue and/or simply don't care about the impact this would have on actual, running hardware out in the real world. Out of sight, out of mind. "It doesn't affect me."
And, as we're seeing with the sudo rust rewrite and the coreutils rewrite, along with other corporate inspired pushes such as moving to x86-64 v2, 3 or 4, the people who have nothing to lose are fine with the rest of the world losing those things, even if it means problems for everyone.
I wish the rewrite-everything-in-rust people would actually take the time to understand the effects of what they're pushing for.
As a rewrite-in-anything-better-than-C guy I agree the platform support for Rust is obviously below C, but instead of saying "it doesn't affect me" I would rather pour more resources into expanding platform support, in an effort to rewrite the world away from C.
I know I’m repeating myself but: out of the 81 vulnerabilities we have confirmed in curl so far during 2026, 14 were the result of mistakes that most likely would have been avoided had we used a memory-safe language such as rust. That’s 17.3%.
A Rust implementation of curl would thus still have had 67 of those vulnerabilities.
I am of the opinion that if it could be caught statically then it must be caught statically. Saying "we only blew our foot off 14 times" isn't comforting for critical infrastructure.
only takes one out of bounds write to ruin your day! https://radar.cloudflare.com/zero-wire/java4shell
Rust has substantially caught up in platform support. There's Rust for Haiku, QNX. There's Rust for 68k and AVR. It can target BPF and NVPTX. Thanks to Rust's GCC backend, people even got Rust running on Dreamcast. People managed to build Rust for Windows XP and even 95. The platforms that are left out now are really really niche bottom of the barrel.
Push to x86 with AVX is not Rust's fault. Rust can build for OG Athlon and i686.
Rust requires a supported platform to have 2 maintainers and ability to run tests in CI, so the platforms that are unsupported don't meet the bar - they're so niche that they can't find more than one person willing to do the work or find a still-working hardware that could be used in CI.
The degree of portability people need also varies a lot. I've encountered several codebases recently where they choose C89 'for portability', but 100% of their users are compiling with either GCC or Clang, so they could easily use C23 (or even C++23) without it causing any problems. If your users are all able to use clang, the odds are that they can use Rust, if some are using GCC, you might be okay, if they're using a long tail of other C compilers, then Rust is probably not an option. I've no idea how common curl is in deeply embedded (i.e. not-UNIX-like-if-they-even-have-an-OS) systems, but these have variable Rust support: it's excellent for some, nonexistent for others.
People seem to forget that rust isn't as portable as C
Well. this isn't true is the thing. Rust's portability story is different from that of C: better in some ways, worse in others. For example, Rust is far more easily ported across Unix and Windows than C is, and it also has sufficient abstraction power to write portable async/event-driven code and have Tokio (etc) take care of platform-specific drivers. As a concrete example of this, because someone had ported Tokio to illumos already, I was able to compile cargo-nextest on illumos (very complex event-driven programming) with zero code changes.
Now, a lot of the porting work has been done within curl already, so this applies less to it. But a general statement that Rust is less portable than C is inaccurate.
When the topic is portability, it really depends on who's pushing for the rewrite. As with X11 to Wayland, sometimes it's the developers feeling at their limits with the old tech.
You porting a compiler or compatibility layer of some sort doesn't opt every C developer whose project suddenly became compatible into an obligation to support a platform they never intended to support and possibly never heard of.
See, for example: https://blog.yossarian.net/2021/02/28/Weird-architectures-werent-supported-to-begin-with
But the point being, it goes from "possible to be portable with meticulous effort" to "impossible to be portable at all without becoming a compiler developer." (and not just any compiler developer, but working on the most massive and complex compilers in existence)
And true, few people do actually bother to write portable code. But I very meticulously do, even for projects that don't need it; and the SQLite devs do; and Curl did/does; and so do many other projects.
As an anecdote, I've run into one or two Rust compiler bugs rendering the language unusable for things as simple as embedded ARM32 targets. Targets that, while GCC is preferred, Clang still works for, so it has to be some frontend Rust issue rather than LLVM. So not even that far off the beaten path (i.e. "modern desktops and smartphones"), still in architectures nominally supported, and Rust already becomes largely unusable.
I've run into quite a number of Rust compiler bugs rendering the language unusable for things as simple as embedded ARM32 targets.
Could you share links to the bug reports? I would be intrigued to see what the problems were, and on which specific platform, because ARM32 support runs the gamut from tier 2 to tier 3. It could be a bug on the rustc side, but it could also be a bug on the llvm side that gets excercised by rustc but not clang (one could argue the bug exists in the combination of rustc+llvm+your platform).
Admittedly I never actually filed bug reports (and "quite a number" is an exaggeration, it was one or two) because I just couldn't be assed to figure out a minimum reproduction when I was just messing around with using Rust alongside C for the project. It was for a GBA homebrew game (ARMv4T), had to do with interwork between ARM32 and Thumb (not Thumb-2) code; in mixed assembly, C, and Rust sources. I think it was either general ABI issues (something related to veneers maybe?), or things being consistently linked wrong or something, I can't quite remember. (I've run into (easier-to-reproduce) miscompiles in GCC's Ada/GNAT with this setup/target too XD, just an odd target and I guess I tend to push languages pretty hard). I'll see if I can dig up the sources that caused it, it could've been incidentally fixed by now.
For ABI issues, see https://faultlore.com/abi-cafe/
The C standard doesn't promise you any ABI. It's an under-documented fragile mess, so in practice it requires testing and tweaking every combination until it seems to work. Rust has already found cases where even gcc and clang disagree.
It was not following the explicit wording of AAPCS, § 5.3 and § 5.6 if my memory about it being interworking/veneers is correct. And per your second paragraph, AAPCS § 7 and AAELF which gives a concrete C→machine ABI for anything that would've been relevant to my issues (I for sure manually verified the assembly from C and Rust when I noticed issues, and I know my own assembly followed AAPCS)
Thanks. I stand corrected.
You're broadly correct, there is ambiguity with things like threading and more complex OS/hosted stuff, and for portable code there's no ABI you could rely on (your statement about "C code isn't portable, just ported" is exactly how I'd put it. See also: the Faultlore post about "C isn't a programming language anymore").
But for a single embedded target in explicitly non-portable code there's usually a concrete ABI you can trust for at least most of ISO C stuff. Which is good because freestanding environments usually need a lot of assembly that you need to be able to reliably call and interact with lol
See also: the Faultlore post about "C isn't a programming language anymore").
Here's the link: https://faultlore.com/blah/c-isnt-a-language/
That's all true, but it doesn't change the fact that, unless you're paying them to do it, you don't get to veto developer decisions to migrate to a language that they believe will reduce the cognitive burden of supporting the platforms they intend to support.
Anything more is entitlement.
So it's not entitled to demand people rewrite their mature programs from scratch in Rust like a subset of the community has been doing to projects for years?
Please refer back to my initial post.
When the topic is portability, it really depends on who's pushing for the rewrite.
That's the whole point I was making. Of course it's entitled when random Joes push for it... but it's also entitled when random Joes push for developers to not make a decision that would cut against goals they never set.
You don't get to hijack their roadmap by opting yourself into compatibility.
Oh yeah, okay. I agree with that, I just think it should be the project's decision. e.g. SQLite where they highly prioritize stability and portability above all else (and have fantastic testing that catches any of the issues Rust would've solved easier), vs. Linux where they are more concerned with driver bugs that affect the larger kernel and security issues at this point.
Although from a rewrite perspective (rather than "new code in <>, leave the old C code" or such) I think it has been kinda demonstrated over and over that it's not a particularly good idea lol; but that's just my opinion/advice and projects should be able to do what they want.
Although from a rewrite perspective (rather than "new code in <>, leave the old C code" or such) I think it has been kinda demonstrated over and over that it's not a particularly good idea lol;
Seems like it worked out pretty well for Fish, though
librsvg too, but that's where the nuance comes in.
Part of the reason it's possible at all with Rust is that it's got good C<->Rust interop which makes incremental porting tractable (i.e. The downsides of rewriting are more mitigated the more incremental you can make it) and I'd say the tipping point is when continued development in C is more difficult than an incremental rewrite into Rust.
It's another form of "at some point, you may find that technical debt has grown too big and is impeding your ability to develop the codebase"... just with the technical debt being centred around the relationship between C, how the developer uses it, how the project's scale has grown, etc.
I thought Anders Hejlsberg made a useful distinction between “porting” code from one language to another (TypeScript to Golang in that instance) as opposed to “rewriting”: porting is a lot more mechanical and (unlike the rewrites that Joel Spolsky was warning against) isn’t trying to address problems with the codebase (other than the language it is written in). IIRC the Fish port was similar: they translated to Rust piece by piece keeping Fish working without changing functionality, and only after the port was complete, started to tackle the improvements that Rust makes possible.
Fish didn't refrain from making small changes and improvements along the way. It looked like a "porting is just a normal ongoing maintenance task" workflow.
Although from a rewrite perspective (rather than "new code in <>, leave the old C code" or such) I think it has been kinda demonstrated over and over that it's not a particularly good idea lol; but that's just my opinion/advice and projects should be able to do what they want.
Agreed. I like to point people at https://www.joelonsoftware.com/2000/04/06/things-you-should-never-do-part-i/ for that one.
Of course it depends on who is pushing for a rewrite. I stated that my issue is with the rewrite-everything-in-rust crowd, who, generally, like to parrot what they've read or heard because it makes them feel smarter, not too unlike the people who like to tell everyone else that self-hosting email can't be done properly.
You porting a compiler or compatibility layer of some sort doesn't opt every C developer whose project suddenly became compatible into an obligation to support a platform they never intended to support and possibly never heard of.
Has anyone suggested that?
Has anyone suggested that?
That was what was implied by the outrage at pyca/cryptography deciding to migrate to Rust ASN.1 parsing as referenced in https://blog.yossarian.net/2021/02/28/Weird-architectures-werent-supported-to-begin-with
It broke compatibility with compiler targets the pyca/cryptography people had never intended to support.
Similarly, it's also often a request to break or significantly lengthen large parts of the bootstrap chain, at a time when people are starting to get really serious about software provenance.
Can you name some platforms that are important to you that Rust doesn't yet support? I am vibing an LLVM replacement and it would be interesting to have support for a platform that existing Rust doesn't, though I thought LLVM support was pretty broad. Should I check in platforms that GCC has that LLVM doesn't?
I compile packages for lots of less common platforms like SuperH, m68k, VAX, Alpha, et cetera, and of course people will gladly dismiss those as too niche to worry about.
Instead, I'll give you an example of a device that's still widely used: I'm using dozens of PogoPlugs as VPN endpoints, firewalls, NAT routers, et cetera. The processor is earmv5, and while I've seen rust work (ish) for earmv6hf (which is already being treated as though the trip to the back of the barn will come any day), I've never seen it work properly for earmv4 or earmv5.
Each PogoPlug is running the latest NetBSD with BIND 9.20, nmap, mtr, tinc, and all sorts of other utilities, and none of them have any issues with earmv5. But when I run across a rust or Go tool, there's just no way to use them.
Also, I'm not going to put tools written in rust or Go on my aarch64 or amd64 machines, because what's the point of adding a tool to your toolbox that you can only use in certain places and not others? This is what, I think, a lot of rust proponents miss.
One final thing worth noting is that number of rust dependencies needed for even basic tools is, well, rather large.
As someone with various bits of old open hardware that still work (eg. OpenPandora, Cubox i4-Pro, Rowetel IP04, WRT54G, etc.), I certainly can sympathize but, at the same time, as someone who's burned out multiple times trying to live up to my own standards for my creations, who now uses Rust as a crutch to avoid doing that again, I also can't.
I'd suggest keeping an eye on rustc_codegen_gcc (progress reports)... the project to write a GCC backend for rustc as an alternative to the existing LLVM one and the Cranelift one in development, the .NET CLR one that appears to be on hiatus early in its development, and the Microsoft-internal one they're using to integrate with the MSVC toolchain.
I imagine that should solve your earmv5 problem unless you're saying you're depending on old GCC in the same way my retro-hobby programming depends on decades-old releases of relevant compilers, in which case I very much sympathize with your plight and don't sympathize with being expected to stay on languages that put the burden on me.
(There's also an effort to write a second Rust compiler in C++ so it can be merged into GCC's upstream, but I imagine that'll mainly be for projects like the Linux kernel and I question how many crates and applications which depend on them will actively work to maintain compatibility, given that we see the same "one supported compiler per platform, and only a handful of officially supported platforms" dynamic in C and C++)
One final thing worth noting is that number of rust dependencies needed for even basic tools is, well, rather large.
Two things to keep in mind there:
First, it's misleading to compare raw dependency counts. https://wiki.alopex.li/LetsBeRealAboutDependencies goes into more detail, but:
Second, it's generally not the number of dependencies needed, but the number of dependencies used.
For example, Clap is a popular argument parser that I tend to use, despite it being the heaviest option, because all the lighter alternatives are missing one of automatic --help generation, a #[derive]-based API (code generation off an annotated struct), and support for handling non-UTF8-able paths instead of just panicking (ASSERT-ing).
However, if you don't want all that and you don't mind omitting support for things like -rav short argument coalescing, --foo=.../--foo ... format variability, and all the other little things we've come to expect out of a well-behaving Unixoid argument parser these days, it's perfectly possible to very concisely write a bespoke argument parser using loop, match, and slice patterns.
https://doc.rust-lang.org/rustc/platform-support/armv5te-none-eabi.html is this not the same platform as earmv5? I get that tier 3 platform support is not "super well supported" but it feels like something. Or even just the arm-none target... doesn't that "work"?
One final thing worth noting is that number of rust dependencies needed for even basic tools is, well, rather large.
feel you on that one for sure. Like even if you get the compilation up you're maybe looking at a bunch of random things to deal with. Wish things could feel a bit smaller.
z80, Intel Itanium (for future proofing), big-endian x86-64 (hypothetical), SH4, xtensa
Rust does support xtensa FYI. And while SH4 is not officially supported it does work via the GCC codegen backend (people have ran Rust on a Dreamcast).
The others, sure. Though I think you're trolling with big-endian x86-64. What would it even mean to support a hypothetical platform? Guess what the ABI might look like then implement that? To what end?
It's a referential joke about old OpenSSL, which had scaffolding for a hypothetical big-endian x86-64, which was discovered as one of the "WTFs" after Heartbleed.
It's not hypothetical though! VOS Stratus and HPE NonStop are both big endian environments even when running on x86.
Should you care about this, or put any effort in to support it? No. But it's real :D
Huh, I thought 8-bit micros were horrible targets (and hosts) for compilers, and you couldn’t expect much more than Small-C. But no, Hi-Tech C is a fairly complete C89 compiler on the Z80 (according to its manual). And sdcc is an actively maintained cross compiler supporting recent C standards. Crikey, TIL.
To be fair, those existing doesn't necessarily disagree with 8-bit micros being horrible targets for compilers. As anyone who has programmed for a PIC microcontroller will let you know, you can absolutely make a C compiler that is not worth using in practice.
The 6809 makes a decent C target (four index registers, which includes the default system stack register), two 8-bit accumulators that can be used as a 16-bit accumulator, and position-independent code, it's not a bad target for an 8-bit C target. The Z80 as a C target isn't that too silly; it's much better than C on the 8080 that's for sure. Other 8-bit CPUs don't make for a decent C target in my opinion.
There's this great slide Daniel includes in his talks every now and then that shows just how many operating systems curl supports. I wonder how many of these are supported by Rust.
Note how they carefully never mention "support". These are platforms that somebody has gotten curl to run on. That's quite different. The curl maintainers don't test on all of these platforms or distribute build artifacts for all of them.
Rust has a pretty big list of platforms that are officially supported. There is a bigger set of platforms that people have gotten Rust to run on.
Rust supports 336 platforms upstream, and there are others supported in private projects. Platform support is not 1:1 to OS support.
There’s a lot of moving the goalposts here:
Not that I think that a Rust rewrite of curl (esp a poorly vibecoded one) is a worthy use of time and money, but all of the above aren’t real arguments against that if eg you have critical infrastructure that does need a safer version of libcurl.
Edit: I also think curl maintainers are right that’s it’s fucking annoying that vibecoders claim to rewrite curl, and as the maintainers they don’t own them good faith intellectual engagement.
Last time it was half, now it’s 17%?
Correct. You're linking to a blog post from 2021. We are now in 2026, 5 years later. These are updated numbers from recent bugs. That's not a statistical anomaly but a result of better testing, fuzzing, static analysers, and now LLM analysers. There is no "moving goalposts" fallacy when the goalpost has literally moved.
Only 17% of your bugs were memory issues? No reason to change to a more powerful programming language at all!
Someone has been able to largely automate the process of migrating the codebase? But that was last week! They are already behind!
No comments on the quality of the port, just mocking people who want something that isn't written using high level assembly that is full of footguns.
I can understand waiting until it's supported in GCC, given the environments curl is used in. But the closest they get is advertising their stable ABI – which Rust can maintain for C interfaces.
Just say upfront that all y'all don't want to program in Rust.. I'm sure your community is nice and outsiders giving unwanted advice is irritating. But this is the vibes based reasoning of someone sitting on their porch with a shot gun.
Rewrites won't happen in Open Source because every project is run by one or more BDFL that like their existing codebase and programming in C.
Python will forever be slow and have poorly defined semantics because the CPython mainteners like maintaining their existing C codebase. But at least they are upfront about it.
So... I don't think you're being particularly kind in your response here but I'm going to engage a bit.
I can understand waiting until it's supported in GCC, given the environments curl is used in. But the closest they get is advertising their stable ABI – which Rust can maintain for C interfaces.
That's not the "closest". Have a look at https://doc.rust-lang.org/nightly/rustc/platform-support.html and look at what the definition of Tier 2 is. 32-bit ARM is everywhere in embedded devices and curl is all over the place on embedded devices. MIPS 32-bit and 64-bit are Tier 3. ARM themselves provide supported versions of GCC. Rust might be able to provide a stable C interface to the code, but they provide no serious support for the compiler actually working on a lot of common embedded platforms.
Someone has been able to largely automate the process of migrating the codebase?
No comments on the quality of the port
And thanks to it being straight up vibecoded, the majority of the code there has never had a single human eyeball look at it. I'm not anti-LLM by any means, I use these tools daily, but... using an LLM to port 200kloc from one language to another and call it a drop-in replacement? C'mon now.
Rewrites won't happen in Open Source because every project is run by one or more BDFL that like their existing codebase and programming in C.
That's the beauty of Open Source in this case. We already have two examples (which Daniel did link to) where people have done the port. What the people who did that port have not done is... find any kind of critical mass of people who would rather use and work on that port over the existing C implementation.
The thing I've never understood about the "rewrite it in Rust" (with or without an LLM) idea is that they're shooting themselves in the both feet:
If I have a codebase that I've been working on for 20 years and know inside and out, there is very little probability that I would like to throw away all of that knowledge because someone else thinks I should. Expecting a maintainer to drop their well-known and grown codebase for an LLM-built version in a different language is pretty wild.
It's adding very little net value. Yes, likely a decrease in memory-safety errors (+gross value). Also likely to be incompatibility bugs where the behaviour is different than what the C code did (--gross value). Also a massive loss of institutional knowledge by the people who know the code the best (--gross value) and in this case, there's no one who does know the new codebase at all.
My recommendation for someone who's proposing "rewriting something in Rust" is to, instead, start a new project that they're willing to own and maintain, and make it better than the code they're proposing replacing. Find the rough edges in the curl API and make them better. Don't try to convince the maintainer of the existing project to toss their life's work, try to convince the world that you've got a better library for making HTTP/etc (many!) requests from C or C++ code, or any language with a C FFI.
I'm sure your community is nice and outsiders giving unwanted advice is irritating.
I mean yes, but the problem isn't strictly the unsolicited advice, it's showing up and telling someone to do a massive amount of work (even if you use an LLM to "translate" from C to Rust, how long is it going to take you to a) actually trust that translation, and b) be anywhere nearly as proficient with the vibe-generated codebase as you are with the one you've been working on since last century) without any skin in the game.
That's not the "closest". Have a look at https://doc.rust-lang.org/nightly/rustc/platform-support.html and look at what the definition of Tier 2 is. 32-bit ARM is everywhere in embedded devices and curl is all over the place on embedded devices.
To be fair to them, the standards for Tier 1 blow GCC's testing out of the water. It's basically "someone is providing us a CI farm/cloud where we can run the compiler and test suite on it, bare-metal, and it's powerful enough that we gate accepting changesets on the completion of CI runs that include it".
(Back before Microsoft started donating Azure capacity, I remember there was a period when CI was starting to become a bottleneck on Rust development.)
In essence, I don't think it's possible for 32-bit ARM to be Tier 1 because I don't think anyone makes 32-bit ARM servers powerful enough and, if they do, apparently nobody is willing to pay to donate the capacity to get it to Tier 1.
When they say "automated tests are not always run" about Tier 2, they mean it in the context of "merging changes into the main branch is blocked on all Tier 1 CI runs passing".
According to https://www.gnu.org/software/gcc/testing/, how it works for GCC is:
- H.J. Lu has several automated Linux/ia32 and Linux/Intel64 testers which build GCC and run the GCC testsuite as well as SPEC CPU 2K/2006 with various optimization options. All test results are sent to the gcc-testresults mailing list and any regressions are sent to the gcc-regression mailing list.
- Several people perform regular builds and regression test runs and send their test results to the gcc-testresults mailing list.
- Jan-Benedict Glaw is running a build robot that tries to build various cross-targets (stage1 only) on some machines.
It's akin to how you can't compare Rust vs. C or C++ CVE counts one-to-one because, by the standards of C or C++ developers, the people reporting Rust CVEs are hypochondriacs.