Add Rhai book.

doc/src/start/builds/minimal.md

@@ -0,0 +1,40 @@
+Minimal Build
+=============
+
+{{#include ../../links.md}}
+
+Configuration
+-------------
+
+In order to compile a _minimal_ build - i.e. a build optimized for size - perhaps for `no-std` embedded targets or for
+compiling to [WASM], it is essential that the correct linker flags are used in `cargo.toml`:
+
+```toml
+[profile.release]
+lto = "fat"         # turn on Link-Time Optimizations
+codegen-units = 1   # trade compile time with maximum optimization
+opt-level = "z"     # optimize for size
+```
+
+
+Opt-Out of Features
+------------------
+
+Opt out of as many features as possible, if they are not needed, to reduce code size because, remember, by default
+all code is compiled in as what a script requires cannot be predicted. If a language feature is not needed,
+omitting them via special features is a prudent strategy to optimize the build for size.
+
+Omitting arrays ([`no_index`]) yields the most code-size savings, followed by floating-point support
+([`no_float`]), checked arithmetic/script resource limits ([`unchecked`]) and finally object maps and custom types ([`no_object`]).
+
+Where the usage scenario does not call for loading externally-defined modules, use [`no_module`] to save some bytes.
+Disable script-defined functions ([`no_function`]) only when the feature is not needed because code size savings is minimal.
+
+
+Use a Raw [`Engine`]
+-------------------
+
+[`Engine::new_raw`](#raw-engine) creates a _raw_ engine.
+A _raw_ engine supports, out of the box, only a very [restricted set](#built-in-operators) of basic arithmetic and logical operators.
+Selectively include other necessary functionalities by loading specific [packages] to minimize the footprint.
+Packages are sharable (even across threads via the [`sync`] feature), so they only have to be created once.

doc/src/start/builds/no-std.md

@@ -0,0 +1,9 @@
+`no-std` Build
+=============
+
+{{#include ../../links.md}}
+
+The feature [`no_std`] automatically converts the scripting engine into a `no-std` build.
+
+Usually, a `no-std` build goes hand-in-hand with [minimal builds] because typical embedded
+hardware (the primary target for `no-std`) has limited storage.

doc/src/start/builds/performance.md

@@ -0,0 +1,27 @@
+Performance Build
+=================
+
+{{#include ../../links.md}}
+
+Use Only One Integer Type
+------------------------
+
+Some features are for performance.  For example, using [`only_i32`] or [`only_i64`] disables all other integer types (such as `u16`).
+If only a single integer type is needed in scripts - most of the time this is the case - it is best to avoid registering
+lots of functions related to other integer types that will never be used.  As a result, performance should improve.
+
+
+Use Only 32-Bit Numbers
+----------------------
+
+If only 32-bit integers are needed - again, most of the time this is the case - using [`only_i32`] disables also `i64`.
+On 64-bit targets this may not gain much, but on some 32-bit targets this improves performance due to 64-bit arithmetic
+requiring more CPU cycles to complete.
+
+
+Minimize Size of [`Dynamic`]
+---------------------------
+
+Turning on [`no_float`], and [`only_i32`] makes the key [`Dynamic`] data type only 8 bytes small on 32-bit targets
+while normally it can be up to 16 bytes (e.g. on x86/x64 CPU's) in order to hold an `i64` or `f64`.
+Making [`Dynamic`] small helps performance due to better cache efficiency.

doc/src/start/builds/wasm.md

@@ -0,0 +1,18 @@
+Building to WebAssembly (WASM)
+=============================
+
+{{#include ../../links.md}}
+
+It is possible to use Rhai when compiling to WebAssembly (WASM). This yields a scripting engine (and language)
+that can be run in a standard web browser. Why you would want to is another matter... as there is already
+a nice, fast, complete scripting language for the the common WASM environment (i.e. a browser) - and it is called JavaScript.
+But anyhow, do it because you _can_!
+
+When building for WASM, certain features will not be available, such as the script file API's and loading modules
+from external script files.
+
+Also look into [minimal builds] to reduce generated WASM size.  As of this version, a typical, full-featured
+Rhai scripting engine compiles to a single WASM file less than 200KB gzipped. When excluding features that are
+marginal in WASM environment, the gzipped payload can be further shrunk to 160KB.
+
+In benchmark tests, a WASM build runs scripts roughly 1.7-2.2x slower than a native optimized release build.