neat
mrustc
neat | mrustc | |
---|---|---|
3 | 75 | |
110 | 2,087 | |
0.9% | - | |
9.4 | 8.8 | |
13 days ago | 7 days ago | |
D | C++ | |
BSD 3-clause "New" or "Revised" License | MIT License |
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.
neat
-
The Neat Programming Language
It runs on plain C ABI, so you can just define C functions as `extern(C)`, just as you would in D. But you can also use `std.macro.cimport` to import C headers directly. Check out the Dragon demo, https://github.com/Neat-Lang/neat/blob/master/demos/dragon.n... :
macro import std.macro.cimport;
-
Running the "Reflections on Trusting Trust" Compiler
Funny sidestory: The way my compiler ( https://github.com/neat-lang/neat ) used to build is, two years ago there was an initial compiler that was written in D. And every time you checked it out on a new system, there was a file with a list of breaking commits, and it would:
- git clone itself in a subfolder
-
Show HN: C3 – a C alternative that looks like C
Sure, but keep in mind it's pre-pre-alpha and the current released version is kind of outdated (ping me if you actually want to try it):
https://github.com/neat-lang/neat
This is more a D-like than a C-like, but it only breaks C syntax in areas where IMO C straight up made the wrong call, like the inside-out type syntax.
The thing I'm most proud of is the full-powered macro system, which is really more of a compile-time compiler plugin system.
A good example of a macro would be listcomprehensions: https://github.com/Neat-Lang/neat/blob/master/src/neat/macro...
You can tell it's just compiler code that happens to be loaded at project compiletime.
`compiler.$expr xxx` is itself a macro, that parses an expression `xxx` and returns an expression that creates a syntax tree that, when compiled, is equivalent to having written `xxx`. It's effectively the opposite of `eval`. In that expression, `$identifier` is expanded to a variable reference to "identifier".
So `ASTSymbol test = compiler.$expr $where && $test;` is equivalent to `ASTSymbol test = new ASTBinary("&&", where, test)`. (This shows its worth as expressions become more expansive.)
All in all, this lets you write `bool b = [all a == 5 for a in array]`, and it's exactly equivalent to a plain for loop. You can see the exact for loop at line 103 in that file. `({ })` is stolen from gcc; google "statement expression".
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.
https://github.com/thepowersgang/mrustc
-
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.
[0]: https://github.com/thepowersgang/mrustc
[1]: https://stackoverflow.com/a/57259339
- 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
What are some alternatives?
c4 - C in four functions
gccrs - GCC Front-End for Rust
mescc-tools-seed - A place for public review of the posix port of stage0
gccrs - GCC Front-End for Rust
archlinux-installer-script - Arch Linux install script. Only performs the minimal steps for booting into arch. 75 lines of script with full progress messages and tutorial.
llvm-cbe - resurrected LLVM "C Backend", with improvements
nixpkgs - Nix Packages collection & NixOS
rust-ttapi
related_post_gen - Data Processing benchmark featuring Rust, Go, Swift, Zig, Julia etc.
miri - An interpreter for Rust's mid-level intermediate representation
gcc-rust - a (WIP) Rust frontend for gcc / a gcc backend for rustc
winlamb - A lightweight modern C++11 library for Win32 API, using lambdas to handle Windows messages.