[mtlmtlmtlmtl]

Has anyone put this to serious use? I played around with it at some point when it was fairly new and at that time I was able to transpile the C into Rust just fine, but that didn't help me much. The idea was to be able to use the Rust toolchain to better understand the code, but the resulting Rust code was even less understandable, and also much harder to refactor. In this case I wasn't attempting a rewrite per se, just trying to understand a C codebase plagued with memory safety issues. Quickly gave up on this avenue at that point and just started carefully refactoring the C to make the bugs easier to shake out.

Would love to see a technical write up of someone outside Immunant using this on a real world codebase for whatever purpose.

[brundolf]

> In this case I wasn't attempting a rewrite per se, just trying to understand a C codebase plagued with memory safety issues

I think this is your problem; to my understanding it's not really the point of the project. The resulting code is meant to be something you can gradually refactor, not something that's immediately better or more understandable. Even if a given piece of code is harder to refactor, it's still important on a large pre-existing project to be able to immediately switch over to the new toolchain all at once, without having to manually refactor/rewrite all of the code all at once

[mtlmtlmtlmtl]

Well, the hope was that maybe the work to get the transpiled code to the state where I could do some borrow-checking might somehow be less than just having at the C itself directly, but yeah, no cigar back them at least.

And I wanted an excuse to play around with rust some more :D

[sm_ts]

Conditional to your definition of "serious", I did: https://github.com/64kramsystem/catacomb_ii-64k. I essentially don't do technical writing anymore (and I had the impression that this topic isn't generally considered interesting), however, my considerations are:

1. there are three levels of refactoring: removing the extensive (unbearable, to be honest) boilerplate that C2Rust introduces; converting the design from "C with Rust syntax" to safe Rust; convert the design from unidiomatic Rust to idiomatic

2. as another poster pointed out, for non-trivial projects, writing refactoring tooling is a must (to remove the C2Rust boilerplate), in order to perform step 1

3. design refactoring (step 3) difficulty depends on the source code design; the code I worked with was relatively hard to refactor, as it was old (school), in particular, lots of globals; the difficulty was caused by the typical freedoms that C gives and Rust doesn't (in other words, the very obvious design differences between C and Rust); somebody did a C to Rust port of (I think) Zstd, which is a modern codebase, and I think much easier to work with (also because of less, or possibly no, external dependencies)

4. regarding the code understanding, if one performs the translation in the three-steps mentioned in point 1, at the end of step 2, one has effectively a safe Rust codebase, "just" unidiomatic

5. in terms of quantity of changes (but not time spent), it's possible to perform the bulk of step 3 with rather local thinking (understanding), but of course, most of the time spent is on major design changes

6. beside a few steps, I was able to perform a conversion in self-contained steps, which is very good news for this type of work. Even better, it's possible (but that's a niche case) to port an SDL project by using at the same time the C library and the Rust one!

7. however, I can imagine projects like Wolfenstein 3d to be very hard to port, since it's hard to port memory allocators and similar

99. most important of all: just converting to Rust will quickly (even immediately) find bugs in the source; I've found approximately four bugs in the source code, including one by Carmack!

All in all, I find this tool great, but somebody needs to work on refactoring tools, and C2Rust's output must be improved in order to be found usable by the public.

[mtlmtlmtlmtl]

By serious I just meant any real world codebase at all. A full game, even if an old, smaller one is way more than I expected anyone to have done!

Definitely will thumb through the git history to get an idea of the refactoring efforts.

Thanks a bunch!

[acomjean]

Transpiled code… way back in the day we had Fortran machine converted to Ada. While it worked it was unreadable and not maintainable. Adatran we called it. Hopefully they do better now.. but from you experience it is the same.

[mtlmtlmtlmtl]

Though be fair the last time I tried it, it was brand new and just barely successful at transpiling at all. Little to no work of the type detailed in TFA had been done at all.