mrustc
rust
Our great sponsors
mrustc | rust | |
---|---|---|
75 | 2,680 | |
2,081 | 92,627 | |
- | 2.4% | |
9.0 | 10.0 | |
5 days ago | 3 days ago | |
C++ | Rust | |
MIT License | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
mrustc
-
Why do lifetimes need to be leaky?
No, you don't. Existential proof: mrustc ignores lifetimes. Just flat out simply ignores. It changes some corner-cases related to HRBT, yet rustc compiled by mrustc works (that's BTW mrustc exist: to bootsrap the rustc compiler).
-
I think C++ is still a desirable coding platform compared to Rust
Incidentally C++ is the only way to bootstrap rust without rust today.
-
Rust – Faster compilation with the parallel front-end in nightly
Well, there is mrustc[0], a Rust compiler that doesn't include a borrow-checker, so it's possible to compile (at least some versions of) Rust without a borrow checker, though it might not result in the most optimized code.
AFAIK there are some optimization like the infamous `noalias` optimization (which took several tries to get turned on[1]) that uses information established during borrow checking.
I'm also not sure what the relation with NLL (non-lexical lifetimes) is, where I would assume you would need at least a primitive borrow-checker to establish some information that the backend might be interested in. Then again, mrustc compiles Rust versions that have NLL features without a borrow-checker, so it's again probably more on the optimization side than being essential.
- Running the "Reflections on Trusting Trust" Compiler
-
Forty years of GNU and the free software movement
> Maybe another memory safe language, but Rust has severe bootstrapping issues which is a hard sell for distros that care about source to binary transparency.
It is possible to bootstrap rustc from just GCC relatively easily, although it's a little bit time consuming.
You can use mrustc to bootstrap Rust 1.54: https://github.com/thepowersgang/mrustc
And from then you can go through each version all the way to the current 1.72. (Each new Rust version officially needs the previous one to compile.)
-
Building rustc on sparcv9 Solaris
Have you tried this route : https://github.com/thepowersgang/mrustc ?
-
GCC 13 and the state of gccrs
Mrustc supports Rust 1.54.0 today
- Any alternate Rust compilers?
-
Stop Comparing Rust to Old C++
There are three. The official one, mrustc (no borrow checker, but can essentially compile the official rustc) and GCC (can't really compile anything substantial yet). Only rustc is production-ready though.
-
Can I make it so that only the newest version of Rust gets installed?
That probably depends on what you mean by problematic. Having an ever increasing chain of dependencies isn’t the most desirable situation so there has been some work to trim the bootstrap chain. In 2018, when the blogpost I linked above was written, mrustc was used to bootstrap rust 1.19.0; now mrustc can bootstrap rust 1.54.0 so the chain to recent versions is much shorter than if all those intervening versions back through 1.19.0 needed to be built. https://github.com/thepowersgang/mrustc
rust
- Rust Weird Exprs
- Critical safety flaw found in Rust on Windows (CVE-2024-24576)
-
Unformat Rust code into perfect rectangles
Almost fixed the compiler: https://github.com/rust-lang/rust/pull/123325
-
Implement React v18 from Scratch Using WASM and Rust - [1] Build the Project
Rust: A secure, efficient, and modern programming language (omitting ten thousand words). You can simply follow the installation instructions provided on the official website.
-
Show HN: Fancy-ANSI – Small JavaScript library for converting ANSI to HTML
Recently did something similar in Rust but for generating SVGs. We've adopted it for snapshot testing of cargo and rustc's output. Don't have a good PR handy for showing Github's rendering of changes in the SVG (text, side-by-side, swiping) but https://github.com/rust-lang/rust/pull/121877/files has newly added SVGs.
To see what is supported, see the screenshot in the docs: https://docs.rs/anstyle-svg/latest/anstyle_svg/
-
Upgrading Hundreds of Kubernetes Clusters
We strongly believe in Rust as a powerful language for building production-grade software, especially for systems like ours that run alongside Kubernetes.
-
What Are Const Generics and How Are They Used in Rust?
The above Assert<{N % 2 == 1}> requires #![feature(generic_const_exprs)] and the nightly toolchain. See https://github.com/rust-lang/rust/issues/76560 for more info.
- Enable frame pointers for the Rust standard library
-
Learning Rust: Structuring Data with Structs
Another week, another dive into Rust. This time, we're delving into structs. Structs bear resemblance to interfaces in TypeScript, enabling the grouping of intricate data sets within an object, much like TypeScript/JavaScript. Rust also accommodates functions within these structs, offering a semblance of classes, albeit with distinctions. Let's delve into this topic.
-
Algorithms for Modern Hardware
There’s also other reasons. For example, take binary search:
* prefetch + cmov. These should be part of the STL but languages and compilers struggle to emit the cmov properly (Rust’s been broken for 6 years: https://github.com/rust-lang/rust/issues/53823). Prefetch is an interesting one because while you do optimize the binary search in a micro benchmark, you’re potentially putting extra pressure on the cache with “garbage” data which means it’s a greedy optimization that might hurt surrounding code. Probably should have separate implementations as binary search isn’t necessarily always in the hot path.
* Eytzinger layout has additional limitations that are often not discussed when pointing out “hey this is faster”. Adding elements is non-trivial since you first have to add + sort (as you would for binary search) and then rebuild a new parallel eytzinger layout from scratch (i.e. you’d have it be an index of pointers rather than the values themselves which adds memory overhead + indirection for the comparisons). You can’t find the “insertion” position for non-existent elements which means it can’t be used for std::lower_bound (i.e. if the element doesn’t exist, you just get None back instead of Err(position where it can be slotted in to maintain order).
Basically, optimizations can sometimes rely on changing the problem domain so that you can trade off features of the algorithm against the runtime. These kinds of algorithms can be a bad fit for a standard library which aims to be a toolbox of “good enough” algorithms and data structures for problems that appear very very frequently. Or they could be part of the standard library toolkit just under a different name but you also have to balance that against maintenance concerns.
What are some alternatives?
gccrs - GCC Front-End for Rust
carbon-lang - Carbon Language's main repository: documents, design, implementation, and related tools. (NOTE: Carbon Language is experimental; see README)
gccrs - GCC Front-End for Rust
zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.
llvm-cbe - resurrected LLVM "C Backend", with improvements
Nim - Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula. Its design focuses on efficiency, expressiveness, and elegance (in that order of priority).
rust-ttapi
Odin - Odin Programming Language
miri - An interpreter for Rust's mid-level intermediate representation
Elixir - Elixir is a dynamic, functional language for building scalable and maintainable applications
gcc-rust - a (WIP) Rust frontend for gcc / a gcc backend for rustc
Rustup - The Rust toolchain installer