diff --git a/swift/Sources/FlatBuffers/FlatBufferBuilder.swift b/swift/Sources/FlatBuffers/FlatBufferBuilder.swift
index 71fcab0..5ccc7e4 100644
--- a/swift/Sources/FlatBuffers/FlatBufferBuilder.swift
+++ b/swift/Sources/FlatBuffers/FlatBufferBuilder.swift
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Google Inc. All rights reserved.
+ * Copyright 2021 Google Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,19 +16,30 @@
 
 import Foundation
 
+/// ``FlatBufferBuilder`` builds a `FlatBuffer` through manipulating its internal state.
+///
+/// This is done by creating a ``ByteBuffer`` that hosts the incoming data and
+/// has a hardcoded growth limit of `2GiB` which is set by the Flatbuffers standards.
+///
+/// ```swift
+/// var builder = FlatBufferBuilder()
+/// ```
+/// The builder should be always created as a variable, since it would be passed into the writers
+///
+@frozen
 public struct FlatBufferBuilder {
 
   /// Storage for the Vtables used in the buffer are stored in here, so they would be written later in EndTable
   @usableFromInline internal var _vtableStorage = VTableStorage()
+  /// Flatbuffer data will be written into
+  @usableFromInline internal var _bb: ByteBuffer
 
   /// Reference Vtables that were already written to the buffer
   private var _vtables: [UOffset] = []
-  /// Flatbuffer data will be written into
-  private var _bb: ByteBuffer
   /// A check if the buffer is being written into by a different table
   private var isNested = false
   /// Dictonary that stores a map of all the strings that were written to the buffer
-  private var stringOffsetMap: [String: Offset<String>] = [:]
+  private var stringOffsetMap: [String: Offset] = [:]
   /// A check to see if finish(::) was ever called to retreive data object
   private var finished = false
   /// A check to see if the buffer should serialize Default values
@@ -43,55 +54,76 @@
 
   /// Gives a read access to the buffer's size
   public var size: UOffset { _bb.size }
+
   /// Data representation of the buffer
+  ///
+  /// Should only be used after ``finish(offset:addPrefix:)`` is called
   public var data: Data {
     assert(finished, "Data shouldn't be called before finish()")
     return Data(
       bytes: _bb.memory.advanced(by: _bb.writerIndex),
       count: _bb.capacity &- _bb.writerIndex)
   }
-  /// Get's the fully sized buffer stored in memory
+
+  /// Returns the underlying bytes in the ``ByteBuffer``
+  ///
+  /// Note: This should be used with caution.
   public var fullSizedByteArray: [UInt8] {
     let ptr = UnsafeBufferPointer(
       start: _bb.memory.assumingMemoryBound(to: UInt8.self),
       count: _bb.capacity)
     return Array(ptr)
   }
-  /// Returns the written size of the buffer
+
+  /// Returns the written bytes into the ``ByteBuffer``
+  ///
+  /// Should only be used after ``finish(offset:addPrefix:)`` is called
   public var sizedByteArray: [UInt8] {
     assert(finished, "Data shouldn't be called before finish()")
-    let cp = _bb.capacity &- _bb.writerIndex
-    let start = _bb.memory.advanced(by: _bb.writerIndex)
-      .bindMemory(to: UInt8.self, capacity: cp)
-
-    let ptr = UnsafeBufferPointer(start: start, count: cp)
-    return Array(ptr)
+    return _bb.underlyingBytes
   }
-  /// Returns the buffer
+
+  /// Returns the original ``ByteBuffer``
+  ///
+  /// Returns the current buffer that was just created
+  /// with the offsets, and data written to it.
   public var buffer: ByteBuffer { _bb }
 
-  /// Returns A sized Buffer from the readable bytes
+  /// Returns a newly created sized ``ByteBuffer``
+  ///
+  /// returns a new buffer that is sized to the data written
+  /// to the main buffer
   public var sizedBuffer: ByteBuffer {
     assert(finished, "Data shouldn't be called before finish()")
-    return ByteBuffer(memory: _bb.memory.advanced(by: _bb.reader), count: Int(_bb.size))
+    return ByteBuffer(
+      memory: _bb.memory.advanced(by: _bb.reader),
+      count: Int(_bb.size))
   }
 
   // MARK: - Init
 
-  /// initialize the buffer with a size
+  /// Initialize the buffer with a size
   /// - Parameters:
   ///   - initialSize: Initial size for the buffer
   ///   - force: Allows default to be serialized into the buffer
-  public init(initialSize: Int32 = 1024, serializeDefaults force: Bool = false) {
+  ///
+  /// This initializes a new builder with an initialSize that would initialize
+  /// a new ``ByteBuffer``. ``FlatBufferBuilder`` by default doesnt serialize defaults
+  /// however the builder can be force by passing true for `serializeDefaults`
+  public init(
+    initialSize: Int32 = 1024,
+    serializeDefaults force: Bool = false)
+  {
     assert(initialSize > 0, "Size should be greater than zero!")
     guard isLitteEndian else {
-      fatalError("Reading/Writing a buffer in big endian machine is not supported on swift")
+      fatalError(
+        "Reading/Writing a buffer in big endian machine is not supported on swift")
     }
     serializeDefaults = force
     _bb = ByteBuffer(initialSize: Int(initialSize))
   }
 
-  /// Clears the buffer and the builder from it's data
+  /// Clears the builder and the buffer from the written data.
   mutating public func clear() {
     _minAlignment = 0
     isNested = false
@@ -107,11 +139,16 @@
   /// - Parameters:
   ///   - table: offset for the table
   ///   - fields: Array of all the important fields to be serialized
-  mutating public func require(table: Offset<UOffset>, fields: [Int32]) {
+  ///
+  /// *NOTE: Never call this function, this is only supposed to be called
+  /// by the generated code*
+  mutating public func require(table: Offset, fields: [Int32]) {
     for field in fields {
       let start = _bb.capacity &- Int(table.o)
       let startTable = start &- Int(_bb.read(def: Int32.self, position: start))
-      let isOkay = _bb.read(def: VOffset.self, position: startTable &+ Int(field)) != 0
+      let isOkay = _bb.read(
+        def: VOffset.self,
+        position: startTable &+ Int(field)) != 0
       assert(isOkay, "Flatbuffers requires the following field")
     }
   }
@@ -121,9 +158,32 @@
   ///   - offset: Offset of the table
   ///   - fileId: Takes the fileId
   ///   - prefix: if false it wont add the size of the buffer
-  mutating public func finish<T>(offset: Offset<T>, fileId: String, addPrefix prefix: Bool = false) {
+  ///
+  /// ``finish(offset:fileId:addPrefix:)`` should be called at the end of creating
+  /// a table
+  /// ```swift
+  /// var root = SomeObject
+  ///   .createObject(&builder,
+  ///   name: nameOffset)
+  /// builder.finish(
+  ///   offset: root,
+  ///   fileId: "ax1a",
+  ///   addPrefix: true)
+  /// ```
+  /// File id would append a file id name at the end of the written bytes before,
+  /// finishing the buffer.
+  ///
+  /// Whereas, if `addPrefix` is true, the written bytes would
+  /// include the size of the current buffer.
+  mutating public func finish(
+    offset: Offset,
+    fileId: String,
+    addPrefix prefix: Bool = false)
+  {
     let size = MemoryLayout<UOffset>.size
-    preAlign(len: size &+ (prefix ? size : 0) &+ FileIdLength, alignment: _minAlignment)
+    preAlign(
+      len: size &+ (prefix ? size : 0) &+ FileIdLength,
+      alignment: _minAlignment)
     assert(fileId.count == FileIdLength, "Flatbuffers requires file id to be 4")
     _bb.push(string: fileId, len: 4)
     finish(offset: offset, addPrefix: prefix)
@@ -133,7 +193,23 @@
   /// - Parameters:
   ///   - offset: Offset of the table
   ///   - prefix: if false it wont add the size of the buffer
-  mutating public func finish<T>(offset: Offset<T>, addPrefix prefix: Bool = false) {
+  ///
+  /// ``finish(offset:addPrefix:)`` should be called at the end of creating
+  /// a table
+  /// ```swift
+  /// var root = SomeObject
+  ///   .createObject(&builder,
+  ///   name: nameOffset)
+  /// builder.finish(
+  ///   offset: root,
+  ///   addPrefix: true)
+  /// ```
+  /// If `addPrefix` is true, the written bytes would
+  /// include the size of the current buffer.
+  mutating public func finish(
+    offset: Offset,
+    addPrefix prefix: Bool = false)
+  {
     notNested()
     let size = MemoryLayout<UOffset>.size
     preAlign(len: size &+ (prefix ? size : 0), alignment: _minAlignment)
@@ -143,10 +219,15 @@
     finished = true
   }
 
-  /// starttable will let the builder know, that a new object is being serialized.
+  /// ``startTable(with:)`` will let the builder know, that a new object is being serialized.
   ///
-  /// The function will fatalerror if called while there is another object being serialized
+  /// The function will fatalerror if called while there is another object being serialized.
+  /// ```swift
+  /// let start = Monster
+  ///   .startMonster(&fbb)
+  /// ```
   /// - Parameter numOfFields: Number of elements to be written to the buffer
+  /// - Returns: Offset of the newly started table
   mutating public func startTable(with numOfFields: Int) -> UOffset {
     notNested()
     isNested = true
@@ -154,11 +235,14 @@
     return _bb.size
   }
 
-  /// Endtable will let the builder know that the object that's written to it is completed
+  /// ``endTable(at:)`` will let the ``FlatBufferBuilder`` know that the
+  /// object that's written to it is completed
   ///
-  /// This would be called after all the elements are serialized, it will add the vtable into the buffer.
-  /// it will fatalError in case the object is called without starttable, or the object has exceeded  the limit of
-  ///  2GB,
+  /// This would be called after all the elements are serialized,
+  /// it will add the current vtable into the ``ByteBuffer``.
+  /// The functions will `fatalError` in case the object is called
+  /// without ``startTable(with:)``, or the object has exceeded  the limit of 2GB.
+  ///
   /// - Parameter startOffset:Start point of the object written
   /// - returns: The root of the table
   mutating public func endTable(at startOffset: UOffset)  -> UOffset {
@@ -183,7 +267,10 @@
       itr = itr &+ _vtableStorage.size
       guard loaded.offset != 0 else { continue }
       let _index = (_bb.writerIndex &+ Int(loaded.position))
-      _bb.write(value: VOffset(vTableOffset &- loaded.offset), index: _index, direct: true)
+      _bb.write(
+        value: VOffset(vTableOffset &- loaded.offset),
+        index: _index,
+        direct: true)
     }
 
     _vtableStorage.clear()
@@ -219,7 +306,7 @@
 
   // MARK: - Builds Buffer
 
-  /// asserts to see if the object is not nested
+  /// Asserts to see if the object is not nested
   @usableFromInline
   mutating internal func notNested()  {
     assert(!isNested, "Object serialization must not be nested")
@@ -227,7 +314,7 @@
 
   /// Changes the minimuim alignment of the buffer
   /// - Parameter size: size of the current alignment
-  @usableFromInline
+  @inline(__always)
   mutating internal func minAlignment(size: Int) {
     if size > _minAlignment {
       _minAlignment = size
@@ -238,8 +325,11 @@
   /// - Parameters:
   ///   - bufSize: Current size of the buffer + the offset of the object to be written
   ///   - elementSize: Element size
-  @usableFromInline
-  mutating internal func padding(bufSize: UInt32, elementSize: UInt32) -> UInt32 {
+  @inline(__always)
+  mutating internal func padding(
+    bufSize: UInt32,
+    elementSize: UInt32) -> UInt32
+  {
     ((~bufSize) &+ 1) & (elementSize - 1)
   }
 
@@ -282,9 +372,20 @@
     _vtableStorage.add(loc: FieldLoc(offset: offset, position: position))
   }
 
-  // MARK: - Vectors
+  // MARK: - Inserting Vectors
 
-  /// Starts a vector of length and Element size
+  /// ``startVector(_:elementSize:)`` creates a new vector within buffer
+  ///
+  /// The function checks if there is a current object being written, if
+  /// the check passes it creates a buffer alignment of `length * elementSize`
+  /// ```swift
+  /// builder.startVector(
+  ///   int32Values.count, elementSize: 4)
+  /// ```
+  ///
+  /// - Parameters:
+  ///   - len: Length of vector to be created
+  ///   - elementSize: Size of object type to be written
   mutating public func startVector(_ len: Int, elementSize: Int) {
     notNested()
     isNested = true
@@ -292,185 +393,268 @@
     preAlign(len: len &* elementSize, alignment: elementSize)
   }
 
-  /// Ends the vector of at length
+  /// ``endVector(len:)`` ends the currently created vector
   ///
-  /// The current function will fatalError if startVector is called before serializing the vector
+  /// Calling ``endVector(len:)`` requires the length, of the current
+  /// vector. The length would be pushed to indicate the count of numbers
+  /// within the vector. If ``endVector(len:)`` is called without
+  /// ``startVector(_:elementSize:)`` it asserts.
+  ///
+  /// ```swift
+  /// let vectorOffset = builder.
+  ///   endVector(len: int32Values.count)
+  /// ```
+  ///
   /// - Parameter len: Length of the buffer
-  mutating public func endVector(len: Int) -> UOffset {
+  /// - Returns: Returns the current ``Offset`` in the ``ByteBuffer``
+  mutating public func endVector(len: Int) -> Offset {
     assert(isNested, "Calling endVector without calling startVector")
     isNested = false
-    return push(element: Int32(len))
+    return Offset(offset: push(element: Int32(len)))
   }
 
-  /// Creates a vector of type Scalar in the buffer
+  /// Creates a vector of type ``Scalar`` into the ``ByteBuffer``
+  ///
+  /// ``createVector(_:)-4swl0`` writes a vector of type Scalars into
+  /// ``ByteBuffer``. This is a convenient method instead of calling,
+  /// ``startVector(_:elementSize:)`` and then ``endVector(len:)``
+  /// ```swift
+  /// let vectorOffset = builder.
+  ///   createVector([1, 2, 3, 4])
+  /// ```
+  ///
+  /// The underlying implementation simply calls ``createVector(_:size:)-4lhrv``
+  ///
   /// - Parameter elements: elements to be written into the buffer
-  /// - returns: Offset of the vector
-  mutating public func createVector<T: Scalar>(_ elements: [T]) -> Offset<UOffset> {
+  /// - returns: ``Offset`` of the vector
+  mutating public func createVector<T: Scalar>(_ elements: [T]) -> Offset {
     createVector(elements, size: elements.count)
   }
 
   ///  Creates a vector of type Scalar in the buffer
+  ///
+  /// ``createVector(_:)-4swl0`` writes a vector of type Scalars into
+  /// ``ByteBuffer``. This is a convenient method instead of calling,
+  /// ``startVector(_:elementSize:)`` and then ``endVector(len:)``
+  /// ```swift
+  /// let vectorOffset = builder.
+  ///   createVector([1, 2, 3, 4], size: 4)
+  /// ```
+  ///
   /// - Parameter elements: Elements to be written into the buffer
   /// - Parameter size: Count of elements
-  /// - returns: Offset of the vector
-  mutating public func createVector<T: Scalar>(_ elements: [T], size: Int) -> Offset<UOffset> {
+  /// - returns: ``Offset`` of the vector
+  mutating public func createVector<T: Scalar>(
+    _ elements: [T],
+    size: Int) -> Offset
+  {
     let size = size
     startVector(size, elementSize: MemoryLayout<T>.size)
     _bb.push(elements: elements)
-    return Offset(offset: endVector(len: size))
+    return endVector(len: size)
   }
 
-  /// Creates a vector of type Enums in the buffer
+  /// Creates a vector of type ``Enum`` into the ``ByteBuffer``
+  ///
+  /// ``createVector(_:)-9h189`` writes a vector of type ``Enum`` into
+  /// ``ByteBuffer``. This is a convenient method instead of calling,
+  /// ``startVector(_:elementSize:)`` and then ``endVector(len:)``
+  /// ```swift
+  /// let vectorOffset = builder.
+  ///   createVector([.swift, .cpp])
+  /// ```
+  ///
+  /// The underlying implementation simply calls ``createVector(_:size:)-7cx6z``
+  ///
   /// - Parameter elements: elements to be written into the buffer
-  /// - returns: Offset of the vector
-  mutating public func createVector<T: Enum>(_ elements: [T]) -> Offset<UOffset> {
+  /// - returns: ``Offset`` of the vector
+  mutating public func createVector<T: Enum>(_ elements: [T]) -> Offset {
     createVector(elements, size: elements.count)
   }
 
-  ///  Creates a vector of type Enums in the buffer
+  /// Creates a vector of type ``Enum`` into the ``ByteBuffer``
+  ///
+  /// ``createVector(_:)-9h189`` writes a vector of type ``Enum`` into
+  /// ``ByteBuffer``. This is a convenient method instead of calling,
+  /// ``startVector(_:elementSize:)`` and then ``endVector(len:)``
+  /// ```swift
+  /// let vectorOffset = builder.
+  ///   createVector([.swift, .cpp])
+  /// ```
+  ///
   /// - Parameter elements: Elements to be written into the buffer
   /// - Parameter size: Count of elements
-  /// - returns: Offset of the vector
-  mutating public func createVector<T: Enum>(_ elements: [T], size: Int) -> Offset<UOffset> {
+  /// - returns: ``Offset`` of the vector
+  mutating public func createVector<T: Enum>(
+    _ elements: [T],
+    size: Int) -> Offset
+  {
     let size = size
     startVector(size, elementSize: T.byteSize)
     for e in elements.reversed() {
       _bb.push(value: e.value, len: T.byteSize)
     }
-    return Offset(offset: endVector(len: size))
+    return endVector(len: size)
   }
 
-  /// Creates a vector of type Offsets  in the buffer
-  /// - Parameter offsets:Array of offsets of type T
-  /// - returns: Offset of the vector
-  mutating public func createVector<T>(ofOffsets offsets: [Offset<T>]) -> Offset<UOffset> {
+  /// Creates a vector of already written offsets
+  ///
+  /// ``createVector(ofOffsets:)`` creates a vector of ``Offset`` into
+  /// ``ByteBuffer``. This is a convenient method instead of calling,
+  /// ``startVector(_:elementSize:)`` and then ``endVector(len:)``.
+  ///
+  /// The underlying implementation simply calls ``createVector(ofOffsets:len:)``
+  ///
+  /// ```swift
+  /// let namesOffsets = builder.
+  ///   createVector(ofOffsets: [name1, name2])
+  /// ```
+  /// - Parameter offsets: Array of offsets of type ``Offset``
+  /// - returns: ``Offset`` of the vector
+  mutating public func createVector(ofOffsets offsets: [Offset]) -> Offset {
     createVector(ofOffsets: offsets, len: offsets.count)
   }
 
-  ///  Creates a vector of type Offsets  in the buffer
-  /// - Parameter elements: Array of offsets of type T
+  /// Creates a vector of already written offsets
+  ///
+  /// ``createVector(ofOffsets:)`` creates a vector of ``Offset`` into
+  /// ``ByteBuffer``. This is a convenient method instead of calling,
+  /// ``startVector(_:elementSize:)`` and then ``endVector(len:)``
+  ///
+  /// ```swift
+  /// let namesOffsets = builder.
+  ///   createVector(ofOffsets: [name1, name2])
+  /// ```
+  ///
+  /// - Parameter offsets: Array of offsets of type ``Offset``
   /// - Parameter size: Count of elements
-  /// - returns: Offset of the vector
-  mutating public func createVector<T>(ofOffsets offsets: [Offset<T>], len: Int) -> Offset<UOffset> {
-    startVector(len, elementSize: MemoryLayout<Offset<T>>.size)
+  /// - returns: ``Offset`` of the vector
+  mutating public func createVector(
+    ofOffsets offsets: [Offset],
+    len: Int) -> Offset
+  {
+    startVector(len, elementSize: MemoryLayout<Offset>.size)
     for o in offsets.reversed() {
       push(element: o)
     }
-    return Offset(offset: endVector(len: len))
+    return endVector(len: len)
   }
 
-  /// Creates a vector of Strings
-  /// - Parameter str: a vector of strings that will be written into the buffer
-  /// - returns: Offset of the vector
-  mutating public func createVector(ofStrings str: [String]) -> Offset<UOffset> {
-    var offsets: [Offset<String>] = []
+  /// Creates a vector of strings
+  ///
+  /// ``createVector(ofStrings:)`` creates a vector of `String` into
+  /// ``ByteBuffer``. This is a convenient method instead of manually
+  /// creating the string offsets, you simply pass it to this function
+  /// and it would write the strings into the ``ByteBuffer``.
+  /// After that it calls ``createVector(ofOffsets:)``
+  ///
+  /// ```swift
+  /// let namesOffsets = builder.
+  ///   createVector(ofStrings: ["Name", "surname"])
+  /// ```
+  ///
+  /// - Parameter str: Array of string
+  /// - returns: ``Offset`` of the vector
+  mutating public func createVector(ofStrings str: [String]) -> Offset {
+    var offsets: [Offset] = []
     for s in str {
       offsets.append(create(string: s))
     }
     return createVector(ofOffsets: offsets)
   }
 
-  /// Creates a vector of Flatbuffer structs.
+  /// Creates a vector of type ``NativeStruct``.
   ///
-  /// The function takes a Type to know what size it is, and alignment
-  /// - Parameters:
-  ///   - structs: An array of UnsafeMutableRawPointer
-  ///   - type: Type of the struct being written
-  /// - returns: Offset of the vector
-  @available(
-    *,
-    deprecated,
-    message: "0.9.0 will be removing the following method. Regenerate the code")
-  mutating public func createVector<T: Readable>(
-    structs: [UnsafeMutableRawPointer],
-    type: T.Type) -> Offset<UOffset>
+  /// Any swift struct in the generated code, should confirm to
+  /// ``NativeStruct``. Since the generated swift structs are padded
+  /// to the `FlatBuffers` standards.
+  ///
+  /// ```swift
+  /// let offsets = builder.
+  ///   createVector(ofStructs: [NativeStr(num: 1), NativeStr(num: 2)])
+  /// ```
+  ///
+  /// - Parameter structs: A vector of ``NativeStruct``
+  /// - Returns: ``Offset`` of the vector
+  mutating public func createVector<T: NativeStruct>(ofStructs structs: [T])
+    -> Offset
   {
-    startVector(structs.count &* T.size, elementSize: T.alignment)
+    startVector(
+      structs.count * MemoryLayout<T>.size,
+      elementSize: MemoryLayout<T>.alignment)
     for i in structs.reversed() {
-      create(struct: i, type: T.self)
+      _ = create(struct: i)
     }
-    return Offset(offset: endVector(len: structs.count))
-  }
-
-  /// Starts a vector of struct that considers the size and alignment of the struct
-  /// - Parameters:
-  ///   - count: number of elements to be written
-  ///   - size: size of struct
-  ///   - alignment: alignment of the struct
-  mutating public func startVectorOfStructs(count: Int, size: Int, alignment: Int) {
-    startVector(count &* size, elementSize: alignment)
-  }
-
-  /// Ends the vector of structs and writtens the current offset
-  /// - Parameter count: number of written elements
-  /// - Returns: Offset of type UOffset
-  mutating public func endVectorOfStructs(count: Int) -> Offset<UOffset> {
-    Offset<UOffset>(offset: endVector(len: count))
+    return endVector(len: structs.count)
   }
 
   // MARK: - Inserting Structs
 
-  /// Writes a Flatbuffer struct into the buffer
+  /// Writes a ``NativeStruct`` into the ``ByteBuffer``
+  ///
+  /// Adds a native struct that's build and padded according
+  /// to `FlatBuffers` standards. with a predefined position.
+  ///
+  /// ```swift
+  /// let offset = builder.create(
+  ///   struct: NativeStr(num: 1),
+  ///   position: 10)
+  /// ```
+  ///
   /// - Parameters:
-  ///   - s: Flatbuffer struct
-  ///   - type: Type of the element to be serialized
-  /// - returns: Offset of the Object
-  @available(
-    *,
-    deprecated,
-    message: "0.9.0 will be removing the following method. Regenerate the code")
+  ///   - s: ``NativeStruct`` to be inserted into the ``ByteBuffer``
+  ///   - position: The  predefined position of the object
+  /// - Returns: ``Offset`` of written struct
   @discardableResult
-  mutating public func create<T: Readable>(
-    struct s: UnsafeMutableRawPointer,
-    type: T.Type) -> Offset<UOffset>
+  mutating public func create<T: NativeStruct>(
+    struct s: T, position: VOffset) -> Offset
   {
-    let size = T.size
-    preAlign(len: size, alignment: T.alignment)
+    let offset = create(struct: s)
+    _vtableStorage.add(loc: FieldLoc(
+      offset: _bb.size,
+      position: VOffset(position)))
+    return offset
+  }
+
+  /// Writes a ``NativeStruct`` into the ``ByteBuffer``
+  ///
+  /// Adds a native struct that's build and padded according
+  /// to `FlatBuffers` standards, directly into the buffer without
+  /// a predefined position.
+  ///
+  /// ```swift
+  /// let offset = builder.create(
+  ///   struct: NativeStr(num: 1))
+  /// ```
+  ///
+  /// - Parameters:
+  ///   - s: ``NativeStruct`` to be inserted into the ``ByteBuffer``
+  /// - Returns: ``Offset`` of written struct
+  @discardableResult
+  mutating public func create<T: NativeStruct>(
+    struct s: T) -> Offset
+  {
+    let size = MemoryLayout<T>.size
+    preAlign(len: size, alignment: MemoryLayout<T>.alignment)
     _bb.push(struct: s, size: size)
     return Offset(offset: _bb.size)
   }
 
-  /// prepares the ByteBuffer to receive a struct of size and alignment
-  /// - Parameters:
-  ///   - size: size of written struct
-  ///   - alignment: alignment of written struct
-  mutating public func createStructOf(size: Int, alignment: Int) {
-    preAlign(len: size, alignment: alignment)
-    _bb.prepareBufferToReceiveStruct(of: size)
-  }
-
-  /// Adds scalars front to back instead of the default behavior of the normal add
-  /// - Parameters:
-  ///   - v: element of type Scalar
-  ///   - postion: position relative to the `writerIndex`
-  mutating public func reverseAdd<T: Scalar>(v: T, postion: Int) {
-    _bb.reversePush(
-      value: v,
-      position: postion,
-      len: MemoryLayout<T>.size)
-  }
-
-  /// Ends the struct and returns the current buffer size
-  /// - Returns: Offset of type UOffset
-  @discardableResult
-  public func endStruct() -> Offset<UOffset> {
-    Offset(offset: _bb.size)
-  }
-
-  /// Adds the offset of a struct into the vTable
-  ///
-  /// The function fatalErrors if we pass an offset that is out of range
-  /// - Parameter o: offset
-  mutating public func add(structOffset o: VOffset) {
-    _vtableStorage.add(loc: FieldLoc(offset: _bb.size, position: VOffset(o)))
-  }
-
   // MARK: - Inserting Strings
 
-  /// Insets a string into the buffer using UTF8
+  /// Insets a string into the buffer of type `UTF8`
+  ///
+  /// Adds a swift string into ``ByteBuffer`` by encoding it
+  /// using `UTF8`
+  ///
+  /// ```swift
+  /// let nameOffset = builder
+  ///   .create(string: "welcome")
+  /// ```
+  ///
   /// - Parameter str: String to be serialized
-  /// - returns: The strings offset in the buffer
-  mutating public func create(string str: String?) -> Offset<String> {
+  /// - returns: ``Offset`` of inserted string
+  mutating public func create(string str: String?) -> Offset {
     guard let str = str else { return Offset() }
     let len = str.utf8.count
     notNested()
@@ -481,12 +665,26 @@
     return Offset(offset: _bb.size)
   }
 
-  /// Inserts a shared string to the buffer
+  /// Insets a shared string into the buffer of type `UTF8`
   ///
-  /// The function checks the stringOffsetmap if it's seen a similar string before
+  /// Adds a swift string into ``ByteBuffer`` by encoding it
+  /// using `UTF8`. The function will check if the string,
+  /// is already written to the ``ByteBuffer``
+  ///
+  /// ```swift
+  /// let nameOffset = builder
+  ///   .createShared(string: "welcome")
+  ///
+  ///
+  /// let secondOffset = builder
+  ///   .createShared(string: "welcome")
+  ///
+  /// assert(nameOffset.o == secondOffset.o)
+  /// ```
+  ///
   /// - Parameter str: String to be serialized
-  /// - returns: The strings offset in the buffer
-  mutating public func createShared(string str: String?) -> Offset<String> {
+  /// - returns: ``Offset`` of inserted string
+  mutating public func createShared(string str: String?) -> Offset {
     guard let str = str else { return Offset() }
     if let offset = stringOffsetMap[str] {
       return offset
@@ -498,37 +696,65 @@
 
   // MARK: - Inseting offsets
 
-  /// Adds the offset of an object into the buffer
+  /// Writes the ``Offset`` of an already written table
+  ///
+  /// Writes the ``Offset`` of a table if not empty into the
+  /// ``ByteBuffer``
+  ///
   /// - Parameters:
-  ///   - offset: Offset of another object to be written
-  ///   - position: The  predefined position of the object
-  mutating public func add<T>(offset: Offset<T>, at position: VOffset) {
+  ///   - offset: ``Offset`` of another object to be written
+  ///   - position: The predefined position of the object
+  mutating public func add(offset: Offset, at position: VOffset) {
     if offset.isEmpty { return }
     add(element: refer(to: offset.o), def: 0, at: position)
   }
 
-  /// Pushes a value of type offset into the buffer
-  /// - Parameter o: Offset
-  /// - returns: Position of the offset
+  /// Pushes a value of type ``Offset`` into the ``ByteBuffer``
+  /// - Parameter o: ``Offset``
+  /// - returns: Current position of the ``Offset``
   @discardableResult
-  mutating public func push<T>(element o: Offset<T>) -> UOffset {
+  mutating public func push(element o: Offset) -> UOffset {
     push(element: refer(to: o.o))
   }
 
   // MARK: - Inserting Scalars to Buffer
 
-  /// Adds a value into the buffer of type Scalar
+  /// Writes a ``Scalar`` value into ``ByteBuffer``
+  ///
+  /// ``add(element:def:at:)`` takes in a default value, and current value
+  /// and the position within the `VTable`. The default value would not
+  /// be serialized if the value is the same as the current value or
+  /// `serializeDefaults` is equal to false.
+  ///
+  /// If serializing defaults is important ``init(initialSize:serializeDefaults:)``,
+  /// passing true for `serializeDefaults` would do the job.
+  ///
+  /// ```swift
+  /// // Adds 10 to the buffer
+  /// builder.add(element: Int(10), def: 1, position 12)
+  /// ```
+  ///
+  /// *NOTE: Never call this manually*
   ///
   /// - Parameters:
   ///   - element: Element to insert
   ///   - def: Default value for that element
   ///   - position: The predefined position of the element
-  mutating public func add<T: Scalar>(element: T, def: T, at position: VOffset) {
+  mutating public func add<T: Scalar>(
+    element: T,
+    def: T,
+    at position: VOffset)
+  {
     if element == def && !serializeDefaults { return }
     track(offset: push(element: element), at: position)
   }
 
-  /// Adds a value into the buffer of type optional Scalar
+  /// Writes a optional ``Scalar`` value into ``ByteBuffer``
+  ///
+  /// Takes an optional value to be written into the ``ByteBuffer``
+  ///
+  /// *NOTE: Never call this manually*
+  ///
   /// - Parameters:
   ///   - element: Optional element of type scalar
   ///   - position: The predefined position of the element
@@ -537,7 +763,10 @@
     track(offset: push(element: element), at: position)
   }
 
-  /// Pushes the values into the buffer
+  /// Pushes a values of type ``Scalar`` into the ``ByteBuffer``
+  ///
+  /// *NOTE: Never call this manually*
+  ///
   /// - Parameter element: Element to insert
   /// - returns: Postion of the Element
   @discardableResult
@@ -582,12 +811,13 @@
     var numOfFields: Int = 0
     /// Last written Index
     var writtenIndex: Int = 0
-    /// the amount of added elements into the buffer
-    var addedElements: Int { capacity - (numOfFields &* size) }
 
     /// Creates the memory to store the buffer in
+    @usableFromInline
     init() {
-      memory = UnsafeMutableRawBufferPointer.allocate(byteCount: 0, alignment: 0)
+      memory = UnsafeMutableRawBufferPointer.allocate(
+        byteCount: 0,
+        alignment: 0)
     }
 
     deinit {
@@ -596,6 +826,7 @@
 
     /// Builds a buffer with byte count of fieldloc.size * count of field numbers
     /// - Parameter count: number of fields to be written
+    @inline(__always)
     func start(count: Int) {
       assert(count >= 0, "number of fields should NOT be negative")
       let capacity = count &* size
@@ -606,7 +837,9 @@
     /// and max offset
     /// - Parameter loc: Location of encoded element
     func add(loc: FieldLoc) {
-      memory.baseAddress?.advanced(by: writtenIndex).storeBytes(of: loc, as: FieldLoc.self)
+      memory.baseAddress?.advanced(by: writtenIndex).storeBytes(
+        of: loc,
+        as: FieldLoc.self)
       writtenIndex = writtenIndex &+ size
       numOfFields = numOfFields &+ 1
       maxOffset = max(loc.position, maxOffset)
@@ -621,16 +854,20 @@
 
     /// Ensure that the buffer has enough space instead of recreating the buffer each time.
     /// - Parameter space: space required for the new vtable
+    @inline(__always)
     func ensure(space: Int) {
       guard space &+ writtenIndex > capacity else { return }
       memory.deallocate()
-      memory = UnsafeMutableRawBufferPointer.allocate(byteCount: space, alignment: size)
+      memory = UnsafeMutableRawBufferPointer.allocate(
+        byteCount: space,
+        alignment: size)
       capacity = space
     }
 
     /// Loads an object of type `FieldLoc` from buffer memory
     /// - Parameter index: index of element
     /// - Returns: a FieldLoc at index
+    @inline(__always)
     func load(at index: Int) -> FieldLoc {
       memory.load(fromByteOffset: index, as: FieldLoc.self)
     }