diff --git a/lib/api/src/lib.rs b/lib/api/src/lib.rs
index d5c054596..32b4a5de0 100644
--- a/lib/api/src/lib.rs
+++ b/lib/api/src/lib.rs
@@ -1,3 +1,342 @@
+#![doc(
+ html_logo_url = "https://github.com/wasmerio.png?size=200",
+ html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png"
+)]
+#![deny(
+ missing_docs,
+ trivial_numeric_casts,
+ unused_extern_crates,
+ broken_intra_doc_links
+)]
+#![warn(unused_import_braces)]
+#![cfg_attr(
+ feature = "cargo-clippy",
+ allow(clippy::new_without_default, vtable_address_comparisons)
+)]
+#![cfg_attr(
+ feature = "cargo-clippy",
+ warn(
+ clippy::float_arithmetic,
+ clippy::mut_mut,
+ clippy::nonminimal_bool,
+ clippy::option_map_unwrap_or,
+ clippy::option_map_unwrap_or_else,
+ clippy::print_stdout,
+ clippy::unicode_not_nfc,
+ clippy::use_self
+ )
+)]
+
+//! This crate contains the `wasmer` API. The `wasmer` API facilitates the efficient,
+//! sandboxed execution of [WebAssembly (Wasm)][wasm] modules.
+//!
+//! Here's an example of the `wasmer` API in action:
+//!
+//! ```
+//! use wasmer::{Store, Module, Instance, Value, imports};
+//!
+//! fn main() -> anyhow::Result<()> {
+//! let module_wat = r#"
+//! (module
+//! (type $t0 (func (param i32) (result i32)))
+//! (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32)
+//! get_local $p0
+//! i32.const 1
+//! i32.add))
+//! "#;
+//!
+//! let store = Store::default();
+//! let module = Module::new(&store, &module_wat)?;
+//! // The module doesn't import anything, so we create an empty import object.
+//! let import_object = imports! {};
+//! let instance = Instance::new(&module, &import_object)?;
+//!
+//! let add_one = instance.exports.get_function("add_one")?;
+//! let result = add_one.call(&[Value::I32(42)])?;
+//! assert_eq!(result[0], Value::I32(43));
+//!
+//! Ok(())
+//! }
+//! ```
+//!
+//! For more examples of using the `wasmer` API, check out the
+//! [Wasmer examples][wasmer-examples].
+//!
+//! ---------
+//!
+//! # Table of Contents
+//!
+//! - [Wasm Primitives](#wasm-primitives)
+//! - [Externs](#externs)
+//! - [Functions](#functions)
+//! - [Memories](#memories)
+//! - [Globals](#globals)
+//! - [Tables](#tables)
+//! - [Project Layout](#project-layout)
+//! - [Engines](#engines)
+//! - [Compilers](#compilers)
+//! - [Features](#features)
+//!
+//!
+//! # Wasm Primitives
+//! In order to make use of the power of the `wasmer` API, it's important
+//! to understand the primitives around which the API is built.
+//!
+//! Wasm only deals with a small number of core data types, these data
+//! types can be found in the [`Value`] type.
+//!
+//! In addition to the core Wasm types, the core types of the API are
+//! referred to as "externs".
+//!
+//! ## Externs
+//! An [`Extern`] is a type that can be imported or exported from a Wasm
+//! module.
+//!
+//! To import an extern, simply give it a namespace and a name with the
+//! [`imports`] macro:
+//!
+//! ```
+//! # use wasmer::{imports, Function, Memory, MemoryType, Store, ImportObject};
+//! # fn imports_example(store: &Store) -> ImportObject {
+//! let memory = Memory::new(&store, MemoryType::new(1, None, false)).unwrap();
+//! imports! {
+//! "env" => {
+//! "my_function" => Function::new_native(store, || println!("Hello")),
+//! "memory" => memory,
+//! }
+//! }
+//! # }
+//! ```
+//!
+//! And to access an exported extern, see the [`Exports`] API, accessible
+//! from any instance via `instance.exports`:
+//!
+//! ```
+//! # use wasmer::{imports, Instance, Function, Memory, NativeFunc};
+//! # fn exports_example(instance: &Instance) -> anyhow::Result<()> {
+//! let memory = instance.exports.get_memory("memory")?;
+//! let memory: &Memory = instance.exports.get("some_other_memory")?;
+//! let add: NativeFunc<(i32, i32), i32> = instance.exports.get_native_function("add")?;
+//! let result = add.call(5, 37)?;
+//! assert_eq!(result, 42);
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! These are the primary types that the `wasmer` API uses.
+//!
+//! ### Functions
+//! There are 2 types of functions in `wasmer`:
+//! 1. Wasm functions,
+//! 2. Host functions.
+//!
+//! A Wasm function is a function defined in a WebAssembly module that can
+//! only perform computation without side effects and call other functions.
+//!
+//! Wasm functions take 0 or more arguments and return 0 or more results.
+//! Wasm functions can only deal with the primitive types defined in
+//! [`Value`].
+//!
+//! A Host function is any function implemented on the host, in this case in
+//! Rust.
+//!
+//! Host functions can optionally be created with an environment that
+//! implements [`WasmerEnv`]. This environment is useful for maintaining
+//! host state (for example the filesystem in WASI).
+//!
+//! Thus WebAssembly modules by themselves cannot do anything but computation
+//! on the core types in [`Value`]. In order to make them more useful we
+//! give them access to the outside world with [`imports`].
+//!
+//! If you're looking for a sandboxed, POSIX-like environment to execute Wasm
+//! in, check out the [`wasmer-wasi`][wasmer-wasi] crate for our implementation of WASI,
+//! the WebAssembly System Interface.
+//!
+//! In the `wasmer` API we support functions which take their arguments and
+//! return their results dynamically, [`Function`], and functions which
+//! take their arguments and return their results statically, [`NativeFunc`].
+//!
+//! ### Memories
+//! Memories store data.
+//!
+//! In most Wasm programs, nearly all data will live in a [`Memory`].
+//!
+//! This data can be shared between the host and guest to allow for more
+//! interesting programs.
+//!
+//! ### Globals
+//! A [`Global`] is a type that may be either mutable or immutable, and
+//! contains one of the core Wasm types defined in [`Value`].
+//!
+//! ### Tables
+//! A [`Table`] is an indexed list of items.
+//!
+//!
+//! ## Project Layout
+//!
+//! The Wasmer project is divided into a number of crates, below is a dependency
+//! graph with transitive dependencies removed.
+//!
+//!
+//!
+//!
-//!
-//!