Actionscript vs Rust

Easy 2D and rich 3D capabilities means ActionScript is a great game prototyping or production tool. Relatively easy to get images on a stage and easy to share with it's wide platform support.

Runs on all major platforms as an AIR executable or mobile app, as well as in-browser as a FLASH file.

Teaches strong typed habits and follows many conventions of major programming languages.

Online games and a colorful history means there are a lot of existing scripts and examples on the internet for available integration as well as tutorials.

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.

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.

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.

You don't have to write same array and dictionary classes hundreds and thousands times for strong type check by compiler.

Rust has built-in support for concurrency.

Since Rust 1.8 you can install additional versions of the standard library for different targets using rustup/multirust.
For example:

$ rustup target add x86_64-unknown-linux-musl

Which then allows for:

$ cargo build --target x86_64-unknown-linux-musl

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.

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.

Cargo is the official package manager for Rust. It comes with the language and downloads dependencies, compiles packages, and makes and uploads distributable packages

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.

The biggest community contributing to language.

Very easy to create functional with some additional from structure application.