When comparing Vala vs Rust, the Slant community recommends Vala for most people. In the question“What are the best languages to write a desktop Linux application in?” Vala is ranked 3rd while Rust is ranked 4th. The most important reason people chose Vala is:
Vala developed by Gnome Foundation.
Ranked in these QuestionsQuestion Ranking
Pro Rich GTK Support
Vala developed by Gnome Foundation.
Underneath there is C. It makes some stuff easier to write than it would be with plain C code.
Pro Easy Syntax
Vala is syntactically similar to C# and includes several features such as: anonymous functions, signals, properties, generics, assisted memory management, exception handling, type inference, and foreach statements
Pro Well-integrated with C language
Vala itself is compiled to C, therefore it can use the vast ecosystem of C language, with least effort.
Pro Good documentation
There is Valadoc and most of the libraries have Devhelp packages.
Pro Catch errors at compile-time
Since Rust is statically typed, you can catch multiple errors during compile time. This is extremely helpful with debugging, especially compared with dynamically typed languages that may fail silently during runtime.
Pro Threads without data races
Unique ownership system guarantees a mutable data to be owned and mutated by only one thread at a time, so there's no data race, and this guarantee is checked at compile time statically. Which means easy multi-threading.
Of course, immutable data can be shared among multiple threads freely.
Pro Generics support
You don't have to write same array and dictionary classes hundreds and thousands times for strong type check by compiler.
Pro Compiles to machine code allowing for extra efficiency
Rust uses LLVM as a backend, among other things this allows Rust code to compile down to machine languages. This allows developers to write programs that run as efficiently as possible.
Pro Support for macros
When you identify a part of your code which gets repeated often, which you cannot abstract using functions or classes, you can use Rust's built-in Macros.
Pro Supports cross compilation for different architectures
Since Rust 1.8 you can install additional versions of the standard library for different targets using
$ rustup target add x86_64-unknown-linux-musl
Which then allows for:
$ cargo build --target x86_64-unknown-linux-musl
Pro Makes developers write optimal code
Rust is a modern programming language written around systems. It was designed from the ground up this way. It's language design makes developers write optimal code almost all the time, meaning you don't have to fully know and understand the compiler's source code in order to optimize your program.
Furthermore, Rust does not copy from memory unnecessarily, to give an example: all types move by default and not copy. Even references to types do not copy by default. In other words, setting a reference to another reference destroys the original one unless it's stated otherwise.
Pro Built-in concurrency
Rust has built-in support for concurrency.
Pro Easy to write understandable code
While not as verbose as Java, it still is much more verbose than languages like Go and Python. This means that the code is very explicit and easy to understand.
Pro Zero-cost futures or Async IO
Con Not a general purpose language
Can't use Vala in multiple software development areas.
Con Not well documented
It already has tons of documentation, even a book about Vala.https://leanpub.com/vala https://wiki.gnome.org/Projects/Vala/Documentation
Con Difficult to debug programs
Try Debug in Gnome Builder, it works perfectly.
Con Scarce learning resources
Difficult to find good resources for learning Vala.
Con Very few resources allocated to the language
Only a single person is working on Vala full time. Gnome Foundation isn't allocating sufficient resources to properly maintain Vala.
Con Doesn't have an independent type system
Heavy reliance on GObject types which heavily restricts where Vala can be used.
Con No stable version
No stable version of Vala released for over a decade so far. Means that Vala isn't production ready.
Con Very limited adoption
Vala isn't used in areas other than GTK development, and no major business has adopted the language.
Con Very limited tooling
Though using Gnome Builder, you can debug it easily.
Con Hard to find learning resources or libraries
Because it's still a relatively new language, Rust does not enjoy a following as large as other languages/environments. Rust development has also been rather volatile for a long time during the beginning of the development of the language adding to this issue.
Because of the small community, it's harder to find useful libraries for projects or any other kind of resource.
Con Asynchronous I/O is not (yet) a part of the core language
The issue of asynchronous I/O is still being discussed as a language feature, and not yet in the implementation phase. See the RFC on GitHub here.