gccrs Blog

I agree with the sentiment somewhat. Some rust libraries are dying, while some great new ones thrive (recently found iroh and wgpu to name a few). Everyone wants to write a game engine or some fun project and then abandon it, but no one wants to write a game. No application software has really "cemented" itself in the global ecosystem. Except for maybe ripgrep? I would like to see support for more compilers (https://rust-gcc.github.io/), more interoperability with C/C++, better support for cross-compilation. Maybe less reliance on crates.io, static linking, and permissive licenses. Still, I see Rust as the natural progression from C++. It has enough momentum to flatten all competitors (Carbon, Zig, Nim, Go) except scripting languages

> compiling Rust programs for platforms not supported by LLVM For this, gcc-rs[1][2] is the most promising candidate. [1] https://rust-gcc.github.io/ [2] https://github.com/Rust-GCC/gccrs

There is a Rust front-end for GCC that is under active development [1]. If the chip vendors are not willing to develop and upstream a LLVM back-end then they can start contributing to it as an alternative. [1] https://rust-gcc.github.io/

You are right, this much more ambitious than I though! Here is more information about the project, for the curious: https://rust-gcc.github.io/

> They plan to use the exact same code! Did they announce a change of plans? Their website just says that they have no plans for a borrow checker (i.e. it's not required to actually implement rust). From the website for the project: > There are no immediate plans for a borrow checker as this is not required to compile rust code and is the last pass in the RustC compiler. This can be handled as a separate project when we get to that point. Link here: https://rust-gcc.github.io/

Luckily, the gccrs developemt work is now backed by a company who is paying the main developer: > https://rust-gcc.github.io/ Having Rust support directly built into GCC means Rust code in kernel will not limit portability and no additional toolchain will be needed.

The biggest barrier is probably going to be the diff between architectures supported by Linux and those supported by Rust. It'll take several years for Linux to prune some of the lesser used architectures [1] and also years for Rust to add support on either LLVM [2] or via a WIP GCC frontend [3]. So while most people involved seem to supportive, including Torvalds and GKH, it will take time for any non-driver code to be written in Rust. [1] - https://lore.kernel.org/lkml/CAK8P3a2VW8T+yYUG1pn1yR-5eU4jJXe1+M_ot6DA… [2] - https://github.com/fishinabarrel/linux-kernel-module-rust/issues/112 [3] - https://rust-gcc.github.io

This talk is about https://rust-gcc.github.io

As background, this is a separate effort from the "GCC Rust" project. This project is using libgccjit, which is basically a library interface to GCC (intended for JITs, but here being used for ahead-of-time compilation), as an alternative to LLVM for the standard Rust compiler ("rustc" aka https://github.com/rust-lang/rust). This allows reusing all the logic inside the Rust compiler for compiling code, checking types and lifetimes, etc. while targeting platforms that LLVM does not support. The GCC Rust project https://rust-gcc.github.io/ is an alternative implementation of Rust inside the GCC project, in much the same way that, say, gccgo is an alternative implementation of Go or GCJ is an alternative implementation of Java. It's adding a Rust frontend to GCC, instead of adding a GCC backend to rustc. From a pure functionality standpoint, the libgccjit approach is preferable, because as soon as a feature is in rustc, it's usable. You share the same implementation. Personally, I'm very happy to see it approved because it immediately solves a difficult issue with getting Rust into the Linux kernel - that the Linux kernel supports many more architectures than LLVM does, and rustc doesn't even support all of those (https://github.com/fishinabarrel/linux-kernel-module-rust/issues/112 is where things were last time I looked in detail), and without some answer for how to get things to compile on every architecture, Rust kernel code will have to be limited to drivers that are…

Some links on the most promising effort so far, gccrs https://opensrcsec.com/open_source_security_announces_rust_gcc_funding https://www.embecosm.com/2021/01/12/gcc-rust-how-it-can-be-achieved/ https://rust-gcc.github.io/ This is an entirely new frontend written in C++, that shares no code with rustc (the official rust compiler). It might be merged some day in GCC proper. But honestly, I'm more excited for rustc_codegen_gcc: https://github.com/antoyo/rustc_codegen_gcc It adds gcc as an alternative backend of the official Rust compiler. That way it is much more feasible to stay up to date as the language evolves. Anyway the former two don't actually work right now. The one that does work today is mrustc, or at least it works for bootstrapping rustc; it doesn't have a borrow checker though (and instead assumes the program is correct). Also, mrustc isn't based on gcc. https://github.com/thepowersgang/mrustc (There's a fourth project, https://github.com/sapir/gcc-rust, but it seems abandoned)