diff --git a/docs/source/Building.md b/docs/source/Building.md
index ad9e972..d7e9ca3 100644
--- a/docs/source/Building.md
+++ b/docs/source/Building.md
@@ -29,6 +29,27 @@
 *Note that you MUST be in the root of the FlatBuffers distribution when you
 run 'flattests' or `flatsampletext`, or it will fail to load its files.*
 
+### Make all warnings into errors
+
+By default all Flatbuffers `cmake` targets are build with `-Werror` flag.
+With this flag (or `/WX` for MSVC) C++ compiler will treat all warnings as errors.
+Additionally `-Wall -pedantic -Wextra` (or `/W4` form MSVC) flags are set.
+These flags minimize the number of possible defects in code and keep code highly portable.
+Using these flags is considered good practice but sometimes it can break dependent projects 
+if a compiler is upgraded or a toolset is changed.
+Usually, newer compiler versions add new compile-time diagnostics that were unavailable before.
+These new diagnostic warnings could stop the build process if `-Werror` flag is set.
+
+It is possible to cancel `warnings as errors` flag at `cmake` configuration stage using 
+`FLATBUFFERS_CXX_FLAGS` option. Compilation flags declared in `FLATBUFFERS_CXX_FLAGS` will be 
+appended to the project-level `CMAKE_CXX_FLAGS` variable.
+Examples:
+
+- GCC and Clang: `cmake . -D FLATBUFFERS_CXX_FLAGS="-Wno-error"`
+- MSVC: `cmake . -D FLATBUFFERS_CXX_FLAGS="/WX-"`
+- MSVC: `cmake . -D FLATBUFFERS_CXX_FLAGS="/Wv <compiler.version>"`
+
+
 ## Building with VCPKG
 
 You can download and install flatbuffers using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:
@@ -100,14 +121,3 @@
 set(FLATBUFFERS_MAX_PARSING_DEPTH 16)
 ```
 to `CMakeLists.txt` file before `add_subdirectory(${FLATBUFFERS_SRC_DIR})` line.
-
-#### For Google Play apps
-
-For applications on Google Play that integrate this library, usage is tracked.
-This tracking is done automatically using the embedded version string
-(flatbuffer_version_string), and helps us continue to optimize it.
-Aside from consuming a few extra bytes in your application binary, it shouldn't
-affect your application at all. We use this information to let us know if
-FlatBuffers is useful and if we should continue to invest in it. Since this is
-open source, you are free to remove the version string but we would appreciate
-if you would leave it in.
diff --git a/docs/source/CUsage.md b/docs/source/CUsage.md
index 9aafa6f..bd1ec15 100644
--- a/docs/source/CUsage.md
+++ b/docs/source/CUsage.md
@@ -7,7 +7,7 @@
 online via a C library. It can also generate buffer verifiers and fast
 JSON parsers, printers.
 
-Great care has been taken to ensure compatibily with the main `flatc`
+Great care has been taken to ensure compatibility with the main `flatc`
 project.
 
 ## General Documention
diff --git a/docs/source/Compiler.md b/docs/source/Compiler.md
index 973c411..242506a 100644
--- a/docs/source/Compiler.md
+++ b/docs/source/Compiler.md
@@ -79,7 +79,7 @@
 -   `--allow-non-utf8` : Pass non-UTF-8 input through parser and emit nonstandard
     \x escapes in JSON. (Default is to raise parse error on non-UTF-8 input.)
 
--  `--natural-utf8` : Output strings with UTF-8 as human-readable strings.
+-   `--natural-utf8` : Output strings with UTF-8 as human-readable strings.
      By default, UTF-8 characters are printed as \uXXXX escapes."
 
 -   `--defaults-json` : Output fields whose value is equal to the default value
@@ -101,7 +101,7 @@
 -   `--gen-mutable` : Generate additional non-const accessors for mutating
     FlatBuffers in-place.
 
--   `--gen-onefile` : Generate single output file for C# and Go.
+-   `--gen-onefile` : Generate single output file for C#, Go, and Python.
 
 -   `--gen-name-strings` : Generate type name functions for C++.
 
@@ -142,23 +142,14 @@
 
 -   `--cpp-std CPP_STD` : Generate a C++ code using features of selected C++ standard.
      Supported `CPP_STD` values:
-    * `c++0x` - generate code compatible with old compilers (VS2010).
-    * `c++11` - use C++11 code generator (default);
+    * `c++0x` - generate code compatible with old compilers (VS2010),
+    * `c++11` - use C++11 code generator (default),
+    * `c++17` - use C++17 features in generated code (experimental).
 
 -   `--object-prefix` : Customise class prefix for C++ object-based API.
 
 -   `--object-suffix` : Customise class suffix for C++ object-based API.
 
--   `--no-js-exports` : Removes Node.js style export lines (useful for JS)
-
--   `--goog-js-export` :  Uses goog.exportsSymbol and goog.exportsProperty
-    instead of Node.js style exporting.  Needed for compatibility with the
-    Google closure compiler (useful for JS).
-
--   `--es6-js-export` : Generates ECMAScript v6 style export definitions
-    instead of Node.js style exporting. Useful when integrating flatbuffers
-    with modern Javascript projects.
-
 -   `--go-namespace` : Generate the overrided namespace in Golang.
 
 -   `--go-import` : Generate the overrided import for flatbuffers in Golang.
@@ -206,12 +197,6 @@
 
 -   `--keep-prefix` : Keep original prefix of schema include statement.
 
--   `--no-fb-import` : Don't include flatbuffers import statement for TypeScript.
-
--   `--no-ts-reexport` : Don't re-export imported dependencies for TypeScript.
-
--   `--short-names` : Use short function names for JS and TypeScript.
-
 -   `--reflect-types` : Add minimal type reflection to code generation.
 
 -   `--reflect-names` : Add minimal type/name reflection.
@@ -228,5 +213,16 @@
 -   `--force-empty-vectors` : When serializing from object API representation, force
      vectors to empty rather than null.
 
+-   `--flexbuffers` : Used with "binary" and "json" options, it generates
+     data using schema-less FlexBuffers.
+
+-   `--no-warnings` : Inhibit all warning messages.
+
+-   `--cs-global-alias` : Prepend `global::` to all user generated csharp classes and structs.
+
+-   `--json-nested-bytes` : Allow a nested_flatbuffer field to be parsed as a
+    vector of bytes in JSON, which is unsafe unless checked by a verifier
+    afterwards.
+
 NOTE: short-form options for generators are deprecated, use the long form
 whenever possible.
diff --git a/docs/source/CppUsage.md b/docs/source/CppUsage.md
index 2333f48..82d6f15 100644
--- a/docs/source/CppUsage.md
+++ b/docs/source/CppUsage.md
@@ -56,7 +56,7 @@
 First, include the library and generated code. Then read the file into
 a `char *` array, which you pass to `GetMonster()`.
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
+```cpp
     #include "flatbuffers/flatbuffers.h"
     #include "monster_test_generate.h"
     #include <iostream> // C++ header file for printing
@@ -73,18 +73,18 @@
     infile.close();
 
     auto monster = GetMonster(data);
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
 
 `monster` is of type `Monster *`, and points to somewhere *inside* your
-buffer (root object pointers are not the same as `buffer_pointer` !).
+buffer (root object pointers are not the same as `buffer_pointer` \!).
 If you look in your generated header, you'll see it has
 convenient accessors for all fields, e.g. `hp()`, `mana()`, etc:
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
-    std::cout << "hp : " << monster->hp() << std::endl;            // `80`
-    std::cout << "mana : " << monster->mana() << std::endl;        // default value of `150`
-    std::cout << "name : " << monster->name()->c_str() << std::endl;        // "MyMonster"
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```cpp
+    std::cout << "hp : " << monster->hp() << std::endl;              // '80'
+    std::cout << "mana : " << monster->mana() << std::endl;          // default value of '150'
+    std::cout << "name : " << monster->name()->c_str() << std::endl; // "MyMonster"
+```
 
 *Note: That we never stored a `mana` value, so it will return the default.*
 
@@ -96,7 +96,7 @@
     Specifically, `CreateXxxDirect` functions and `Pack` functions for object
     based API (see below) will use `CreateSharedString` to create strings.
 
-## Object based API.  {#flatbuffers_cpp_object_based_api}
+## Object based API  {#flatbuffers_cpp_object_based_api}
 
 FlatBuffers is all about memory efficiency, which is why its base API is written
 around using as little as possible of it. This does make the API clumsier
@@ -109,7 +109,7 @@
 
 To use:
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
+```cpp
     // Autogenerated class from table Monster.
     MonsterT monsterobj;
 
@@ -123,7 +123,7 @@
     // Serialize into new flatbuffer.
     FlatBufferBuilder fbb;
     fbb.Finish(Monster::Pack(fbb, &monsterobj));
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
 
 The following attributes are specific to the object-based API code generation:
 
@@ -133,27 +133,30 @@
     This attribute changes the member declaration to use the type directly
     rather than wrapped in a unique_ptr.
 
--   `native_default`: "value" (on a field): For members that are declared
+-   `native_default("value")` (on a field): For members that are declared
     "native_inline", the value specified with this attribute will be included
     verbatim in the class constructor initializer list for this member.
 
--   `native_custom_alloc`:"custom_allocator" (on a table or struct): When using the
+-   `native_custom_alloc("custom_allocator")` (on a table or struct): When using the
     object-based API all generated NativeTables that  are allocated when unpacking
     your  flatbuffer will use "custom allocator". The allocator is also used by
     any std::vector that appears in a table defined with `native_custom_alloc`.
     This can be  used to provide allocation from a pool for example, for faster
     unpacking when using the object-based API.
 
-    Minimal Example:
+Minimal Example:
 
-    schema:
+schema:
 
+```cpp
     table mytable(native_custom_alloc:"custom_allocator") {
       ...
     }
+```
 
-    with custom_allocator defined before flatbuffers.h is included, as:
+with `custom_allocator` defined before `flatbuffers.h` is included, as:
 
+```cpp
     template <typename T> struct custom_allocator : public std::allocator<T> {
 
       typedef T *pointer;
@@ -172,51 +175,77 @@
       }
 
       custom_allocator() throw() {}
+
       template <class U>
       custom_allocator(const custom_allocator<U>&) throw() {}
     };
+```
 
--   `native_type`' "type" (on a struct): In some cases, a more optimal C++ data
-    type exists for a given struct.  For example, the following schema:
+-   `native_type("type")` (on a struct): In some cases, a more optimal C++ data
+type exists for a given struct.  For example, the following schema:
 
-      struct Vec2 {
-        x: float;
-        y: float;
-      }
+```cpp
+    struct Vec2 {
+      x: float;
+      y: float;
+    }
+```
 
-    generates the following Object-Based API class:
+generates the following Object-Based API class:
 
-      struct Vec2T : flatbuffers::NativeTable {
-        float x;
-        float y;
-      };
+```cpp
+    struct Vec2T : flatbuffers::NativeTable {
+      float x;
+      float y;
+    };
+```
 
-    However, it can be useful to instead use a user-defined C++ type since it
-    can provide more functionality, eg.
+However, it can be useful to instead use a user-defined C++ type since it
+can provide more functionality, eg.
 
-      struct vector2 {
-        float x = 0, y = 0;
-        vector2 operator+(vector2 rhs) const { ... }
-        vector2 operator-(vector2 rhs) const { ... }
-        float length() const { ... }
-        // etc.
-      };
+```cpp
+    struct vector2 {
+      float x = 0, y = 0;
+      vector2 operator+(vector2 rhs) const { ... }
+      vector2 operator-(vector2 rhs) const { ... }
+      float length() const { ... }
+      // etc.
+    };
+```
 
-    The `native_type` attribute will replace the usage of the generated class
-    with the given type.  So, continuing with the example, the generated
-    code would use |vector2| in place of |Vec2T| for all generated code.
+The `native_type` attribute will replace the usage of the generated class
+with the given type.  So, continuing with the example, the generated
+code would use `vector2` in place of `Vec2T` for all generated code of
+the Object-Based API.
 
-    However, becuase the native_type is unknown to flatbuffers, the user must
-    provide the following functions to aide in the serialization process:
+However, because the `native_type` is unknown to flatbuffers, the user must
+provide the following functions to aide in the serialization process:
 
-      namespace flatbuffers {
-        FlatbufferStruct Pack(const native_type& obj);
-        native_type UnPack(const FlatbufferStruct& obj);
-      }
+```cpp
+    namespace flatbuffers {
+      Vec2 Pack(const vector2& obj);
+      vector2 UnPack(const Vec2& obj);
+    }
+```
 
-Finally, the following top-level attribute
+-   `native_type_pack_name("name")` (on a struct when `native_type` is
+    specified, too): when you want to use the same `native_type` multiple times
+    (e. g. with different precision) you must make the names of the Pack/UnPack
+    functions unique, otherwise you will run into compile errors. This attribute
+    appends a name to the expected Pack/UnPack functions. So when you
+    specify `native_type_pack_name("Vec2")` in the above example you now need to
+    implement these serialization functions instead:
 
--   `native_include`: "path" (at file level): Because the `native_type` attribute
+```cpp
+    namespace flatbuffers {
+      Vec2 PackVec2(const vector2& obj);
+      vector2 UnPackVec2(const Vec2& obj);
+    }
+```
+
+Finally, the following top-level attributes:
+
+-   `native_include("path")` (at file level): Because the `native_type` attribute
     can be used to introduce types that are unknown to flatbuffers, it may be
     necessary to include "external" header files in the generated code.  This
     attribute can be used to directly add an #include directive to the top of
@@ -225,7 +254,7 @@
 -   `force_align`: this attribute may not be respected in the object API,
     depending on the aligned of the allocator used with `new`.
 
-# External references.
+# External references
 
 An additional feature of the object API is the ability to allow you to load
 multiple independent FlatBuffers, and have them refer to eachothers objects
@@ -244,7 +273,7 @@
 When you call `UnPack` (or `Create`), you'll need a function that maps from
 hash to the object (see `resolver_function_t` for details).
 
-# Using different pointer types.
+# Using different pointer types
 
 By default the object tree is built out of `std::unique_ptr`, but you can
 influence this either globally (using the `--cpp-ptr-type` argument to
@@ -255,13 +284,13 @@
 pointer type specified by the `--cpp-ptr-type` argument to `flatc` from a
 flatbuffer field set the `cpp_ptr_type` attribute to `default_ptr_type`.
 
-# Using different string type.
+# Using different string type
 
 By default the object tree is built out of `std::string`, but you can
 influence this either globally (using the `--cpp-str-type` argument to
 `flatc`) or per field using the `cpp_str_type` attribute.
 
-The type must support T::c_str(), T::length() and T::empty() as member functions.
+The type must support `T::c_str()`, `T::length()` and `T::empty()` as member functions.
 
 Further, the type must be constructible from std::string, as by default a
 std::string instance is constructed and then used to initialize the custom
@@ -270,7 +299,7 @@
 per field attribute `cpp_str_flex_ctor` can be used to change this behavior,
 so that the custom string type is constructed by passing the pointer and
 length of the FlatBuffers String. The custom string class will require a
-constructor in the following format: custom_str_class(const char *, size_t).
+constructor in the following format: `custom_str_class(const char *, size_t)`.
 Please note that the character array is not guaranteed to be NULL terminated,
 you should always use the provided size to determine end of string.
 
@@ -281,7 +310,7 @@
 even allows you to change sizes of strings and vectors in-place.
 
 The way this works is very elegant; there is actually a FlatBuffer schema that
-describes schemas (!) which you can find in `reflection/reflection.fbs`.
+describes schemas (\!) which you can find in `reflection/reflection.fbs`.
 The compiler, `flatc`, can write out any schemas it has just parsed as a binary
 FlatBuffer, corresponding to this meta-schema.
 
@@ -299,7 +328,7 @@
 ## Mini Reflection
 
 A more limited form of reflection is available for direct inclusion in
-generated code, which doesn't any (binary) schema access at all. It was designed
+generated code, which doesn't do any (binary) schema access at all. It was designed
 to keep the overhead of reflection as low as possible (on the order of 2-6
 bytes per field added to your executable), but doesn't contain all the
 information the (binary) schema contains.
@@ -390,9 +419,9 @@
 Each root type will have a verification function generated for it,
 e.g. for `Monster`, you can call:
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
+```cpp
 	bool ok = VerifyMonsterBuffer(Verifier(buf, len));
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
 
 if `ok` is true, the buffer is safe to read.
 
@@ -458,15 +487,15 @@
 convenient `LoadFile()` utility function in `flatbuffers/util.h` if you
 wish). Construct a parser:
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
+```cpp
     flatbuffers::Parser parser;
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
 
 Now you can parse any number of text files in sequence:
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
+```cpp
     parser.Parse(text_file.c_str());
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
 
 This works similarly to how the command-line compiler works: a sequence
 of files parsed by the same `Parser` object allow later files to
@@ -498,7 +527,7 @@
 a FlatBuffer is contained in a FlatBufferBuilder instance, and no memory
 outside of it is touched. To make this thread safe, either do not
 share instances of FlatBufferBuilder between threads (recommended), or
-manually wrap it in synchronisation primites. There's no automatic way to
+manually wrap it in synchronisation primitives. There's no automatic way to
 accomplish this, by design, as we feel multithreaded construction
 of a single buffer will be rare, and synchronisation overhead would be costly.
 
diff --git a/docs/source/CsharpUsage.md b/docs/source/CsharpUsage.md
index 83f4842..abfcbf6 100644
--- a/docs/source/CsharpUsage.md
+++ b/docs/source/CsharpUsage.md
@@ -180,7 +180,8 @@
 An additional feature of the object API is the ability to allow you to
 serialize & deserialize a JSON text.
 To use Json Serialization, add `--cs-gen-json-serializer` option to `flatc` and
-add `Newtonsoft.Json` nuget package to csproj.
+add `Newtonsoft.Json` nuget package to csproj. This requires explicitly setting
+the `--gen-object-api` option as well.
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs}
     // Deserialize MonsterT from json
@@ -192,7 +193,7 @@
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * Limitation
-  * `hash` attribute currentry not supported.
+  * `hash` attribute currently not supported.
 * NuGet package Dependency
   * [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json)
 
diff --git a/docs/source/DartUsage.md b/docs/source/DartUsage.md
index 6670cc5..515a644 100644
--- a/docs/source/DartUsage.md
+++ b/docs/source/DartUsage.md
@@ -105,4 +105,27 @@
 not currently an option in Flutter - follow [this issue](https://github.com/flutter/flutter/issues/7053)
 for the latest).
 
-<br>
+## Object based API
+
+FlatBuffers is all about memory efficiency, which is why its base API is written
+around using as little as possible of it. This does make the API clumsier
+(requiring pre-order construction of all data, and making mutation harder).
+
+For times when efficiency is less important a more convenient object based API
+can be used (through `--gen-object-api`) that is able to unpack & pack a FlatBuffer
+into objects and lists, allowing for convenient construction, access and mutation.
+
+To use:
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.dart}
+    // Deserialize from buffer into object.
+    MonsterT monster = Monster(flatbuffer).unpack();
+
+    // Update object directly like a Dart class instance.
+    print(monster.Name);
+    monster.Name = "Bob";  // Change the name.
+
+    // Serialize into new flatbuffer.
+    final fbb = Builder();
+    fbb.Finish(monster.pack(fbb));
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/docs/source/FlatBuffers.md b/docs/source/FlatBuffers.md
index 2a2133f..bbd2cb0 100644
--- a/docs/source/FlatBuffers.md
+++ b/docs/source/FlatBuffers.md
@@ -64,8 +64,8 @@
 with the primary difference being that FlatBuffers does not need a parsing/
 unpacking step to a secondary representation before you can
 access data, often coupled with per-object memory allocation. The code
-is an order of magnitude bigger, too. Protocol Buffers has neither optional
-text import/export nor schema language features like unions.
+is an order of magnitude bigger, too. Protocol Buffers has no optional
+text import/export.
 
 ### But all the cool kids use JSON!
 
diff --git a/docs/source/IntermediateRepresentation.md b/docs/source/IntermediateRepresentation.md
new file mode 100644
index 0000000..f4eb075
--- /dev/null
+++ b/docs/source/IntermediateRepresentation.md
@@ -0,0 +1,35 @@
+# Flatbuffers Intermediate Representation {#intermediate_representation}
+
+We use [reflection.fbs](https://github.com/google/flatbuffers/blob/master/reflection/reflection.fbs)
+as our intermediate representation. `flatc` parses `.fbs` files, checks them for
+errors and stores the resulting data in this IR, outputting `.bfbs` files.
+Since this IR is a Flatbuffer, you can load and use it at runtime for runtime
+reflection purposes.
+
+There are some quirks: 
+- Tables and Structs are serialized as `Object`s.
+- Unions and Enums are serialized as `Enum`s.
+- It is the responsibility of the code generator to check the `advanced_features`
+  field of `Schema`. These mark the presence of new, backwards incompatible,
+  schema features. Code generators must error if generating a schema with
+  unrecognized advanced features.
+- Filenames are relative to a "project root" denoted by "//" in the path. This
+  may be specified in flatc with `--bfbs-filenames=$PROJECT_ROOT`, or it will be
+  inferred to be the directory containing the first provided schema file.
+
+
+## Invocation 
+You can invoke it like so
+```{.sh}
+flatc -b --schema ${your_fbs_files}
+```
+This generates `.bfbs` (binary flatbuffer schema) files.
+
+Some information is not included by default. See the `--bfbs-filenames` and
+`--bfbs-comments` flags. These may be necessary for code-generators, so they can
+add documentation and maybe name generated files (depending on the generator).
+
+
+TODO(cneo): Flags to output bfbs as flexbuffers or json.
+
+TODO(cneo): Tutorial for building a flatc plugin.
diff --git a/docs/source/Internals.md b/docs/source/Internals.md
index 389a8f9..591f040 100644
--- a/docs/source/Internals.md
+++ b/docs/source/Internals.md
@@ -85,10 +85,12 @@
 
 They start with an `soffset_t` to a vtable. This is a signed version of
 `uoffset_t`, since vtables may be stored anywhere relative to the object.
-This offset is substracted (not added) from the object start to arrive at
+This offset is subtracted (not added) from the object start to arrive at
 the vtable start. This offset is followed by all the
 fields as aligned scalars (or offsets). Unlike structs, not all fields
-need to be present. There is no set order and layout.
+need to be present. There is no set order and layout. A table may contain
+field offsets that point to the same value if the user explicitly
+serializes the same offset twice.
 
 To be able to access fields regardless of these uncertainties, we go
 through a vtable of offsets. Vtables are shared between any objects that
@@ -111,13 +113,21 @@
 default value is return. Otherwise, the entry is used as offset to the
 field to be read.
 
+### Unions
+
+Unions are encoded as the combination of two fields: an enum representing the
+union choice and the offset to the actual element. FlatBuffers reserves the
+enumeration constant `NONE` (encoded as 0) to mean that the union field is not
+set.
+
 ### Strings and Vectors
 
 Strings are simply a vector of bytes, and are always
 null-terminated. Vectors are stored as contiguous aligned scalar
 elements prefixed by a 32bit element count (not including any
 null termination). Neither is stored inline in their parent, but are referred to
-by offset.
+by offset. A vector may consist of more than one offset pointing to the same
+value if the user explicitly serializes the same offset twice.
 
 ### Construction
 
@@ -346,6 +356,9 @@
 bytes (one per element of the vector), which are always following the vector,
 and are always a uint8_t even if the vector is made up of bigger scalars.
 
+A vector may include more than one offset pointing to the same value if the
+user explicitly serializes the same offset twice.
+
 ### Types
 
 A type byte is made up of 2 components (see flexbuffers.h for exact values):
@@ -422,7 +435,7 @@
 values *have* to be stored in sorted order (as determined by `strcmp`), such
 that lookups can be made using binary search.
 
-The reason the key vector is a seperate structure from the value vector is
+The reason the key vector is a separate structure from the value vector is
 such that it can be shared between multiple value vectors, and also to
 allow it to be treated as its own individual vector in code.
 
diff --git a/docs/source/JavaScriptUsage.md b/docs/source/JavaScriptUsage.md
index c321c95..64764e2 100644
--- a/docs/source/JavaScriptUsage.md
+++ b/docs/source/JavaScriptUsage.md
@@ -16,43 +16,31 @@
 
 ## FlatBuffers JavaScript library code location
 
-The code for the FlatBuffers JavaScript library can be found at
-`flatbuffers/js`. You can browse the library code on the [FlatBuffers
-GitHub page](https://github.com/google/flatbuffers/tree/master/js).
+The generated code for the FlatBuffers JavaScript library can be found at 
+https://www.npmjs.com/package/flatbuffers. To use it from sources:
 
-## Testing the FlatBuffers JavaScript library
+1. Run `npm run compile` from the main folder to generate JS files from TS.
+1. In your project, install it as a normal dependency, using the flatbuffers
+folder as the source.
 
-The code to test the JavaScript library can be found at `flatbuffers/tests`.
-The test code itself is located in [JavaScriptTest.js](https://github.com/
-google/flatbuffers/blob/master/tests/JavaScriptTest.js).
-
-To run the tests, use the [JavaScriptTest.sh](https://github.com/google/
-flatbuffers/blob/master/tests/JavaScriptTest.sh) shell script.
-
-*Note: The JavaScript test file requires [Node.js](https://nodejs.org/en/).*
-
-## Using the FlatBuffers JavaScript libary
+## Using the FlatBuffers JavaScript library
 
 *Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
-example of how to use FlatBuffers in JavaScript.*
+example of how to use FlatBuffers.*
 
-FlatBuffers supports both reading and writing FlatBuffers in JavaScript.
+Due to the complexity related with large amounts of JS flavors and module types,
+native JS support has been replaced in 2.0 by transpilation from TypeScript.
 
-To use FlatBuffers in your own code, first generate JavaScript classes from your
-schema with the `--js` option to `flatc`. Then you can include both FlatBuffers
-and the generated code to read or write a FlatBuffer.
+Please look at [TypeScript usage](@ref flatbuffers_guide_use_typescript) and
+transpile your sources to desired JS flavor. The minimal steps to get up and
+running with JS are:
 
-For example, here is how you would read a FlatBuffer binary file in Javascript:
-First, include the library and generated code. Then read the file into an
-`Uint8Array`. Make a `flatbuffers.ByteBuffer` out of the `Uint8Array`, and pass
-the ByteBuffer to the `getRootAsMonster` function.
-
-*Note: Both JavaScript module loaders (e.g. Node.js) and browser-based
-HTML/JavaScript code segments are shown below in the following snippet:*
+1. Generate TS files from `*.fbs` by using the `--ts` option.
+1. Transpile resulting TS files to desired JS flavor using `tsc` (see 
+   https://www.typescriptlang.org/download for installation instructions).
 
 ~~~{.js}
-  // Note: These require functions are specific to JavaScript module loaders
-  //       (namely, Node.js). See below for a browser-based example.
+  // Note: These require functions are an example - use your desired module flavor.
   var fs = require('fs');
 
   var flatbuffers = require('../flatbuffers').flatbuffers;
@@ -65,7 +53,7 @@
 
   //--------------------------------------------------------------------------//
 
-  // Note: This code is specific to browser-based HTML/JavaScript. See above
+  // Note: This code is an example of browser-based HTML/JavaScript. See above
   //       for the code using JavaScript module loaders (e.g. Node.js).
   <script src="../js/flatbuffers.js"></script>
   <script src="monster_generated.js"></script>
diff --git a/docs/source/LobsterUsage.md b/docs/source/LobsterUsage.md
index 9d69caf..723966b 100644
--- a/docs/source/LobsterUsage.md
+++ b/docs/source/LobsterUsage.md
@@ -71,7 +71,7 @@
 makes use of native support for writing binary values, and access of vtables.
 Both generated code and the runtime library are therefore small and fast.
 
-Actual speed will depend on wether you use Lobster as bytecode VM or compiled to
+Actual speed will depend on whether you use Lobster as bytecode VM or compiled to
 C++.
 
 ## Text Parsing
diff --git a/docs/source/LuaUsage.md b/docs/source/LuaUsage.md
index 75b1f3b..43c370f 100644
--- a/docs/source/LuaUsage.md
+++ b/docs/source/LuaUsage.md
@@ -29,8 +29,8 @@
 To run the tests, use the [LuaTest.sh](https://github.com/google/flatbuffers/
 blob/master/tests/LuaTest.sh) shell script.
 
-*Note: This script requires [Lua 5.3](https://www.lua.org/) to be
-installed.*
+*Note: This script requires [Lua 5.3](https://www.lua.org/) and
+[LuaJIT](http://luajit.org/) to be installed.*
 
 ## Using the FlatBuffers Lua library
 
diff --git a/docs/source/RustUsage.md b/docs/source/RustUsage.md
index 6819117..9e959a9 100644
--- a/docs/source/RustUsage.md
+++ b/docs/source/RustUsage.md
@@ -36,7 +36,7 @@
 [integration_test.rs](https://github.com/google/flatbuffers/blob/master/tests/rust_usage_test/tests/integration_test.rs)
 
 This test file requires `flatc` to be present. To review how to build the project,
-please read the [Building](@ref flatbuffers_guide_building) documenation.
+please read the [Building](@ref flatbuffers_guide_building) documentation.
 
 To run the tests, execute `RustTest.sh` from the `flatbuffers/tests` directory.
 For example, on [Linux](https://en.wikipedia.org/wiki/Linux), you would simply
diff --git a/docs/source/Schemas.md b/docs/source/Schemas.md
index 06c0f5c..10ed260 100644
--- a/docs/source/Schemas.md
+++ b/docs/source/Schemas.md
@@ -211,9 +211,11 @@
 open-ended way, for example for use as files, see the file identification
 feature below.
 
-There is an experimental support only in C++ for a vector of unions
-(and types). In the example IDL file above, use [Any] to add a
-vector of Any to Monster table.
+There is an experimental support only in C++ for a vector of unions (and
+types). In the example IDL file above, use [Any] to add a vector of Any to
+Monster table. There is also experimental support for other types besides
+tables in unions, in particular structs and strings. There's no direct support
+for scalars in unions, but they can be wrapped in a struct at no space cost.
 
 ### Namespaces
 
@@ -237,9 +239,9 @@
 
 ### Root type
 
-This declares what you consider to be the root table (or struct) of the
-serialized data. This is particularly important for parsing JSON data,
-which doesn't include object type information.
+This declares what you consider to be the root table of the serialized
+data. This is particularly important for parsing JSON data, which doesn't
+include object type information.
 
 ### File identification and extension
 
@@ -488,7 +490,7 @@
 tempted to use a dictionary.
 
 Similarly, strings as values should only be used when they are
-truely open-ended. If you can, always use an enum instead.
+truly open-ended. If you can, always use an enum instead.
 
 FlatBuffers doesn't have inheritance, so the way to represent a set
 of related data structures is a union. Unions do have a cost however,
@@ -590,7 +592,7 @@
 
     table { b:int; }
 
-NOT ok. We can only remove a field by deprecation, regardless of wether we use
+NOT ok. We can only remove a field by deprecation, regardless of whether we use
 explicit ids or not.
 
     table { a:uint; b:uint; }
@@ -635,10 +637,14 @@
 Some `FlatBufferBuilder` implementations have an option called `force_defaults`
 that circumvents this "not writing defaults" behavior you can then use
 `IsFieldPresent` to query presence.
-
+/
 Another option that works in all languages is to wrap a scalar field in a
 struct. This way it will return null if it is not present. This will be slightly
 less ergonomic but structs don't take up any more space than the scalar they
 represent.
 
    [Interface Definition Language]: https://en.wikipedia.org/wiki/Interface_description_language
+
+## Writing your own code generator.
+
+See [our intermediate representation](@ref intermediate_representation).
diff --git a/docs/source/Support.md b/docs/source/Support.md
index 4cac209..3436a6f 100644
--- a/docs/source/Support.md
+++ b/docs/source/Support.md
@@ -25,7 +25,7 @@
 Simple mutation                | Yes    | Yes   | Yes      | Yes   | No     | No    | No  | No     | No  | No      | No      | No     | Yes
 Reflection                     | Yes    | No    | No       | No    | No     | No    | No  | Basic  | No  | No      | No      | No     | No
 Buffer verifier                | Yes    | No    | No       | No    | No     | No    | No  | Yes    | No  | No      | No      | No     | No
-Native Object API              | Yes    | No    | Yes      | Yes   | Yes    | Yes   | Yes | No     | No  | No      | No      | No     | No
+Native Object API              | Yes    | No    | Yes      | Yes   | Yes    | Yes   | Yes | No     | No  | Yes     | No      | No     | No
 Optional Scalars               | Yes    | Yes   | Yes      | No    | No     | Yes   | Yes | Yes    | No  | No      | Yes     | Yes    | Yes
 Flexbuffers                    | Yes    | Yes   | ?        | ?     | ?      | ?     | ?   | ?      | ?   | ?       | ?       | Yes    | ?
 Testing: basic                 | Yes    | Yes   | Yes      | Yes   | Yes    | Yes   | Yes | Yes    | ?   | Yes     | Yes     | Yes    | Yes
diff --git a/docs/source/SwiftUsage.md b/docs/source/SwiftUsage.md
index d5640f6..1c438f2 100644
--- a/docs/source/SwiftUsage.md
+++ b/docs/source/SwiftUsage.md
@@ -64,7 +64,8 @@
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.swift}
     let hp = monster.hp
-    let pos = monster.pos
+    let pos = monster.pos // uses native swift structs
+    let pos = monster.mutablePos // uses flatbuffers structs
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
@@ -76,8 +77,10 @@
     if !monster.mutate(hp: 10) {
       fatalError("couldn't mutate")
     }
-    // mutate a struct field
-    let vec = monster.pos.mutate(z: 4)
+    // mutate a struct field using flatbuffers struct
+    // DONT use monster.pos to mutate since swift copy on write 
+    // will not mutate the value in the buffer
+    let vec = monster.mutablePos.mutate(z: 4)
 
     // This mutation will fail because the mana field is not available in
     // the buffer. It should be set when creating the buffer.
diff --git a/docs/source/Tutorial.md b/docs/source/Tutorial.md
index 419ea09..f633425 100644
--- a/docs/source/Tutorial.md
+++ b/docs/source/Tutorial.md
@@ -130,7 +130,7 @@
 [sample_binary.py](https://github.com/google/flatbuffers/blob/master/samples/sample_binary.py)
 </div>
 <div class="language-javascript">
-[samplebinary.js](https://github.com/google/flatbuffers/blob/master/samples/samplebinary.js)
+No sample binary is provided, since JS needs to be transpiled from TypeScript. Please see TypeScript support.
 </div>
 <div class="language-typescript">
 <em>none yet</em>
@@ -231,7 +231,7 @@
 `uint`, or `float`) will be given a default of `0` while strings and tables will
 be given a default of `null`. Another thing to note is the line `friendly:bool =
 false (deprecated);`. Since you cannot delete fields from a `table` (to support
-backwards compatability), you can set fields as `deprecated`, which will prevent
+backwards compatibility), you can set fields as `deprecated`, which will prevent
 the generation of accessors for this field in the generated code. Be careful
 when using `deprecated`, however, as it may break legacy code that used this
 accessor.
@@ -321,7 +321,9 @@
 <div class="language-javascript">
 ~~~{.sh}
   cd flatbuffers/samples
-  ./../flatc --js monster.fbs
+  ./../flatc --ts monster.fbs
+  # customize your TS -> JS transpilation
+  tsc monster_generated.ts
 ~~~
 </div>
 <div class="language-typescript">
@@ -439,8 +441,7 @@
 </div>
 <div class="language-javascript">
 ~~~{.js}
-  // The following code is for JavaScript module loaders (e.g. Node.js). See
-  // below for a browser-based HTML/JavaScript example of including the library.
+  // The following code is an example - use your desired module flavor by transpiling from TS. 
   var flatbuffers = require('/js/flatbuffers').flatbuffers;
   var MyGame = require('./monster_generated').MyGame; // Generated by `flatc`.
 
@@ -544,10 +545,10 @@
   import Flatbuffers
 
   // typealiases for convenience
-  typealias Monster = MyGame1.Sample.Monster
-  typealias Weapon = MyGame1.Sample.Weapon
-  typealias Color = MyGame1.Sample.Color
-  typealias Vec3 = MyGame1.Sample.Vec3
+  typealias Monster = MyGame1_Sample_Monster
+  typealias Weapon = MyGame1_Sample_Weapon
+  typealias Color = MyGame1_Sample_Color
+  typealias Vec3 = MyGame1_Sample_Vec3
 ~~~
 </div>
 
@@ -741,16 +742,16 @@
   weapon_two = builder.CreateString('Axe')
 
   # Create the first `Weapon` ('Sword').
-  MyGame.Sample.Weapon.WeaponStart(builder)
-  MyGame.Sample.Weapon.WeaponAddName(builder, weapon_one)
-  MyGame.Sample.Weapon.WeaponAddDamage(builder, 3)
-  sword = MyGame.Sample.Weapon.WeaponEnd(builder)
+  MyGame.Sample.Weapon.Start(builder)
+  MyGame.Sample.Weapon.AddName(builder, weapon_one)
+  MyGame.Sample.Weapon.AddDamage(builder, 3)
+  sword = MyGame.Sample.Weapon.End(builder)
 
   # Create the second `Weapon` ('Axe').
-  MyGame.Sample.Weapon.WeaponStart(builder)
-  MyGame.Sample.Weapon.WeaponAddName(builder, weapon_two)
-  MyGame.Sample.Weapon.WeaponAddDamage(builder, 5)
-  axe = MyGame.Sample.Weapon.WeaponEnd(builder)
+  MyGame.Sample.Weapon.Start(builder)
+  MyGame.Sample.Weapon.AddName(builder, weapon_two)
+  MyGame.Sample.Weapon.AddDamage(builder, 5)
+  axe = MyGame.Sample.Weapon.End(builder)
 ~~~
 </div>
 <div class="language-javascript">
@@ -1014,10 +1015,10 @@
   # Create a `vector` representing the inventory of the Orc. Each number
   # could correspond to an item that can be claimed after he is slain.
   # Note: Since we prepend the bytes, this loop iterates in reverse.
-  MyGame.Sample.Monster.MonsterStartInventoryVector(builder, 10)
+  MyGame.Sample.Monster.StartInventoryVector(builder, 10)
   for i in reversed(range(0, 10)):
     builder.PrependByte(i)
-  inv = builder.EndVector(10)
+  inv = builder.EndVector()
 ~~~
 </div>
 <div class="language-javascript">
@@ -1089,7 +1090,7 @@
 </div>
 <div class="language-lua">
 ~~~{.py}
-    -- Serialize a name for our mosnter, called 'orc'
+    -- Serialize a name for our monster, called 'orc'
     local name = builder:CreateString("Orc")
 
     -- Create a `vector` representing the inventory of the Orc. Each number
@@ -1204,10 +1205,10 @@
 ~~~{.py}
   # Create a FlatBuffer vector and prepend the weapons.
   # Note: Since we prepend the data, prepend them in reverse order.
-  MyGame.Sample.Monster.MonsterStartWeaponsVector(builder, 2)
+  MyGame.Sample.Monster.StartWeaponsVector(builder, 2)
   builder.PrependUOffsetTRelative(axe)
   builder.PrependUOffsetTRelative(sword)
-  weapons = builder.EndVector(2)
+  weapons = builder.EndVector()
 ~~~
 </div>
 <div class="language-javascript">
@@ -1333,10 +1334,10 @@
 </div>
 <div class="language-python">
 ~~~{.py}
-  MyGame.Sample.Monster.MonsterStartPathVector(builder, 2)
+  MyGame.Sample.Monster.StartPathVector(builder, 2)
   MyGame.Sample.Vec3.CreateVec3(builder, 1.0, 2.0, 3.0)
   MyGame.Sample.Vec3.CreateVec3(builder, 4.0, 5.0, 6.0)
-  path = builder.EndVector(2)
+  path = builder.EndVector()
 ~~~
 </div>
 <div class="language-javascript">
@@ -1420,10 +1421,21 @@
 <div class="language-swift">
 ~~~{.swift}
   //
-  Monster.startVectorOfvec3(2, in: &fbb)
-  MyGame_Example_Vec3.createVec3(builder: &fbb, x: 1, y: 2, z: 3)
-  MyGame_Example_Vec3.createVec3(builder: &fbb, x: 4, y: 5, z: 6)
-  let points = fbb.endVectorOfStructs(count: size)
+  let points = fbb.createVector(ofStructs: [
+    Vec3(x: 1, y: 2, z: 3),
+    Vec3(x: 4, y: 5, z: 6)
+  ])
+
+  // OR
+  var vec3 = [
+    Vec3(x: 1, y: 2, z: 3),
+    Vec3(x: 4, y: 5, z: 6)
+  ]
+  Monster.startVectorOfVec3(2, in: &fbb)
+  for i in obj {
+    _ = create(struct: i)
+  }
+  let points = fbb.endVector(len: size)
 ~~~
 </div>
 
@@ -1513,21 +1525,21 @@
 </div>
 <div class="language-python">
 ~~~{.py}
-  # Create our monster by using `MonsterStart()` and `MonsterEnd()`.
-  MyGame.Sample.Monster.MonsterStart(builder)
-  MyGame.Sample.Monster.MonsterAddPos(builder,
+  # Create our monster by using `Monster.Start()` and `Monster.End()`.
+  MyGame.Sample.Monster.Start(builder)
+  MyGame.Sample.Monster.AddPos(builder,
                           MyGame.Sample.Vec3.CreateVec3(builder, 1.0, 2.0, 3.0))
-  MyGame.Sample.Monster.MonsterAddHp(builder, 300)
-  MyGame.Sample.Monster.MonsterAddName(builder, name)
-  MyGame.Sample.Monster.MonsterAddInventory(builder, inv)
-  MyGame.Sample.Monster.MonsterAddColor(builder,
+  MyGame.Sample.Monster.AddHp(builder, 300)
+  MyGame.Sample.Monster.AddName(builder, name)
+  MyGame.Sample.Monster.AddInventory(builder, inv)
+  MyGame.Sample.Monster.AddColor(builder,
                                         MyGame.Sample.Color.Color().Red)
-  MyGame.Sample.Monster.MonsterAddWeapons(builder, weapons)
-  MyGame.Sample.Monster.MonsterAddEquippedType(
+  MyGame.Sample.Monster.AddWeapons(builder, weapons)
+  MyGame.Sample.Monster.AddEquippedType(
       builder, MyGame.Sample.Equipment.Equipment().Weapon)
-  MyGame.Sample.Monster.MonsterAddEquipped(builder, axe)
-  MyGame.Sample.Monster.MonsterAddPath(builder, path)
-  orc = MyGame.Sample.Monster.MonsterEnd(builder)
+  MyGame.Sample.Monster.AddEquipped(builder, axe)
+  MyGame.Sample.Monster.AddPath(builder, path)
+  orc = MyGame.Sample.Monster.End(builder)
 ~~~
 </div>
 <div class="language-javascript">
@@ -1702,17 +1714,16 @@
 </div>
 <div class="language-swift">
 ~~~{.swift}
-  let start = Monster.startMonster(&builder)
-  let posStruct = MyGame_Example_Vec3.createVec3(builder: &builder, x: 1, y: 2, z: 3)
-  Monster.add(pos: pos, &builder)
-  Monster.add(hp: 300, &builder)
-  Monster.add(name: name, &builder)
-  Monster.addVectorOf(inventory: inventoryOffset, &builder)
-  Monster.add(color: .red, &builder)
-  Monster.addVectorOf(weapons: weaponsOffset, &builder)
-  Monster.add(equippedType: .weapon, &builder)
-  Monster.add(equipped: axe, &builder)
-  var orc = Monster.endMonster(&builder, start: start)
+  let orc = Monster.createMonster(
+    &builder,
+    pos: MyGame_Sample_Vec3(x: 1, y: 2, z: 3),
+    hp: 300,
+    nameOffset: name,
+    inventoryVectorOffset: inventoryOffset,
+    color: .red,
+    weaponsVectorOffset: weaponsOffset,
+    equippedType: .weapon,
+    equippedOffset: axe)
 ~~~
 </div>
 
@@ -1780,6 +1791,21 @@
 ~~~
 </div>
 
+<div class="language-swift">
+~~~{.swift}
+  let start = Monster.startMonster(&builder)
+  Monster.add(pos: Vec3(x: 1, y: 2, z: 3), &builder)
+  Monster.add(hp: 300, &builder)
+  Monster.add(name: name, &builder)
+  Monster.addVectorOf(inventory: inventoryOffset, &builder)
+  Monster.add(color: .red, &builder)
+  Monster.addVectorOf(weapons: weaponsOffset, &builder)
+  Monster.add(equippedType: .weapon, &builder)
+  Monster.add(equipped: axe, &builder)
+  var orc = Monster.endMonster(&builder, start: start)
+~~~
+</div>
+
 Before finishing the serialization, let's take a quick look at FlatBuffer
 `union Equipped`. There are two parts to each FlatBuffer `union`. The first is
 a hidden field `_type` that is generated to hold the type of `table` referred
@@ -1794,7 +1820,7 @@
 <div class="language-cpp">
   ~~~{.cpp}
     monster_builder.add_equipped_type(Equipment_Weapon); // Union type
-    monster_builder.add_equipped(axe); // Union data
+    monster_builder.add_equipped(axe.Union()); // Union data
   ~~~
 </div>
 <div class="language-java">
@@ -1823,9 +1849,9 @@
 </div>
 <div class="language-python">
   ~~~{.py}
-    MyGame.Sample.Monster.MonsterAddEquippedType(            # Union type
+    MyGame.Sample.Monster.AddEquippedType(            # Union type
         builder, MyGame.Sample.Equipment.Equipment().Weapon)
-    MyGame.Sample.Monster.MonsterAddEquipped(builder, axe)   # Union data
+    MyGame.Sample.Monster.AddEquipped(builder, axe)   # Union data
   ~~~
 </div>
 <div class="language-javascript">
@@ -2199,14 +2225,13 @@
 </div>
 <div class="language-javascript">
 ~~~{.js}
-  // The following code is for JavaScript module loaders (e.g. Node.js). See
-  // below for a browser-based HTML/JavaScript example of including the library.
+  // The following code is an example - use your desired module flavor by transpiling from TS. 
   var flatbuffers = require('/js/flatbuffers').flatbuffers;
   var MyGame = require('./monster_generated').MyGame; // Generated by `flatc`.
 
   //--------------------------------------------------------------------------//
 
-  // The following code is for browser-based HTML/JavaScript. Use the above code
+  // The following code an example for browser-based HTML/JavaScript. Use the above code
   // for JavaScript module loaders (e.g. Node.js).
   <script src="../js/flatbuffers.js"></script>
   <script src="monster_generated.js"></script> // Generated by `flatc`.
@@ -2357,7 +2382,7 @@
   buf = /* the data you just read, in an object of type "bytearray" */
 
   // Get an accessor to the root object inside the buffer.
-  monster = MyGame.Sample.Monster.Monster.GetRootAsMonster(buf, 0)
+  monster = MyGame.Sample.Monster.Monster.GetRootAs(buf, 0)
 
   # Note: We use `0` for the offset here, which is typical for most buffers
   # you would read.  If you wanted to read from the `builder.Bytes` directly,
@@ -2945,7 +2970,7 @@
 
 <div class="language-cpp">
 ~~~{.cpp}
-  auto union_type = monster.equipped_type();
+  auto union_type = monster->equipped_type();
 
   if (union_type == Equipment_Weapon) {
     auto weapon = static_cast<const Weapon*>(monster->equipped()); // Requires `static_cast`
@@ -3239,7 +3264,8 @@
 ~~~{.swift}
   let monster = Monster.getRootAsMonster(bb: ByteBuffer(bytes: buf))
   monster.mutate(hp: 10) // mutates a value in a table
-  monster.pos.mutate(z: 4) // mutates a value in a struct
+  /// to mutate structs in swift you have to use the mutable accessors
+  monster.mutablePos.mutate(z: 4) // mutates a value in a struct
   monster.mutate(inventory: 6, at index: 0) // mutates a value in an Scalar array
 ~~~
 </div>
@@ -3366,6 +3392,125 @@
 
 ## Advanced Features for Each Language
 
+### Vector of Unions
+
+Some languages support storing unions directly in a vector.
+
+~~~
+// File found in tests/union_vector/union_vector.fbs
+namespace Example.VectorOfUnions;
+
+// Demonstrates the ability to have vectors of unions, and also to
+// store structs and strings in unions.
+
+table Attacker {
+  sword_attack_damage: int;
+}
+
+struct Rapunzel {
+  hair_length: int;
+}
+
+struct BookReader {
+  books_read: int;
+}
+
+union Character {
+  MuLan: Attacker,  // Can have name be different from type.
+  Rapunzel,         // Or just both the same, as before.
+  Belle: BookReader,
+  BookFan: BookReader,
+  Other: string,
+  Unused: string
+}
+
+table Movie {
+  main_character: Character;
+  characters: [Character];
+}
+~~~
+
+#### Creating
+
+Analagously to how a union adds two fields to a table a vector of unions creates two different vectors:
+one for the union data and one for the data types.
+
+<div class="language-cpp">
+C++ supports vectors of unions, but it isn't currently documented.
+</div>
+<div class="language-typescript">
+Typescript supports vectors of unions, but it isn't currently documented.
+</div>
+<div class="language-php">
+PHP supports vectors of unions, but it isn't currently documented.
+</div>
+<div class="language-java">
+Java supports vectors of unions, but it isn't currently documented.
+</div>
+<div class="language-csharp">
+~~~{.cs}
+using FlatBuffers;
+using Example.VectorOfUnions;
+
+var fbb = new FlatBufferBuilder(100);
+
+var characterTypes = new[]
+{
+    Character.MuLan,
+    Character.Belle,
+    Character.Other,
+};
+var characterTypesOffset = Movie.CreateCharactersTypeVector(fbb, characterTypes);
+
+var characters = new[]
+{
+    Attacker.CreateAttacker(fbb, 10).Value,
+    BookReader.CreateBookReader(fbb, 20).Value,
+    fbb.CreateSharedString("Chip").Value,
+};
+var charactersOffset = Movie.CreateCharactersVector(fbb, characters);
+
+var movieOffset = Movie.CreateMovie(
+    fbb,
+    Character.Rapunzel,
+    rapunzel,
+    characterTypesOffset,
+    charactersOffset);
+Movie.FinishMovieBuffer(fbb, movieOffset);
+~~~
+</div>
+<div class="language-kotlin">
+Kotlin supports vectors of unions, but it isn't currently documented.
+</div>
+<div class="language-swift">
+Swift supports vectors of unions, but it isn't currently documented.
+</div>
+
+#### Reading
+<div class="language-csharp">
+~~~{.cs}
+var movie = Movie.GetRootAsMovie(fbb.DataBuffer);
+
+for (var i = 0; i <= movie.CharactersLength; i++)
+{
+  if (movie.CharactersType(i) == Character.MuLan)
+  {
+    var mulanSwordDamage = movie.Characters<Attacker>(i).Value.SwordAttackDamage;
+  }
+  else if (movie.CharactersType(i) == Character.Belle)
+  {
+    var belleBooksRead = movie.Characters<BookReader>(i).Value.BooksRead;
+  }
+  else if (movie.CharactersType(i) == Character.Other)
+  {
+    var otherStr = movie.CharactersAsString(i);
+  }
+}
+~~~
+</div>
+
+### Further Reading
+
 Each language has a dedicated `Use in XXX` page in the Programmer's Guide
 to cover the nuances of FlatBuffers in that language.
 
diff --git a/docs/source/TypeScriptUsage.md b/docs/source/TypeScriptUsage.md
index 0b9739e..a1acaeb 100644
--- a/docs/source/TypeScriptUsage.md
+++ b/docs/source/TypeScriptUsage.md
@@ -17,7 +17,7 @@
 ## FlatBuffers TypeScript library code location
 
 The code for the FlatBuffers TypeScript library can be found at
-`flatbuffers/js` with typings available at `@types/flatbuffers`.
+https://www.npmjs.com/package/flatbuffers.
 
 ## Testing the FlatBuffers TypeScript library
 
@@ -26,7 +26,7 @@
 
 *Note: The TypeScript test file requires [Node.js](https://nodejs.org/en/).*
 
-## Using the FlatBuffers TypeScript libary
+## Using the FlatBuffers TypeScript library
 
 *Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in TypeScript.*
@@ -43,7 +43,7 @@
 the ByteBuffer to the `getRootAsMonster` function.
 
 ~~~{.ts}
-  // note: import flatbuffers with your desired import method
+  import * as flatbuffers from 'flatbuffers';
 
   import { MyGame } from './monster_generated';
 
@@ -70,8 +70,6 @@
 can be used (through `--gen-object-api`) that is able to unpack & pack a
 FlatBuffer into objects and standard TS types.
 
-**When using the obj based API, the flatbuffers import need to be in the global namespace if you don't have `--no-fb-import` enabled** since creating default values require accessing the `flatbuffers.js` file.
-
 To use:
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.ts}
diff --git a/docs/source/WhitePaper.md b/docs/source/WhitePaper.md
index e504ada..dbad2cb 100644
--- a/docs/source/WhitePaper.md
+++ b/docs/source/WhitePaper.md
@@ -20,7 +20,7 @@
 If it would be possible to do serialization with no temporary objects,
 no additional allocation, no copying, and good locality, this could be
 of great value. The reason serialization systems usually don't manage
-this is because it goes counter to forwards/backwards compatability, and
+this is because it goes counter to forwards/backwards compatibility, and
 platform specifics like endianness and alignment.
 
 FlatBuffers is what you get if you try anyway.
@@ -64,7 +64,7 @@
 between multiple tables with the same layout), and contains information
 where fields for this particular kind of instance of vtable are stored.
 The vtable may also indicate that the field is not present (because this
-FlatBuffer was written with an older version of the software, of simply
+FlatBuffer was written with an older version of the software, or simply
 because the information was not necessary for this instance, or deemed
 deprecated), in which case a default value is returned.
 
diff --git a/docs/source/doxyfile b/docs/source/doxyfile
index 3a5bd98..8cf9000 100644
--- a/docs/source/doxyfile
+++ b/docs/source/doxyfile
@@ -768,6 +768,7 @@
         "WhitePaper.md" \
         "FlexBuffers.md" \
         "Internals.md" \
+        "IntermediateRepresentation.md" \
         "Grammar.md" \
         "../../CONTRIBUTING.md" \
         "Tutorial.md" \
diff --git a/docs/source/doxygen_layout.xml b/docs/source/doxygen_layout.xml
index e1a6b81..28dd065 100644
--- a/docs/source/doxygen_layout.xml
+++ b/docs/source/doxygen_layout.xml
@@ -66,6 +66,8 @@
         title="FlatBuffers white paper"/>
     <tab type="user" url="@ref flatbuffers_internals"
         title="FlatBuffers internals"/>
+    <tab type="user" url="@ref intermediate_representation"
+        title="Intermediate Representation"/>
     <tab type="user" url="@ref flatbuffers_grammar"
         title="Grammar of the schema language"/>
     <tab type="usergroup" url="" title="API Reference">