diff --git a/dart/lib/flat_buffers.dart b/dart/lib/flat_buffers.dart
index 3d4cf81..d27d4bf 100644
--- a/dart/lib/flat_buffers.dart
+++ b/dart/lib/flat_buffers.dart
@@ -22,69 +22,70 @@
 ///
 /// This callback is used by other struct's `finish` methods to write the nested
 /// struct's fields inline.
-typedef void StructBuilder();
+typedef StructBuilder = void Function();
 
 /// Buffer with data and some context about it.
 class BufferContext {
   final ByteData _buffer;
 
-  factory BufferContext.fromBytes(List<int> byteList) {
-    Uint8List uint8List = _asUint8List(byteList);
-    ByteData buf = new ByteData.view(uint8List.buffer, uint8List.offsetInBytes);
-    return new BufferContext._(buf);
-  }
+  ByteData get buffer => _buffer;
 
-  BufferContext._(this._buffer);
+  /// Create from a FlatBuffer represented by a list of bytes (uint8).
+  factory BufferContext.fromBytes(List<int> byteList) =>
+      BufferContext(byteList is Uint8List
+          ? byteList.buffer.asByteData(byteList.offsetInBytes)
+          : ByteData.view(Uint8List.fromList(byteList).buffer));
 
-  int derefObject(int offset) {
-    return offset + _getUint32(offset);
-  }
+  /// Create from a FlatBuffer represented by ByteData.
+  BufferContext(this._buffer);
 
-  Uint8List _asUint8LIst(int offset, int length) =>
+  @pragma('vm:prefer-inline')
+  int derefObject(int offset) => offset + _getUint32(offset);
+
+  @pragma('vm:prefer-inline')
+  Uint8List _asUint8List(int offset, int length) =>
       _buffer.buffer.asUint8List(_buffer.offsetInBytes + offset, length);
 
-  double _getFloat64(int offset) =>
-      _buffer.getFloat64(offset, Endian.little);
+  @pragma('vm:prefer-inline')
+  double _getFloat64(int offset) => _buffer.getFloat64(offset, Endian.little);
 
-  double _getFloat32(int offset) =>
-      _buffer.getFloat32(offset, Endian.little);
+  @pragma('vm:prefer-inline')
+  double _getFloat32(int offset) => _buffer.getFloat32(offset, Endian.little);
 
-  int _getInt64(int offset) =>
-      _buffer.getInt64(offset, Endian.little);
+  @pragma('vm:prefer-inline')
+  int _getInt64(int offset) => _buffer.getInt64(offset, Endian.little);
 
-  int _getInt32(int offset) =>
-      _buffer.getInt32(offset, Endian.little);
+  @pragma('vm:prefer-inline')
+  int _getInt32(int offset) => _buffer.getInt32(offset, Endian.little);
 
-  int _getInt16(int offset) =>
-      _buffer.getInt16(offset, Endian.little);
+  @pragma('vm:prefer-inline')
+  int _getInt16(int offset) => _buffer.getInt16(offset, Endian.little);
 
+  @pragma('vm:prefer-inline')
   int _getInt8(int offset) => _buffer.getInt8(offset);
 
-  int _getUint64(int offset) =>
-      _buffer.getUint64(offset, Endian.little);
+  @pragma('vm:prefer-inline')
+  int _getUint64(int offset) => _buffer.getUint64(offset, Endian.little);
 
-  int _getUint32(int offset) =>
-      _buffer.getUint32(offset, Endian.little);
+  @pragma('vm:prefer-inline')
+  int _getUint32(int offset) => _buffer.getUint32(offset, Endian.little);
 
-  int _getUint16(int offset) =>
-      _buffer.getUint16(offset, Endian.little);
+  @pragma('vm:prefer-inline')
+  int _getUint16(int offset) => _buffer.getUint16(offset, Endian.little);
 
+  @pragma('vm:prefer-inline')
   int _getUint8(int offset) => _buffer.getUint8(offset);
+}
 
-  /// If the [byteList] is already a [Uint8List] return it.
-  /// Otherwise return a [Uint8List] copy of the [byteList].
-  static Uint8List _asUint8List(List<int> byteList) {
-    if (byteList is Uint8List) {
-      return byteList;
-    } else {
-      return new Uint8List.fromList(byteList);
-    }
-  }
+/// Interface implemented by the "object-api" classes (ending with "T").
+abstract class Packable {
+  /// Serialize the object using the given builder, returning the offset.
+  int pack(Builder fbBuilder);
 }
 
 /// Class implemented by typed builders generated by flatc.
 abstract class ObjectBuilder {
-  int _firstOffset;
+  int? _firstOffset;
 
   /// Can be used to write the data represented by this builder to the [Builder]
   /// and reuse the offset created in multiple tables.
@@ -94,7 +95,7 @@
   /// first call to this method.
   int getOrCreateOffset(Builder fbBuilder) {
     _firstOffset ??= finish(fbBuilder);
-    return _firstOffset;
+    return _firstOffset!;
   }
 
   /// Writes the data in this helper to the [Builder].
@@ -107,34 +108,39 @@
 
 /// Class that helps building flat buffers.
 class Builder {
+  bool _finished = false;
+
   final int initialSize;
 
   /// The list of existing VTable(s).
-  //final List<_VTable> _vTables = <_VTable>[];
-  final List<int> _vTables = <int>[];
+  final List<int> _vTables;
+
+  final bool deduplicateTables;
 
   ByteData _buf;
 
+  final Allocator _allocator;
+
   /// The maximum alignment that has been seen so far.  If [_buf] has to be
   /// reallocated in the future (to insert room at its start for more bytes) the
   /// reallocation will need to be a multiple of this many bytes.
-  int _maxAlign;
+  int _maxAlign = 1;
 
   /// The number of bytes that have been written to the buffer so far.  The
   /// most recently written byte is this many bytes from the end of [_buf].
-  int _tail;
+  int _tail = 0;
 
   /// The location of the end of the current table, measured in bytes from the
-  /// end of [_buf], or `null` if a table is not currently being built.
-  int _currentTableEndTail;
+  /// end of [_buf].
+  int _currentTableEndTail = 0;
 
-  _VTable _currentVTable;
+  _VTable? _currentVTable;
 
   /// Map containing all strings that have been written so far.  This allows us
   /// to avoid duplicating strings.
   ///
   /// Allocated only if `internStrings` is set to true on the constructor.
-  Map<String, int> _strings;
+  Map<String, int>? _strings;
 
   /// Creates a new FlatBuffers Builder.
   ///
@@ -142,18 +148,28 @@
   /// automatically grow the array if/as needed.  `internStrings`, if set to
   /// true, will cause [writeString] to pool strings in the buffer so that
   /// identical strings will always use the same offset in tables.
-  Builder({this.initialSize: 1024, bool internStrings = false}) {
-    if (internStrings == true) {
-      _strings = new Map<String, int>();
+  Builder({
+    this.initialSize = 1024,
+    bool internStrings = false,
+    Allocator allocator = const DefaultAllocator(),
+    this.deduplicateTables = true,
+  })  : _allocator = allocator,
+        _buf = allocator.allocate(initialSize),
+        _vTables = deduplicateTables ? [] : const [] {
+    if (internStrings) {
+      _strings = <String, int>{};
     }
-    reset();
   }
 
+  /// Calculate the finished buffer size (aligned).
+  @pragma('vm:prefer-inline')
+  int size() => _tail + ((-_tail) & (_maxAlign - 1));
+
   /// Add the [field] with the given boolean [value].  The field is not added if
   /// the [value] is equal to [def].  Booleans are stored as 8-bit fields with
   /// `0` for `false` and `1` for `true`.
-  void addBool(int field, bool value, [bool def]) {
-    _ensureCurrentVTable();
+  void addBool(int field, bool? value, [bool? def]) {
+    assert(_inVTable);
     if (value != null && value != def) {
       _prepare(_sizeofUint8, 1);
       _trackField(field);
@@ -163,180 +179,183 @@
 
   /// Add the [field] with the given 32-bit signed integer [value].  The field is
   /// not added if the [value] is equal to [def].
-  void addInt32(int field, int value, [int def]) {
-    _ensureCurrentVTable();
+  void addInt32(int field, int? value, [int? def]) {
+    assert(_inVTable);
     if (value != null && value != def) {
       _prepare(_sizeofInt32, 1);
       _trackField(field);
-      _setInt32AtTail(_buf, _tail, value);
+      _setInt32AtTail(_tail, value);
     }
   }
 
   /// Add the [field] with the given 32-bit signed integer [value].  The field is
   /// not added if the [value] is equal to [def].
-  void addInt16(int field, int value, [int def]) {
-    _ensureCurrentVTable();
+  void addInt16(int field, int? value, [int? def]) {
+    assert(_inVTable);
     if (value != null && value != def) {
       _prepare(_sizeofInt16, 1);
       _trackField(field);
-      _setInt16AtTail(_buf, _tail, value);
+      _setInt16AtTail(_tail, value);
     }
   }
 
   /// Add the [field] with the given 8-bit signed integer [value].  The field is
   /// not added if the [value] is equal to [def].
-  void addInt8(int field, int value, [int def]) {
-    _ensureCurrentVTable();
+  void addInt8(int field, int? value, [int? def]) {
+    assert(_inVTable);
     if (value != null && value != def) {
       _prepare(_sizeofInt8, 1);
       _trackField(field);
-      _setInt8AtTail(_buf, _tail, value);
+      _setInt8AtTail(_tail, value);
     }
   }
 
   void addStruct(int field, int offset) {
-    _ensureCurrentVTable();
+    assert(_inVTable);
     _trackField(field);
-    _currentVTable.addField(field, offset);
+    _currentVTable!.addField(field, offset);
   }
 
   /// Add the [field] referencing an object with the given [offset].
-  void addOffset(int field, int offset) {
-    _ensureCurrentVTable();
+  void addOffset(int field, int? offset) {
+    assert(_inVTable);
     if (offset != null) {
       _prepare(_sizeofUint32, 1);
       _trackField(field);
-      _setUint32AtTail(_buf, _tail, _tail - offset);
+      _setUint32AtTail(_tail, _tail - offset);
     }
   }
 
   /// Add the [field] with the given 32-bit unsigned integer [value].  The field
   /// is not added if the [value] is equal to [def].
-  void addUint32(int field, int value, [int def]) {
-    _ensureCurrentVTable();
+  void addUint32(int field, int? value, [int? def]) {
+    assert(_inVTable);
     if (value != null && value != def) {
       _prepare(_sizeofUint32, 1);
       _trackField(field);
-      _setUint32AtTail(_buf, _tail, value);
+      _setUint32AtTail(_tail, value);
     }
   }
 
   /// Add the [field] with the given 32-bit unsigned integer [value].  The field
   /// is not added if the [value] is equal to [def].
-  void addUint16(int field, int value, [int def]) {
-    _ensureCurrentVTable();
+  void addUint16(int field, int? value, [int? def]) {
+    assert(_inVTable);
     if (value != null && value != def) {
       _prepare(_sizeofUint16, 1);
       _trackField(field);
-      _setUint16AtTail(_buf, _tail, value);
+      _setUint16AtTail(_tail, value);
     }
   }
 
   /// Add the [field] with the given 8-bit unsigned integer [value].  The field
   /// is not added if the [value] is equal to [def].
-  void addUint8(int field, int value, [int def]) {
-    _ensureCurrentVTable();
+  void addUint8(int field, int? value, [int? def]) {
+    assert(_inVTable);
     if (value != null && value != def) {
       _prepare(_sizeofUint8, 1);
       _trackField(field);
-      _setUint8AtTail(_buf, _tail, value);
+      _setUint8AtTail(_tail, value);
     }
   }
 
   /// Add the [field] with the given 32-bit float [value].  The field
   /// is not added if the [value] is equal to [def].
-  void addFloat32(int field, double value, [double def]) {
-    _ensureCurrentVTable();
+  void addFloat32(int field, double? value, [double? def]) {
+    assert(_inVTable);
     if (value != null && value != def) {
       _prepare(_sizeofFloat32, 1);
       _trackField(field);
-      _setFloat32AtTail(_buf, _tail, value);
+      _setFloat32AtTail(_tail, value);
     }
   }
 
   /// Add the [field] with the given 64-bit double [value].  The field
   /// is not added if the [value] is equal to [def].
-  void addFloat64(int field, double value, [double def]) {
-    _ensureCurrentVTable();
+  void addFloat64(int field, double? value, [double? def]) {
+    assert(_inVTable);
     if (value != null && value != def) {
       _prepare(_sizeofFloat64, 1);
       _trackField(field);
-      _setFloat64AtTail(_buf, _tail, value);
+      _setFloat64AtTail(_tail, value);
     }
   }
 
   /// Add the [field] with the given 64-bit unsigned integer [value].  The field
   /// is not added if the [value] is equal to [def].
-  void addUint64(int field, int value, [double def]) {
-    _ensureCurrentVTable();
+  void addUint64(int field, int? value, [double? def]) {
+    assert(_inVTable);
     if (value != null && value != def) {
       _prepare(_sizeofUint64, 1);
       _trackField(field);
-      _setUint64AtTail(_buf, _tail, value);
+      _setUint64AtTail(_tail, value);
     }
   }
 
   /// Add the [field] with the given 64-bit unsigned integer [value].  The field
   /// is not added if the [value] is equal to [def].
-  void addInt64(int field, int value, [double def]) {
-    _ensureCurrentVTable();
+  void addInt64(int field, int? value, [double? def]) {
+    assert(_inVTable);
     if (value != null && value != def) {
       _prepare(_sizeofInt64, 1);
       _trackField(field);
-      _setInt64AtTail(_buf, _tail, value);
+      _setInt64AtTail(_tail, value);
     }
   }
 
   /// End the current table and return its offset.
   int endTable() {
-    if (_currentVTable == null) {
-      throw new StateError('Start a table before ending it.');
-    }
+    assert(_inVTable);
     // Prepare for writing the VTable.
     _prepare(_sizeofInt32, 1);
-    int tableTail = _tail;
+    var tableTail = _tail;
     // Prepare the size of the current table.
-    _currentVTable.tableSize = tableTail - _currentTableEndTail;
+    final currentVTable = _currentVTable!;
+    currentVTable.tableSize = tableTail - _currentTableEndTail;
     // Prepare the VTable to use for the current table.
-    int vTableTail;
+    int? vTableTail;
     {
-      _currentVTable.computeFieldOffsets(tableTail);
-      // Try to find an existing compatible VTable.
-      // Search backward - more likely to have recently used one
-      for (int i = _vTables.length - 1; i >= 0; i--) {
-        final int vt2Offset = _vTables[i];
-        final int vt2Start = _buf.lengthInBytes - vt2Offset;
-        final int vt2Size = _buf.getUint16(vt2Start, Endian.little);
+      currentVTable.computeFieldOffsets(tableTail);
 
-        if (_currentVTable._vTableSize == vt2Size &&
-            _currentVTable._offsetsMatch(vt2Start, _buf)) {
-          vTableTail = vt2Offset;
-          break;
+      // Try to find an existing compatible VTable.
+      if (deduplicateTables) {
+        // Search backward - more likely to have recently used one
+        for (var i = _vTables.length - 1; i >= 0; i--) {
+          final vt2Offset = _vTables[i];
+          final vt2Start = _buf.lengthInBytes - vt2Offset;
+          final vt2Size = _buf.getUint16(vt2Start, Endian.little);
+
+          if (currentVTable._vTableSize == vt2Size &&
+              currentVTable._offsetsMatch(vt2Start, _buf)) {
+            vTableTail = vt2Offset;
+            break;
+          }
         }
       }
+
       // Write a new VTable.
       if (vTableTail == null) {
-        _prepare(_sizeofUint16, _currentVTable.numOfUint16);
+        _prepare(_sizeofUint16, _currentVTable!.numOfUint16);
         vTableTail = _tail;
-        _currentVTable.tail = vTableTail;
-        _currentVTable.output(_buf, _buf.lengthInBytes - _tail);
-        _vTables.add(_currentVTable.tail);
+        currentVTable.tail = vTableTail;
+        currentVTable.output(_buf, _buf.lengthInBytes - _tail);
+        if (deduplicateTables) _vTables.add(currentVTable.tail);
       }
     }
     // Set the VTable offset.
-    _setInt32AtTail(_buf, tableTail, vTableTail - tableTail);
+    _setInt32AtTail(tableTail, vTableTail - tableTail);
     // Done with this table.
     _currentVTable = null;
     return tableTail;
   }
 
-  /// This method low level method can be used to return a raw piece of the buffer
-  /// after using the the put* methods.
-  ///
-  /// Most clients should prefer calling [finish].
-  Uint8List lowFinish() {
-    int alignedTail = _tail + ((-_tail) % _maxAlign);
-    return _buf.buffer.asUint8List(_buf.lengthInBytes - alignedTail);
+  /// Returns the finished buffer. You must call [finish] before accessing this.
+  @pragma('vm:prefer-inline')
+  Uint8List get buffer {
+    assert(_finished);
+    final finishedSize = size();
+    return _buf.buffer
+        .asUint8List(_buf.lengthInBytes - finishedSize, finishedSize);
   }
 
   /// Finish off the creation of the buffer.  The given [offset] is used as the
@@ -344,17 +363,26 @@
   /// written object.  If [fileIdentifier] is specified (and not `null`), it is
   /// interpreted as a 4-byte Latin-1 encoded string that should be placed at
   /// bytes 4-7 of the file.
-  Uint8List finish(int offset, [String fileIdentifier]) {
-    _prepare(max(_sizeofUint32, _maxAlign), fileIdentifier == null ? 1 : 2);
-    int alignedTail = _tail + ((-_tail) % _maxAlign);
-    _setUint32AtTail(_buf, alignedTail, alignedTail - offset);
+  void finish(int offset, [String? fileIdentifier]) {
+    final sizeBeforePadding = size();
+    final requiredBytes = _sizeofUint32 * (fileIdentifier == null ? 1 : 2);
+    _prepare(max(requiredBytes, _maxAlign), 1);
+    final finishedSize = size();
+    _setUint32AtTail(finishedSize, finishedSize - offset);
     if (fileIdentifier != null) {
-      for (int i = 0; i < 4; i++) {
-        _setUint8AtTail(_buf, alignedTail - _sizeofUint32 - i,
-            fileIdentifier.codeUnitAt(i));
+      for (var i = 0; i < 4; i++) {
+        _setUint8AtTail(
+            finishedSize - _sizeofUint32 - i, fileIdentifier.codeUnitAt(i));
       }
     }
-    return _buf.buffer.asUint8List(_buf.lengthInBytes - alignedTail);
+
+    // zero out the added padding
+    for (var i = sizeBeforePadding + 1;
+        i <= finishedSize - requiredBytes;
+        i++) {
+      _setUint8AtTail(i, 0);
+    }
+    _finished = true;
   }
 
   /// Writes a Float64 to the tail of the buffer after preparing space for it.
@@ -362,7 +390,7 @@
   /// Updates the [offset] pointer.  This method is intended for use when writing structs to the buffer.
   void putFloat64(double value) {
     _prepare(_sizeofFloat64, 1);
-    _setFloat32AtTail(_buf, _tail, value);
+    _setFloat32AtTail(_tail, value);
   }
 
   /// Writes a Float32 to the tail of the buffer after preparing space for it.
@@ -370,7 +398,7 @@
   /// Updates the [offset] pointer.  This method is intended for use when writing structs to the buffer.
   void putFloat32(double value) {
     _prepare(_sizeofFloat32, 1);
-    _setFloat32AtTail(_buf, _tail, value);
+    _setFloat32AtTail(_tail, value);
   }
 
   /// Writes a Int64 to the tail of the buffer after preparing space for it.
@@ -378,7 +406,7 @@
   /// Updates the [offset] pointer.  This method is intended for use when writing structs to the buffer.
   void putInt64(int value) {
     _prepare(_sizeofInt64, 1);
-    _setInt64AtTail(_buf, _tail, value);
+    _setInt64AtTail(_tail, value);
   }
 
   /// Writes a Uint32 to the tail of the buffer after preparing space for it.
@@ -386,7 +414,7 @@
   /// Updates the [offset] pointer.  This method is intended for use when writing structs to the buffer.
   void putInt32(int value) {
     _prepare(_sizeofInt32, 1);
-    _setInt32AtTail(_buf, _tail, value);
+    _setInt32AtTail(_tail, value);
   }
 
   /// Writes a Uint16 to the tail of the buffer after preparing space for it.
@@ -394,7 +422,7 @@
   /// Updates the [offset] pointer.  This method is intended for use when writing structs to the buffer.
   void putInt16(int value) {
     _prepare(_sizeofInt16, 1);
-    _setInt16AtTail(_buf, _tail, value);
+    _setInt16AtTail(_tail, value);
   }
 
   /// Writes a Uint8 to the tail of the buffer after preparing space for it.
@@ -410,7 +438,7 @@
   /// Updates the [offset] pointer.  This method is intended for use when writing structs to the buffer.
   void putUint64(int value) {
     _prepare(_sizeofUint64, 1);
-    _setUint64AtTail(_buf, _tail, value);
+    _setUint64AtTail(_tail, value);
   }
 
   /// Writes a Uint32 to the tail of the buffer after preparing space for it.
@@ -418,7 +446,7 @@
   /// Updates the [offset] pointer.  This method is intended for use when writing structs to the buffer.
   void putUint32(int value) {
     _prepare(_sizeofUint32, 1);
-    _setUint32AtTail(_buf, _tail, value);
+    _setUint32AtTail(_tail, value);
   }
 
   /// Writes a Uint16 to the tail of the buffer after preparing space for it.
@@ -426,7 +454,7 @@
   /// Updates the [offset] pointer.  This method is intended for use when writing structs to the buffer.
   void putUint16(int value) {
     _prepare(_sizeofUint16, 1);
-    _setUint16AtTail(_buf, _tail, value);
+    _setUint16AtTail(_tail, value);
   }
 
   /// Writes a Uint8 to the tail of the buffer after preparing space for it.
@@ -439,21 +467,20 @@
 
   /// Reset the builder and make it ready for filling a new buffer.
   void reset() {
-    _buf = new ByteData(initialSize);
+    _finished = false;
     _maxAlign = 1;
     _tail = 0;
     _currentVTable = null;
+    if (deduplicateTables) _vTables.clear();
     if (_strings != null) {
-      _strings = new Map<String, int>();
+      _strings = <String, int>{};
     }
   }
 
-  /// Start a new table.  Must be finished with [endTable] invocation.
-  void startTable() {
-    if (_currentVTable != null) {
-      throw new StateError('Inline tables are not supported.');
-    }
-    _currentVTable = new _VTable();
+  /// Start a new table. Must be finished with [endTable] invocation.
+  void startTable(int numFields) {
+    assert(!_inVTable); // Inline tables are not supported.
+    _currentVTable = _VTable(numFields);
     _currentTableEndTail = _tail;
   }
 
@@ -467,8 +494,8 @@
 
   /// Writes a list of Structs to the buffer, returning the offset
   int writeListOfStructs(List<ObjectBuilder> structBuilders) {
-    _ensureNoVTable();
-    for (int i = structBuilders.length - 1; i >= 0; i--) {
+    assert(!_inVTable);
+    for (var i = structBuilders.length - 1; i >= 0; i--) {
       structBuilders[i].finish(this);
     }
     return endStructVector(structBuilders.length);
@@ -476,14 +503,14 @@
 
   /// Write the given list of [values].
   int writeList(List<int> values) {
-    _ensureNoVTable();
+    assert(!_inVTable);
     _prepare(_sizeofUint32, 1 + values.length);
-    final int result = _tail;
-    int tail = _tail;
-    _setUint32AtTail(_buf, tail, values.length);
+    final result = _tail;
+    var tail = _tail;
+    _setUint32AtTail(tail, values.length);
     tail -= _sizeofUint32;
-    for (int value in values) {
-      _setUint32AtTail(_buf, tail, tail - value);
+    for (var value in values) {
+      _setUint32AtTail(tail, tail - value);
       tail -= _sizeofUint32;
     }
     return result;
@@ -491,14 +518,14 @@
 
   /// Write the given list of 64-bit float [values].
   int writeListFloat64(List<double> values) {
-    _ensureNoVTable();
+    assert(!_inVTable);
     _prepare(_sizeofFloat64, values.length, additionalBytes: _sizeofUint32);
-    final int result = _tail;
-    int tail = _tail;
-    _setUint32AtTail(_buf, tail, values.length);
+    final result = _tail;
+    var tail = _tail;
+    _setUint32AtTail(tail, values.length);
     tail -= _sizeofUint32;
-    for (double value in values) {
-      _setFloat64AtTail(_buf, tail, value);
+    for (var value in values) {
+      _setFloat64AtTail(tail, value);
       tail -= _sizeofFloat64;
     }
     return result;
@@ -506,14 +533,14 @@
 
   /// Write the given list of 32-bit float [values].
   int writeListFloat32(List<double> values) {
-    _ensureNoVTable();
+    assert(!_inVTable);
     _prepare(_sizeofFloat32, 1 + values.length);
-    final int result = _tail;
-    int tail = _tail;
-    _setUint32AtTail(_buf, tail, values.length);
+    final result = _tail;
+    var tail = _tail;
+    _setUint32AtTail(tail, values.length);
     tail -= _sizeofUint32;
-    for (double value in values) {
-      _setFloat32AtTail(_buf, tail, value);
+    for (var value in values) {
+      _setFloat32AtTail(tail, value);
       tail -= _sizeofFloat32;
     }
     return result;
@@ -521,14 +548,14 @@
 
   /// Write the given list of signed 64-bit integer [values].
   int writeListInt64(List<int> values) {
-    _ensureNoVTable();
+    assert(!_inVTable);
     _prepare(_sizeofInt64, values.length, additionalBytes: _sizeofUint32);
-    final int result = _tail;
-    int tail = _tail;
-    _setUint32AtTail(_buf, tail, values.length);
+    final result = _tail;
+    var tail = _tail;
+    _setUint32AtTail(tail, values.length);
     tail -= _sizeofUint32;
-    for (int value in values) {
-      _setInt64AtTail(_buf, tail, value);
+    for (var value in values) {
+      _setInt64AtTail(tail, value);
       tail -= _sizeofInt64;
     }
     return result;
@@ -536,14 +563,14 @@
 
   /// Write the given list of signed 64-bit integer [values].
   int writeListUint64(List<int> values) {
-    _ensureNoVTable();
+    assert(!_inVTable);
     _prepare(_sizeofUint64, values.length, additionalBytes: _sizeofUint32);
-    final int result = _tail;
-    int tail = _tail;
-    _setUint32AtTail(_buf, tail, values.length);
+    final result = _tail;
+    var tail = _tail;
+    _setUint32AtTail(tail, values.length);
     tail -= _sizeofUint32;
-    for (int value in values) {
-      _setUint64AtTail(_buf, tail, value);
+    for (var value in values) {
+      _setUint64AtTail(tail, value);
       tail -= _sizeofUint64;
     }
     return result;
@@ -551,14 +578,14 @@
 
   /// Write the given list of signed 32-bit integer [values].
   int writeListInt32(List<int> values) {
-    _ensureNoVTable();
+    assert(!_inVTable);
     _prepare(_sizeofUint32, 1 + values.length);
-    final int result = _tail;
-    int tail = _tail;
-    _setUint32AtTail(_buf, tail, values.length);
+    final result = _tail;
+    var tail = _tail;
+    _setUint32AtTail(tail, values.length);
     tail -= _sizeofUint32;
-    for (int value in values) {
-      _setInt32AtTail(_buf, tail, value);
+    for (var value in values) {
+      _setInt32AtTail(tail, value);
       tail -= _sizeofInt32;
     }
     return result;
@@ -566,14 +593,14 @@
 
   /// Write the given list of unsigned 32-bit integer [values].
   int writeListUint32(List<int> values) {
-    _ensureNoVTable();
+    assert(!_inVTable);
     _prepare(_sizeofUint32, 1 + values.length);
-    final int result = _tail;
-    int tail = _tail;
-    _setUint32AtTail(_buf, tail, values.length);
+    final result = _tail;
+    var tail = _tail;
+    _setUint32AtTail(tail, values.length);
     tail -= _sizeofUint32;
-    for (int value in values) {
-      _setUint32AtTail(_buf, tail, value);
+    for (var value in values) {
+      _setUint32AtTail(tail, value);
       tail -= _sizeofUint32;
     }
     return result;
@@ -581,14 +608,14 @@
 
   /// Write the given list of signed 16-bit integer [values].
   int writeListInt16(List<int> values) {
-    _ensureNoVTable();
+    assert(!_inVTable);
     _prepare(_sizeofUint32, 1, additionalBytes: 2 * values.length);
-    final int result = _tail;
-    int tail = _tail;
-    _setUint32AtTail(_buf, tail, values.length);
+    final result = _tail;
+    var tail = _tail;
+    _setUint32AtTail(tail, values.length);
     tail -= _sizeofUint32;
-    for (int value in values) {
-      _setInt16AtTail(_buf, tail, value);
+    for (var value in values) {
+      _setInt16AtTail(tail, value);
       tail -= _sizeofInt16;
     }
     return result;
@@ -596,14 +623,14 @@
 
   /// Write the given list of unsigned 16-bit integer [values].
   int writeListUint16(List<int> values) {
-    _ensureNoVTable();
+    assert(!_inVTable);
     _prepare(_sizeofUint32, 1, additionalBytes: 2 * values.length);
-    final int result = _tail;
-    int tail = _tail;
-    _setUint32AtTail(_buf, tail, values.length);
+    final result = _tail;
+    var tail = _tail;
+    _setUint32AtTail(tail, values.length);
     tail -= _sizeofUint32;
-    for (int value in values) {
-      _setUint16AtTail(_buf, tail, value);
+    for (var value in values) {
+      _setUint16AtTail(tail, value);
       tail -= _sizeofUint16;
     }
     return result;
@@ -611,19 +638,19 @@
 
   /// Write the given list of bools as unsigend 8-bit integer [values].
   int writeListBool(List<bool> values) {
-    return writeListUint8(values?.map((b) => b ? 1 : 0)?.toList());
+    return writeListUint8(values.map((b) => b ? 1 : 0).toList());
   }
 
   /// Write the given list of signed 8-bit integer [values].
   int writeListInt8(List<int> values) {
-    _ensureNoVTable();
+    assert(!_inVTable);
     _prepare(_sizeofUint32, 1, additionalBytes: values.length);
-    final int result = _tail;
-    int tail = _tail;
-    _setUint32AtTail(_buf, tail, values.length);
+    final result = _tail;
+    var tail = _tail;
+    _setUint32AtTail(tail, values.length);
     tail -= _sizeofUint32;
-    for (int value in values) {
-      _setInt8AtTail(_buf, tail, value);
+    for (var value in values) {
+      _setInt8AtTail(tail, value);
       tail -= _sizeofUint8;
     }
     return result;
@@ -631,146 +658,187 @@
 
   /// Write the given list of unsigned 8-bit integer [values].
   int writeListUint8(List<int> values) {
-    _ensureNoVTable();
+    assert(!_inVTable);
     _prepare(_sizeofUint32, 1, additionalBytes: values.length);
-    final int result = _tail;
-    int tail = _tail;
-    _setUint32AtTail(_buf, tail, values.length);
+    final result = _tail;
+    var tail = _tail;
+    _setUint32AtTail(tail, values.length);
     tail -= _sizeofUint32;
-    for (int value in values) {
-      _setUint8AtTail(_buf, tail, value);
+    for (var value in values) {
+      _setUint8AtTail(tail, value);
       tail -= _sizeofUint8;
     }
     return result;
   }
 
-  /// Write the given string [value] and return its offset, or `null` if
-  /// the [value] is `null`.
-  int writeString(String value) {
-    _ensureNoVTable();
-    if (value != null) {
-      if (_strings != null) {
-        return _strings.putIfAbsent(value, () => _writeString(value));
-      } else {
-        return _writeString(value);
-      }
+  /// Write the given string [value] and return its offset.
+  ///
+  /// Dart strings are UTF-16 but must be stored as UTF-8 in FlatBuffers.
+  /// If the given string consists only of ASCII characters, you can indicate
+  /// enable [asciiOptimization]. In this mode, [writeString()] first tries to
+  /// copy the ASCII string directly to the output buffer and if that fails
+  /// (because there are no-ASCII characters in the string) it falls back and to
+  /// the default UTF-16 -> UTF-8 conversion (with slight performance penalty).
+  int writeString(String value, {bool asciiOptimization = false}) {
+    assert(!_inVTable);
+    if (_strings != null) {
+      return _strings!
+          .putIfAbsent(value, () => _writeString(value, asciiOptimization));
+    } else {
+      return _writeString(value, asciiOptimization);
     }
-    return null;
   }
 
-  int _writeString(String value) {
-    // TODO(scheglov) optimize for ASCII strings
-    List<int> bytes = utf8.encode(value);
-    int length = bytes.length;
+  int _writeString(String value, bool asciiOptimization) {
+    if (asciiOptimization) {
+      // [utf8.encode()] is slow (up to at least Dart SDK 2.13). If the given
+      // string is ASCII we can just write it directly, without any conversion.
+      final originalTail = _tail;
+      if (_tryWriteASCIIString(value)) return _tail;
+      // if non-ASCII: reset the output buffer position for [_writeUTFString()]
+      _tail = originalTail;
+    }
+    _writeUTFString(value);
+    return _tail;
+  }
+
+  // Try to write the string as ASCII, return false if there's a non-ascii char.
+  @pragma('vm:prefer-inline')
+  bool _tryWriteASCIIString(String value) {
+    _prepare(4, 1, additionalBytes: value.length + 1);
+    final length = value.length;
+    var offset = _buf.lengthInBytes - _tail + 4;
+    for (var i = 0; i < length; i++) {
+      // utf16 code unit, e.g. for '†' it's [0x20 0x20], which is 8224 decimal.
+      // ASCII characters go from 0x00 to 0x7F (which is 0 to 127 decimal).
+      final char = value.codeUnitAt(i);
+      if ((char & ~0x7F) != 0) {
+        return false;
+      }
+      _buf.setUint8(offset++, char);
+    }
+    _buf.setUint8(offset, 0); // trailing zero
+    _setUint32AtTail(_tail, value.length);
+    return true;
+  }
+
+  @pragma('vm:prefer-inline')
+  void _writeUTFString(String value) {
+    final bytes = utf8.encode(value) as Uint8List;
+    final length = bytes.length;
     _prepare(4, 1, additionalBytes: length + 1);
-    final int result = _tail;
-    _setUint32AtTail(_buf, _tail, length);
-    int offset = _buf.lengthInBytes - _tail + 4;
-    for (int i = 0; i < length; i++) {
+    _setUint32AtTail(_tail, length);
+    var offset = _buf.lengthInBytes - _tail + 4;
+    for (var i = 0; i < length; i++) {
       _buf.setUint8(offset++, bytes[i]);
     }
-    return result;
+    _buf.setUint8(offset, 0); // trailing zero
   }
 
-  /// Throw an exception if there is not currently a vtable.
-  void _ensureCurrentVTable() {
-    if (_currentVTable == null) {
-      throw new StateError('Start a table before adding values.');
-    }
-  }
-
-  /// Throw an exception if there is currently a vtable.
-  void _ensureNoVTable() {
-    if (_currentVTable != null) {
-      throw new StateError(
-          'Cannot write a non-scalar value while writing a table.');
-    }
-  }
+  /// Used to assert whether a "Table" is currently being built.
+  ///
+  /// If you hit `assert(!_inVTable())`, you're trying to add table fields
+  /// without starting a table with [Builder.startTable()].
+  ///
+  /// If you hit `assert(_inVTable())`, you're trying to construct a
+  /// Table/Vector/String during the construction of its parent table,
+  /// between the MyTableBuilder and [Builder.endTable()].
+  /// Move the creation of these sub-objects to before the MyTableBuilder to
+  /// not get this assert.
+  @pragma('vm:prefer-inline')
+  bool get _inVTable => _currentVTable != null;
 
   /// The number of bytes that have been written to the buffer so far.  The
   /// most recently written byte is this many bytes from the end of the buffer.
+  @pragma('vm:prefer-inline')
   int get offset => _tail;
 
   /// Zero-pads the buffer, which may be required for some struct layouts.
+  @pragma('vm:prefer-inline')
   void pad(int howManyBytes) {
-    for (int i = 0; i < howManyBytes; i++) putUint8(0);
+    for (var i = 0; i < howManyBytes; i++) {
+      putUint8(0);
+    }
   }
 
   /// Prepare for writing the given `count` of scalars of the given `size`.
   /// Additionally allocate the specified `additionalBytes`. Update the current
   /// tail pointer to point at the allocated space.
+  @pragma('vm:prefer-inline')
   void _prepare(int size, int count, {int additionalBytes = 0}) {
+    assert(!_finished);
     // Update the alignment.
     if (_maxAlign < size) {
       _maxAlign = size;
     }
     // Prepare amount of required space.
-    int dataSize = size * count + additionalBytes;
-    int alignDelta = (-(_tail + dataSize)) % size;
-    int bufSize = alignDelta + dataSize;
+    var dataSize = size * count + additionalBytes;
+    var alignDelta = (-(_tail + dataSize)) & (size - 1);
+    var bufSize = alignDelta + dataSize;
     // Ensure that we have the required amount of space.
     {
-      int oldCapacity = _buf.lengthInBytes;
+      var oldCapacity = _buf.lengthInBytes;
       if (_tail + bufSize > oldCapacity) {
-        int desiredNewCapacity = (oldCapacity + bufSize) * 2;
-        int deltaCapacity = desiredNewCapacity - oldCapacity;
-        deltaCapacity += (-deltaCapacity) % _maxAlign;
-        int newCapacity = oldCapacity + deltaCapacity;
-        ByteData newBuf = new ByteData(newCapacity);
-        newBuf.buffer
-            .asUint8List()
-            .setAll(deltaCapacity, _buf.buffer.asUint8List());
-        _buf = newBuf;
+        var desiredNewCapacity = (oldCapacity + bufSize) * 2;
+        var deltaCapacity = desiredNewCapacity - oldCapacity;
+        deltaCapacity += (-deltaCapacity) & (_maxAlign - 1);
+        var newCapacity = oldCapacity + deltaCapacity;
+        _buf = _allocator.resize(_buf, newCapacity, _tail, 0);
       }
     }
+
+    // zero out the added padding
+    for (var i = _tail + 1; i <= _tail + alignDelta; i++) {
+      _setUint8AtTail(i, 0);
+    }
+
     // Update the tail pointer.
     _tail += bufSize;
   }
 
   /// Record the offset of the given [field].
-  void _trackField(int field) {
-    _currentVTable.addField(field, _tail);
-  }
+  @pragma('vm:prefer-inline')
+  void _trackField(int field) => _currentVTable!.addField(field, _tail);
 
-  static void _setFloat64AtTail(ByteData _buf, int tail, double x) {
-    _buf.setFloat64(_buf.lengthInBytes - tail, x, Endian.little);
-  }
+  @pragma('vm:prefer-inline')
+  void _setFloat64AtTail(int tail, double x) =>
+      _buf.setFloat64(_buf.lengthInBytes - tail, x, Endian.little);
 
-  static void _setFloat32AtTail(ByteData _buf, int tail, double x) {
-    _buf.setFloat32(_buf.lengthInBytes - tail, x, Endian.little);
-  }
+  @pragma('vm:prefer-inline')
+  void _setFloat32AtTail(int tail, double x) =>
+      _buf.setFloat32(_buf.lengthInBytes - tail, x, Endian.little);
 
-  static void _setUint64AtTail(ByteData _buf, int tail, int x) {
-    _buf.setUint64(_buf.lengthInBytes - tail, x, Endian.little);
-  }
+  @pragma('vm:prefer-inline')
+  void _setUint64AtTail(int tail, int x) =>
+      _buf.setUint64(_buf.lengthInBytes - tail, x, Endian.little);
 
-  static void _setInt64AtTail(ByteData _buf, int tail, int x) {
-    _buf.setInt64(_buf.lengthInBytes - tail, x, Endian.little);
-  }
+  @pragma('vm:prefer-inline')
+  void _setInt64AtTail(int tail, int x) =>
+      _buf.setInt64(_buf.lengthInBytes - tail, x, Endian.little);
 
-  static void _setInt32AtTail(ByteData _buf, int tail, int x) {
-    _buf.setInt32(_buf.lengthInBytes - tail, x, Endian.little);
-  }
+  @pragma('vm:prefer-inline')
+  void _setInt32AtTail(int tail, int x) =>
+      _buf.setInt32(_buf.lengthInBytes - tail, x, Endian.little);
 
-  static void _setUint32AtTail(ByteData _buf, int tail, int x) {
-    _buf.setUint32(_buf.lengthInBytes - tail, x, Endian.little);
-  }
+  @pragma('vm:prefer-inline')
+  void _setUint32AtTail(int tail, int x) =>
+      _buf.setUint32(_buf.lengthInBytes - tail, x, Endian.little);
 
-  static void _setInt16AtTail(ByteData _buf, int tail, int x) {
-    _buf.setInt16(_buf.lengthInBytes - tail, x, Endian.little);
-  }
+  @pragma('vm:prefer-inline')
+  void _setInt16AtTail(int tail, int x) =>
+      _buf.setInt16(_buf.lengthInBytes - tail, x, Endian.little);
 
-  static void _setUint16AtTail(ByteData _buf, int tail, int x) {
-    _buf.setUint16(_buf.lengthInBytes - tail, x, Endian.little);
-  }
+  @pragma('vm:prefer-inline')
+  void _setUint16AtTail(int tail, int x) =>
+      _buf.setUint16(_buf.lengthInBytes - tail, x, Endian.little);
 
-  static void _setInt8AtTail(ByteData _buf, int tail, int x) {
-    _buf.setInt8(_buf.lengthInBytes - tail, x);
-  }
+  @pragma('vm:prefer-inline')
+  void _setInt8AtTail(int tail, int x) =>
+      _buf.setInt8(_buf.lengthInBytes - tail, x);
 
-  static void _setUint8AtTail(ByteData _buf, int tail, int x) {
-    _buf.setUint8(_buf.lengthInBytes - tail, x);
-  }
+  @pragma('vm:prefer-inline')
+  void _setUint8AtTail(int tail, int x) =>
+      _buf.setUint8(_buf.lengthInBytes - tail, x);
 }
 
 /// Reader of lists of boolean values.
@@ -780,11 +848,13 @@
   const BoolListReader();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofUint32;
 
   @override
+  @pragma('vm:prefer-inline')
   List<bool> read(BufferContext bc, int offset) =>
-      new _FbBoolList(bc, bc.derefObject(offset));
+      _FbBoolList(bc, bc.derefObject(offset));
 }
 
 /// The reader of booleans.
@@ -792,9 +862,11 @@
   const BoolReader() : super();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofUint8;
 
   @override
+  @pragma('vm:prefer-inline')
   bool read(BufferContext bc, int offset) => bc._getInt8(offset) != 0;
 }
 
@@ -805,31 +877,37 @@
   const Float64ListReader();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofFloat64;
 
   @override
+  @pragma('vm:prefer-inline')
   List<double> read(BufferContext bc, int offset) =>
-      new _FbFloat64List(bc, bc.derefObject(offset));
+      _FbFloat64List(bc, bc.derefObject(offset));
 }
 
 class Float32ListReader extends Reader<List<double>> {
   const Float32ListReader();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofFloat32;
 
   @override
+  @pragma('vm:prefer-inline')
   List<double> read(BufferContext bc, int offset) =>
-      new _FbFloat32List(bc, bc.derefObject(offset));
+      _FbFloat32List(bc, bc.derefObject(offset));
 }
 
 class Float64Reader extends Reader<double> {
   const Float64Reader();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofFloat64;
 
   @override
+  @pragma('vm:prefer-inline')
   double read(BufferContext bc, int offset) => bc._getFloat64(offset);
 }
 
@@ -837,18 +915,23 @@
   const Float32Reader();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofFloat32;
 
   @override
+  @pragma('vm:prefer-inline')
   double read(BufferContext bc, int offset) => bc._getFloat32(offset);
 }
 
 class Int64Reader extends Reader<int> {
   const Int64Reader() : super();
+
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofInt64;
 
   @override
+  @pragma('vm:prefer-inline')
   int read(BufferContext bc, int offset) => bc._getInt64(offset);
 }
 
@@ -857,9 +940,11 @@
   const Int32Reader() : super();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofInt32;
 
   @override
+  @pragma('vm:prefer-inline')
   int read(BufferContext bc, int offset) => bc._getInt32(offset);
 }
 
@@ -868,9 +953,11 @@
   const Int16Reader() : super();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofInt16;
 
   @override
+  @pragma('vm:prefer-inline')
   int read(BufferContext bc, int offset) => bc._getInt16(offset);
 }
 
@@ -879,26 +966,43 @@
   const Int8Reader() : super();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofInt8;
 
   @override
+  @pragma('vm:prefer-inline')
   int read(BufferContext bc, int offset) => bc._getInt8(offset);
 }
 
-/// The reader of lists of objects.
-///
-/// The returned unmodifiable lists lazily read objects on access.
+/// The reader of lists of objects. Lazy by default - see [lazy].
 class ListReader<E> extends Reader<List<E>> {
   final Reader<E> _elementReader;
 
-  const ListReader(this._elementReader);
+  /// Enables lazy reading of the list
+  ///
+  /// If true, the returned unmodifiable list lazily reads objects on access.
+  /// Therefore, the underlying buffer must not change while accessing the list.
+  ///
+  /// If false, reads the whole list immediately on access.
+  final bool lazy;
+
+  const ListReader(this._elementReader, {this.lazy = true});
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofUint32;
 
   @override
-  List<E> read(BufferContext bc, int offset) =>
-      new _FbGenericList<E>(_elementReader, bc, bc.derefObject(offset));
+  List<E> read(BufferContext bc, int offset) {
+    final listOffset = bc.derefObject(offset);
+    return lazy
+        ? _FbGenericList<E>(_elementReader, bc, listOffset)
+        : List<E>.generate(
+            bc.buffer.getUint32(listOffset, Endian.little),
+            (int index) => _elementReader.read(
+                bc, listOffset + size + _elementReader.size * index),
+            growable: true);
+  }
 }
 
 /// Object that can read a value at a [BufferContext].
@@ -912,43 +1016,55 @@
   T read(BufferContext bc, int offset);
 
   /// Read the value of the given [field] in the given [object].
-  T vTableGet(BufferContext object, int offset, int field, [T defaultValue]) {
-    int vTableSOffset = object._getInt32(offset);
-    int vTableOffset = offset - vTableSOffset;
-    int vTableSize = object._getUint16(vTableOffset);
-    int vTableFieldOffset = field;
-    if (vTableFieldOffset < vTableSize) {
-      int fieldOffsetInObject =
-          object._getUint16(vTableOffset + vTableFieldOffset);
-      if (fieldOffsetInObject != 0) {
-        return read(object, offset + fieldOffsetInObject);
-      }
-    }
-    return defaultValue;
+  @pragma('vm:prefer-inline')
+  T vTableGet(BufferContext object, int offset, int field, T defaultValue) {
+    var fieldOffset = _vTableFieldOffset(object, offset, field);
+    return fieldOffset == 0 ? defaultValue : read(object, offset + fieldOffset);
+  }
+
+  /// Read the value of the given [field] in the given [object].
+  @pragma('vm:prefer-inline')
+  T? vTableGetNullable(BufferContext object, int offset, int field) {
+    var fieldOffset = _vTableFieldOffset(object, offset, field);
+    return fieldOffset == 0 ? null : read(object, offset + fieldOffset);
+  }
+
+  @pragma('vm:prefer-inline')
+  int _vTableFieldOffset(BufferContext object, int offset, int field) {
+    var vTableSOffset = object._getInt32(offset);
+    var vTableOffset = offset - vTableSOffset;
+    var vTableSize = object._getUint16(vTableOffset);
+    if (field >= vTableSize) return 0;
+    return object._getUint16(vTableOffset + field);
   }
 }
 
 /// The reader of string values.
 class StringReader extends Reader<String> {
-  const StringReader() : super();
+  final bool asciiOptimization;
+
+  const StringReader({this.asciiOptimization = false}) : super();
 
   @override
-  int get size => 4;
+  @pragma('vm:prefer-inline')
+  int get size => _sizeofUint32;
 
   @override
+  @pragma('vm:prefer-inline')
   String read(BufferContext bc, int offset) {
-    int strOffset = bc.derefObject(offset);
-    int length = bc._getUint32(strOffset);
-    Uint8List bytes = bc._asUint8LIst(strOffset + 4, length);
-    if (_isLatin(bytes)) {
-      return new String.fromCharCodes(bytes);
+    var strOffset = bc.derefObject(offset);
+    var length = bc._getUint32(strOffset);
+    var bytes = bc._asUint8List(strOffset + _sizeofUint32, length);
+    if (asciiOptimization && _isLatin(bytes)) {
+      return String.fromCharCodes(bytes);
     }
     return utf8.decode(bytes);
   }
 
+  @pragma('vm:prefer-inline')
   static bool _isLatin(Uint8List bytes) {
-    int length = bytes.length;
-    for (int i = 0; i < length; i++) {
+    var length = bytes.length;
+    for (var i = 0; i < length; i++) {
       if (bytes[i] > 127) {
         return false;
       }
@@ -964,8 +1080,9 @@
   /// Return the object at `offset`.
   T createObject(BufferContext bc, int offset);
 
-  T read(BufferContext bp, int offset) {
-    return createObject(bp, offset);
+  @override
+  T read(BufferContext bc, int offset) {
+    return createObject(bc, offset);
   }
 }
 
@@ -974,15 +1091,16 @@
   const TableReader();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => 4;
 
   /// Return the object at [offset].
   T createObject(BufferContext bc, int offset);
 
   @override
-  T read(BufferContext bp, int offset) {
-    int objectOffset = bp.derefObject(offset);
-    return createObject(bp, objectOffset);
+  T read(BufferContext bc, int offset) {
+    var objectOffset = bc.derefObject(offset);
+    return createObject(bc, objectOffset);
   }
 }
 
@@ -993,11 +1111,13 @@
   const Uint32ListReader();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofUint32;
 
   @override
+  @pragma('vm:prefer-inline')
   List<int> read(BufferContext bc, int offset) =>
-      new _FbUint32List(bc, bc.derefObject(offset));
+      _FbUint32List(bc, bc.derefObject(offset));
 }
 
 /// The reader of unsigned 64-bit integers.
@@ -1007,9 +1127,11 @@
   const Uint64Reader() : super();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofUint64;
 
   @override
+  @pragma('vm:prefer-inline')
   int read(BufferContext bc, int offset) => bc._getUint64(offset);
 }
 
@@ -1018,9 +1140,11 @@
   const Uint32Reader() : super();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofUint32;
 
   @override
+  @pragma('vm:prefer-inline')
   int read(BufferContext bc, int offset) => bc._getUint32(offset);
 }
 
@@ -1031,11 +1155,13 @@
   const Uint16ListReader();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofUint32;
 
   @override
+  @pragma('vm:prefer-inline')
   List<int> read(BufferContext bc, int offset) =>
-      new _FbUint16List(bc, bc.derefObject(offset));
+      _FbUint16List(bc, bc.derefObject(offset));
 }
 
 /// The reader of unsigned 32-bit integers.
@@ -1043,24 +1169,44 @@
   const Uint16Reader() : super();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofUint16;
 
   @override
+  @pragma('vm:prefer-inline')
   int read(BufferContext bc, int offset) => bc._getUint16(offset);
 }
 
-/// Reader of lists of unsigned 8-bit integer values.
-///
-/// The returned unmodifiable lists lazily read values on access.
+/// Reader of unmodifiable binary data (a list of unsigned 8-bit integers).
 class Uint8ListReader extends Reader<List<int>> {
-  const Uint8ListReader();
+  /// Enables lazy reading of the list
+  ///
+  /// If true, the returned unmodifiable list lazily reads bytes on access.
+  /// Therefore, the underlying buffer must not change while accessing the list.
+  ///
+  /// If false, reads the whole list immediately as an Uint8List.
+  final bool lazy;
+
+  const Uint8ListReader({this.lazy = true});
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofUint32;
 
   @override
-  List<int> read(BufferContext bc, int offset) =>
-      new _FbUint8List(bc, bc.derefObject(offset));
+  @pragma('vm:prefer-inline')
+  List<int> read(BufferContext bc, int offset) {
+    final listOffset = bc.derefObject(offset);
+    if (lazy) return _FbUint8List(bc, listOffset);
+
+    final length = bc._getUint32(listOffset);
+    final result = Uint8List(length);
+    var pos = listOffset + _sizeofUint32;
+    for (var i = 0; i < length; i++, pos++) {
+      result[i] = bc._getUint8(pos);
+    }
+    return result;
+  }
 }
 
 /// The reader of unsigned 8-bit integers.
@@ -1068,20 +1214,53 @@
   const Uint8Reader() : super();
 
   @override
+  @pragma('vm:prefer-inline')
   int get size => _sizeofUint8;
 
   @override
+  @pragma('vm:prefer-inline')
   int read(BufferContext bc, int offset) => bc._getUint8(offset);
 }
 
+/// Reader of unmodifiable binary data (a list of signed 8-bit integers).
+class Int8ListReader extends Reader<List<int>> {
+  /// Enables lazy reading of the list
+  ///
+  /// If true, the returned unmodifiable list lazily reads bytes on access.
+  /// Therefore, the underlying buffer must not change while accessing the list.
+  ///
+  /// If false, reads the whole list immediately as an Uint8List.
+  final bool lazy;
+
+  const Int8ListReader({this.lazy = true});
+
+  @override
+  @pragma('vm:prefer-inline')
+  int get size => _sizeofUint32;
+
+  @override
+  @pragma('vm:prefer-inline')
+  List<int> read(BufferContext bc, int offset) {
+    final listOffset = bc.derefObject(offset);
+    if (lazy) return _FbUint8List(bc, listOffset);
+
+    final length = bc._getUint32(listOffset);
+    final result = Int8List(length);
+    var pos = listOffset + _sizeofUint32;
+    for (var i = 0; i < length; i++, pos++) {
+      result[i] = bc._getInt8(pos);
+    }
+    return result;
+  }
+}
+
 /// The list backed by 64-bit values - Uint64 length and Float64.
 class _FbFloat64List extends _FbList<double> {
   _FbFloat64List(BufferContext bc, int offset) : super(bc, offset);
 
   @override
-  double operator [](int i) {
-    return bc._getFloat64(offset + 4 + 8 * i);
-  }
+  @pragma('vm:prefer-inline')
+  double operator [](int i) => bc._getFloat64(offset + 4 + 8 * i);
 }
 
 /// The list backed by 32-bit values - Float32.
@@ -1089,29 +1268,29 @@
   _FbFloat32List(BufferContext bc, int offset) : super(bc, offset);
 
   @override
-  double operator [](int i) {
-    return bc._getFloat32(offset + 4 + 4 * i);
-  }
+  @pragma('vm:prefer-inline')
+  double operator [](int i) => bc._getFloat32(offset + 4 + 4 * i);
 }
 
 /// List backed by a generic object which may have any size.
 class _FbGenericList<E> extends _FbList<E> {
   final Reader<E> elementReader;
 
-  List<E> _items;
+  List<E?>? _items;
 
   _FbGenericList(this.elementReader, BufferContext bp, int offset)
       : super(bp, offset);
 
   @override
+  @pragma('vm:prefer-inline')
   E operator [](int i) {
-    _items ??= new List<E>(length);
-    E item = _items[i];
+    _items ??= List<E?>.filled(length, null);
+    var item = _items![i];
     if (item == null) {
       item = elementReader.read(bc, offset + 4 + elementReader.size * i);
-      _items[i] = item;
+      _items![i] = item;
     }
-    return item;
+    return item!;
   }
 }
 
@@ -1119,23 +1298,20 @@
 abstract class _FbList<E> extends Object with ListMixin<E> implements List<E> {
   final BufferContext bc;
   final int offset;
-  int _length;
+  int? _length;
 
   _FbList(this.bc, this.offset);
 
   @override
-  int get length {
-    _length ??= bc._getUint32(offset);
-    return _length;
-  }
+  @pragma('vm:prefer-inline')
+  int get length => _length ??= bc._getUint32(offset);
 
   @override
-  void set length(int i) =>
-      throw new StateError('Attempt to modify immutable list');
+  set length(int i) => throw StateError('Attempt to modify immutable list');
 
   @override
   void operator []=(int i, E e) =>
-      throw new StateError('Attempt to modify immutable list');
+      throw StateError('Attempt to modify immutable list');
 }
 
 /// List backed by 32-bit unsigned integers.
@@ -1143,9 +1319,8 @@
   _FbUint32List(BufferContext bc, int offset) : super(bc, offset);
 
   @override
-  int operator [](int i) {
-    return bc._getUint32(offset + 4 + 4 * i);
-  }
+  @pragma('vm:prefer-inline')
+  int operator [](int i) => bc._getUint32(offset + 4 + 4 * i);
 }
 
 /// List backed by 16-bit unsigned integers.
@@ -1153,9 +1328,8 @@
   _FbUint16List(BufferContext bc, int offset) : super(bc, offset);
 
   @override
-  int operator [](int i) {
-    return bc._getUint16(offset + 4 + 2 * i);
-  }
+  @pragma('vm:prefer-inline')
+  int operator [](int i) => bc._getUint16(offset + 4 + 2 * i);
 }
 
 /// List backed by 8-bit unsigned integers.
@@ -1163,9 +1337,17 @@
   _FbUint8List(BufferContext bc, int offset) : super(bc, offset);
 
   @override
-  int operator [](int i) {
-    return bc._getUint8(offset + 4 + i);
-  }
+  @pragma('vm:prefer-inline')
+  int operator [](int i) => bc._getUint8(offset + 4 + i);
+}
+
+/// List backed by 8-bit signed integers.
+class _FbInt8List extends _FbList<int> {
+  _FbInt8List(BufferContext bc, int offset) : super(bc, offset);
+
+  @override
+  @pragma('vm:prefer-inline')
+  int operator [](int i) => bc._getInt8(offset + 4 + i);
 }
 
 /// List backed by 8-bit unsigned integers.
@@ -1173,41 +1355,48 @@
   _FbBoolList(BufferContext bc, int offset) : super(bc, offset);
 
   @override
-  bool operator [](int i) {
-    return bc._getUint8(offset + 4 + i) == 1 ? true : false;
-  }
+  @pragma('vm:prefer-inline')
+  bool operator [](int i) => bc._getUint8(offset + 4 + i) == 1 ? true : false;
 }
 
 /// Class that describes the structure of a table.
 class _VTable {
   static const int _metadataLength = 4;
 
-  final List<int> fieldTails = <int>[];
-  final List<int> fieldOffsets = <int>[];
+  final int numFields;
+
+  // Note: fieldOffsets start as "tail offsets" and are then transformed by
+  // [computeFieldOffsets()] to actual offsets when a table is finished.
+  final Uint32List fieldOffsets;
+  bool offsetsComputed = false;
+
+  _VTable(this.numFields) : fieldOffsets = Uint32List(numFields);
 
   /// The size of the table that uses this VTable.
-  int tableSize;
+  int tableSize = 0;
 
-  /// The tail of this VTable.  It is used to share the same VTable between
+  /// The tail of this VTable. It is used to share the same VTable between
   /// multiple tables of identical structure.
-  int tail;
+  int tail = 0;
 
   int get _vTableSize => numOfUint16 * _sizeofUint16;
 
-  int get numOfUint16 => 1 + 1 + fieldTails.length;
+  int get numOfUint16 => 1 + 1 + numFields;
 
+  @pragma('vm:prefer-inline')
   void addField(int field, int offset) {
-    while (fieldTails.length <= field) {
-      fieldTails.add(null);
-    }
-    fieldTails[field] = offset;
+    assert(!offsetsComputed);
+    assert(offset > 0); // it's impossible for field to start at the buffer end
+    assert(offset <= 4294967295); // uint32 max
+    fieldOffsets[field] = offset;
   }
 
+  @pragma('vm:prefer-inline')
   bool _offsetsMatch(int vt2Start, ByteData buf) {
-    for (int i = 0; i < fieldOffsets.length; i++) {
+    assert(offsetsComputed);
+    for (var i = 0; i < numFields; i++) {
       if (fieldOffsets[i] !=
-          buf.getUint16(
-              vt2Start + _metadataLength + (2 * i), Endian.little)) {
+          buf.getUint16(vt2Start + _metadataLength + (2 * i), Endian.little)) {
         return false;
       }
     }
@@ -1215,17 +1404,22 @@
   }
 
   /// Fill the [fieldOffsets] field.
+  @pragma('vm:prefer-inline')
   void computeFieldOffsets(int tableTail) {
-    assert(fieldOffsets.isEmpty);
-    for (int fieldTail in fieldTails) {
-      int fieldOffset = fieldTail == null ? 0 : tableTail - fieldTail;
-      fieldOffsets.add(fieldOffset);
+    assert(!offsetsComputed);
+    offsetsComputed = true;
+    for (var i = 0; i < numFields; i++) {
+      if (fieldOffsets[i] != 0) {
+        fieldOffsets[i] = tableTail - fieldOffsets[i];
+      }
     }
   }
 
   /// Outputs this VTable to [buf], which is is expected to be aligned to 16-bit
   /// and have at least [numOfUint16] 16-bit words available.
+  @pragma('vm:prefer-inline')
   void output(ByteData buf, int bufOffset) {
+    assert(offsetsComputed);
     // VTable size.
     buf.setUint16(bufOffset, numOfUint16 * 2, Endian.little);
     bufOffset += 2;
@@ -1233,9 +1427,62 @@
     buf.setUint16(bufOffset, tableSize, Endian.little);
     bufOffset += 2;
     // Field offsets.
-    for (int fieldOffset in fieldOffsets) {
-      buf.setUint16(bufOffset, fieldOffset, Endian.little);
+    for (var i = 0; i < numFields; i++) {
+      buf.setUint16(bufOffset, fieldOffsets[i], Endian.little);
       bufOffset += 2;
     }
   }
 }
+
+/// The interface that [Builder] uses to allocate buffers for encoding.
+abstract class Allocator {
+  const Allocator();
+
+  /// Allocate a [ByteData] buffer of a given size.
+  ByteData allocate(int size);
+
+  /// Free the given [ByteData] buffer previously allocated by [allocate].
+  void deallocate(ByteData data);
+
+  /// Reallocate [newSize] bytes of memory, replacing the old [oldData]. This
+  /// grows downwards, and is intended specifically for use with [Builder].
+  /// Params [inUseBack] and [inUseFront] indicate how much of [oldData] is
+  /// actually in use at each end, and needs to be copied.
+  ByteData resize(
+      ByteData oldData, int newSize, int inUseBack, int inUseFront) {
+    final newData = allocate(newSize);
+    _copyDownward(oldData, newData, inUseBack, inUseFront);
+    deallocate(oldData);
+    return newData;
+  }
+
+  /// Called by [resize] to copy memory from [oldData] to [newData]. Only
+  /// memory of size [inUseFront] and [inUseBack] will be copied from the front
+  /// and back of the old memory allocation.
+  void _copyDownward(
+      ByteData oldData, ByteData newData, int inUseBack, int inUseFront) {
+    if (inUseBack != 0) {
+      newData.buffer.asUint8List().setAll(
+          newData.lengthInBytes - inUseBack,
+          oldData.buffer.asUint8List().getRange(
+              oldData.lengthInBytes - inUseBack, oldData.lengthInBytes));
+    }
+    if (inUseFront != 0) {
+      newData.buffer
+          .asUint8List()
+          .setAll(0, oldData.buffer.asUint8List().getRange(0, inUseFront));
+    }
+  }
+}
+
+class DefaultAllocator extends Allocator {
+  const DefaultAllocator();
+
+  @override
+  ByteData allocate(int size) => ByteData(size);
+
+  @override
+  void deallocate(ByteData data) {
+    // nothing to do, it's garbage-collected
+  }
+}