My question is, what are the advantages of Rust over D? How do
you think they compare?

An answer by ssylvan:

For me, the memory management of Rust (the three pointer types,
per-task GC), as well as the additional safety (in particular, D
still has nulls all over the place - IME the by far most common
remaining "real world" crash seen in so called "memory safe"
languages - it's unfortunate because we know that they can be
statically eliminated). Also, not a fan of the class/struct
distinction in D, I think it encourages heap allocations,
whereas Rust drastically prefers big chunky objects that mostly
stay on the stack or inside another object with only the
extremely rare allocation, and even then most of those can be
unique (no GC/RC).<

And you are here to remedy that situation?
No offense, I started to keep an eye on Rust myself. I'm
pretty sure it will eventually have to cater to the people who
use it and tack some features on, like D2 that make it look
less carefully designed. New features lead to language WATs.
Also thanks for the strawman citation about not-null types. ;)
Since I don't write compilers I don't worry about their
complexity, and I think they are supposed to be a language
feature. Library solutions are clumsy to use and lack the
static flow analysis that is possible inside a compiler.
This three pointer types stuff also sounds effective to keep
the GC heap slim. I can't tell without personal experience
though, if all they implemented is an advantage in practice.
I agree with them, that it would be nice if D classes could
naturally be placed on the stack. Again I think it's a
language feature, just as 'ref' parameters are. Otherwise, as
long as I don't need polymorphism, I never missed anything
from structs, so I get along fine most of the time.
--
Marco

I agree with them, that it would be nice if D classes could
naturally be placed on the stack.

Allocating D class instances in-place (on the stack or inside
other structs/class instances) is not hard, but in practice I
never do it (Like I never use Rebindable or Typedef. I sometimes
use Nullable or AssumeUnique). But to make it safe enough you
probably need a smarter type system, that they have mostly
finished designing in Rust.
Avoiding most heap allocations is positive because it reduces the
amount of garbage, reduces pressure on the GC, gives good
performance even if you use a not too much refined GC, avoids GC
precision troubles, helps use less levels of indirection, and
generally helps keep the code faster.
Another thing Rust team is doing is (I think) having the
reference compiler based on LLVM. This means saving time to
develop only the front-end and designing the language. Scala
development was quick because the "back-end" and the GC was
already done (but of course it introduced some limitations. Now
they are porting Scala to the LLVM, removing most or all of the
limitations, but they keep all layers of the compiler but the
last one, so they have to translate stack-based code to the
infinite-number-of-registers-based IR of LLVM, and I think this
is sub-optimal, but they will have time to fix this problem later
removing one more stage in the middle).
Bye,
bearophile

I can't compile even hello world on both Win 7 and Win XP.
rust 0.4, latest mingw.

Try it out in Linux. Windows support is still shaky due to LLVM,
which also has Windows issues.
If you check Rust mailing list there are a few posts about not so
good Windows support.
I had to endure the same thing with Go, as Go team only cared
about Linux & Mac OS X, leaving any other operating system
support to the community.
--
Paulo