diff --git a/modules/mono/editor/bindings_generator.cpp b/modules/mono/editor/bindings_generator.cpp
index f67e3effe86..392814b4e67 100644
--- a/modules/mono/editor/bindings_generator.cpp
+++ b/modules/mono/editor/bindings_generator.cpp
@@ -376,7 +376,7 @@ String BindingsGenerator::bbcode_to_xml(const String &p_bbcode, const TypeInterf
 					xml_output.append(link_target);
 					xml_output.append("</c>");
 				}
-			} else if (link_tag == "const") {
+			} else if (link_tag == "constant") {
 				if (!target_itype || !target_itype->is_object_type) {
 					if (OS::get_singleton()->is_stdout_verbose()) {
 						if (target_itype) {
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/AABB.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/AABB.cs
index 4c3d4e2cca9..fd056a06ebc 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/AABB.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/AABB.cs
@@ -20,7 +20,7 @@ namespace Godot
         private Vector3 _size;
 
         /// <summary>
-        /// Beginning corner. Typically has values lower than End.
+        /// Beginning corner. Typically has values lower than <see cref="End"/>.
         /// </summary>
         /// <value>Directly uses a private field.</value>
         public Vector3 Position
@@ -30,7 +30,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Size from Position to End. Typically all components are positive.
+        /// Size from <see cref="Position"/> to <see cref="End"/>. Typically all components are positive.
         /// If the size is negative, you can use <see cref="Abs"/> to fix it.
         /// </summary>
         /// <value>Directly uses a private field.</value>
@@ -44,7 +44,10 @@ namespace Godot
         /// Ending corner. This is calculated as <see cref="Position"/> plus
         /// <see cref="Size"/>. Setting this value will change the size.
         /// </summary>
-        /// <value>Getting is equivalent to `value = Position + Size`, setting is equivalent to `Size = value - Position`.</value>
+        /// <value>
+        /// Getting is equivalent to <paramref name="value"/> = <see cref="Position"/> + <see cref="Size"/>,
+        /// setting is equivalent to <see cref="Size"/> = <paramref name="value"/> - <see cref="Position"/>
+        /// </value>
         public Vector3 End
         {
             get { return _position + _size; }
@@ -52,10 +55,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns an AABB with equivalent position and size, modified so that
+        /// Returns an <see cref="AABB"/> with equivalent position and size, modified so that
         /// the most-negative corner is the origin and the size is positive.
         /// </summary>
-        /// <returns>The modified AABB.</returns>
+        /// <returns>The modified <see cref="AABB"/>.</returns>
         public AABB Abs()
         {
             Vector3 end = End;
@@ -64,10 +67,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if this AABB completely encloses another one.
+        /// Returns <see langword="true"/> if this <see cref="AABB"/> completely encloses another one.
         /// </summary>
-        /// <param name="with">The other AABB that may be enclosed.</param>
-        /// <returns>A bool for whether or not this AABB encloses `b`.</returns>
+        /// <param name="with">The other <see cref="AABB"/> that may be enclosed.</param>
+        /// <returns>
+        /// A <see langword="bool"/> for whether or not this <see cref="AABB"/> encloses <paramref name="with"/>.
+        /// </returns>
         public bool Encloses(AABB with)
         {
             Vector3 src_min = _position;
@@ -84,10 +89,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns this AABB expanded to include a given point.
+        /// Returns this <see cref="AABB"/> expanded to include a given point.
         /// </summary>
         /// <param name="point">The point to include.</param>
-        /// <returns>The expanded AABB.</returns>
+        /// <returns>The expanded <see cref="AABB"/>.</returns>
         public AABB Expand(Vector3 point)
         {
             Vector3 begin = _position;
@@ -123,7 +128,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the area of the AABB.
+        /// Returns the area of the <see cref="AABB"/>.
         /// </summary>
         /// <returns>The area.</returns>
         public real_t GetArea()
@@ -132,10 +137,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Gets the position of one of the 8 endpoints of the AABB.
+        /// Gets the position of one of the 8 endpoints of the <see cref="AABB"/>.
         /// </summary>
         /// <param name="idx">Which endpoint to get.</param>
-        /// <returns>An endpoint of the AABB.</returns>
+        /// <returns>An endpoint of the <see cref="AABB"/>.</returns>
         public Vector3 GetEndpoint(int idx)
         {
             switch (idx)
@@ -162,9 +167,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the normalized longest axis of the AABB.
+        /// Returns the normalized longest axis of the <see cref="AABB"/>.
         /// </summary>
-        /// <returns>A vector representing the normalized longest axis of the AABB.</returns>
+        /// <returns>A vector representing the normalized longest axis of the <see cref="AABB"/>.</returns>
         public Vector3 GetLongestAxis()
         {
             var axis = new Vector3(1f, 0f, 0f);
@@ -185,7 +190,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the <see cref="Vector3.Axis"/> index of the longest axis of the AABB.
+        /// Returns the <see cref="Vector3.Axis"/> index of the longest axis of the <see cref="AABB"/>.
         /// </summary>
         /// <returns>A <see cref="Vector3.Axis"/> index for which axis is longest.</returns>
         public Vector3.Axis GetLongestAxisIndex()
@@ -208,9 +213,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the scalar length of the longest axis of the AABB.
+        /// Returns the scalar length of the longest axis of the <see cref="AABB"/>.
         /// </summary>
-        /// <returns>The scalar length of the longest axis of the AABB.</returns>
+        /// <returns>The scalar length of the longest axis of the <see cref="AABB"/>.</returns>
         public real_t GetLongestAxisSize()
         {
             real_t max_size = _size.x;
@@ -225,9 +230,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the normalized shortest axis of the AABB.
+        /// Returns the normalized shortest axis of the <see cref="AABB"/>.
         /// </summary>
-        /// <returns>A vector representing the normalized shortest axis of the AABB.</returns>
+        /// <returns>A vector representing the normalized shortest axis of the <see cref="AABB"/>.</returns>
         public Vector3 GetShortestAxis()
         {
             var axis = new Vector3(1f, 0f, 0f);
@@ -248,7 +253,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the <see cref="Vector3.Axis"/> index of the shortest axis of the AABB.
+        /// Returns the <see cref="Vector3.Axis"/> index of the shortest axis of the <see cref="AABB"/>.
         /// </summary>
         /// <returns>A <see cref="Vector3.Axis"/> index for which axis is shortest.</returns>
         public Vector3.Axis GetShortestAxisIndex()
@@ -271,9 +276,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the scalar length of the shortest axis of the AABB.
+        /// Returns the scalar length of the shortest axis of the <see cref="AABB"/>.
         /// </summary>
-        /// <returns>The scalar length of the shortest axis of the AABB.</returns>
+        /// <returns>The scalar length of the shortest axis of the <see cref="AABB"/>.</returns>
         public real_t GetShortestAxisSize()
         {
             real_t max_size = _size.x;
@@ -305,10 +310,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a copy of the AABB grown a given amount of units towards all the sides.
+        /// Returns a copy of the <see cref="AABB"/> grown a given amount of units towards all the sides.
         /// </summary>
         /// <param name="by">The amount to grow by.</param>
-        /// <returns>The grown AABB.</returns>
+        /// <returns>The grown <see cref="AABB"/>.</returns>
         public AABB Grow(real_t by)
         {
             var res = this;
@@ -324,28 +329,37 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if the AABB is flat or empty, or false otherwise.
+        /// Returns <see langword="true"/> if the <see cref="AABB"/> is flat or empty,
+        /// or <see langword="false"/> otherwise.
         /// </summary>
-        /// <returns>A bool for whether or not the AABB has area.</returns>
+        /// <returns>
+        /// A <see langword="bool"/> for whether or not the <see cref="AABB"/> has area.
+        /// </returns>
         public bool HasNoArea()
         {
             return _size.x <= 0f || _size.y <= 0f || _size.z <= 0f;
         }
 
         /// <summary>
-        /// Returns true if the AABB has no surface (no size), or false otherwise.
+        /// Returns <see langword="true"/> if the <see cref="AABB"/> has no surface (no size),
+        /// or <see langword="false"/> otherwise.
         /// </summary>
-        /// <returns>A bool for whether or not the AABB has area.</returns>
+        /// <returns>
+        /// A <see langword="bool"/> for whether or not the <see cref="AABB"/> has area.
+        /// </returns>
         public bool HasNoSurface()
         {
             return _size.x <= 0f && _size.y <= 0f && _size.z <= 0f;
         }
 
         /// <summary>
-        /// Returns true if the AABB contains a point, or false otherwise.
+        /// Returns <see langword="true"/> if the <see cref="AABB"/> contains a point,
+        /// or <see langword="false"/> otherwise.
         /// </summary>
         /// <param name="point">The point to check.</param>
-        /// <returns>A bool for whether or not the AABB contains `point`.</returns>
+        /// <returns>
+        /// A <see langword="bool"/> for whether or not the <see cref="AABB"/> contains <paramref name="point"/>.
+        /// </returns>
         public bool HasPoint(Vector3 point)
         {
             if (point.x < _position.x)
@@ -365,10 +379,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the intersection of this AABB and `b`.
+        /// Returns the intersection of this <see cref="AABB"/> and <paramref name="with"/>.
         /// </summary>
-        /// <param name="with">The other AABB.</param>
-        /// <returns>The clipped AABB.</returns>
+        /// <param name="with">The other <see cref="AABB"/>.</param>
+        /// <returns>The clipped <see cref="AABB"/>.</returns>
         public AABB Intersection(AABB with)
         {
             Vector3 src_min = _position;
@@ -406,15 +420,18 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if the AABB overlaps with `b`
+        /// Returns <see langword="true"/> if the <see cref="AABB"/> overlaps with <paramref name="with"/>
         /// (i.e. they have at least one point in common).
         ///
-        /// If `includeBorders` is true, they will also be considered overlapping
-        /// if their borders touch, even without intersection.
+        /// If <paramref name="includeBorders"/> is <see langword="true"/>,
+        /// they will also be considered overlapping if their borders touch,
+        /// even without intersection.
         /// </summary>
-        /// <param name="with">The other AABB to check for intersections with.</param>
+        /// <param name="with">The other <see cref="AABB"/> to check for intersections with.</param>
         /// <param name="includeBorders">Whether or not to consider borders.</param>
-        /// <returns>A bool for whether or not they are intersecting.</returns>
+        /// <returns>
+        /// A <see langword="bool"/> for whether or not they are intersecting.
+        /// </returns>
         public bool Intersects(AABB with, bool includeBorders = false)
         {
             if (includeBorders)
@@ -452,10 +469,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if the AABB is on both sides of `plane`.
+        /// Returns <see langword="true"/> if the <see cref="AABB"/> is on both sides of <paramref name="plane"/>.
         /// </summary>
-        /// <param name="plane">The plane to check for intersection.</param>
-        /// <returns>A bool for whether or not the AABB intersects the plane.</returns>
+        /// <param name="plane">The <see cref="Plane"/> to check for intersection.</param>
+        /// <returns>
+        /// A <see langword="bool"/> for whether or not the <see cref="AABB"/> intersects the <see cref="Plane"/>.
+        /// </returns>
         public bool IntersectsPlane(Plane plane)
         {
             Vector3[] points =
@@ -489,11 +508,14 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if the AABB intersects the line segment between `from` and `to`.
+        /// Returns <see langword="true"/> if the <see cref="AABB"/> intersects
+        /// the line segment between <paramref name="from"/> and <paramref name="to"/>.
         /// </summary>
         /// <param name="from">The start of the line segment.</param>
         /// <param name="to">The end of the line segment.</param>
-        /// <returns>A bool for whether or not the AABB intersects the line segment.</returns>
+        /// <returns>
+        /// A <see langword="bool"/> for whether or not the <see cref="AABB"/> intersects the line segment.
+        /// </returns>
         public bool IntersectsSegment(Vector3 from, Vector3 to)
         {
             real_t min = 0f;
@@ -549,10 +571,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a larger AABB that contains this AABB and `b`.
+        /// Returns a larger <see cref="AABB"/> that contains this <see cref="AABB"/> and <paramref name="with"/>.
         /// </summary>
-        /// <param name="with">The other AABB.</param>
-        /// <returns>The merged AABB.</returns>
+        /// <param name="with">The other <see cref="AABB"/>.</param>
+        /// <returns>The merged <see cref="AABB"/>.</returns>
         public AABB Merge(AABB with)
         {
             Vector3 beg1 = _position;
@@ -576,7 +598,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs an AABB from a position and size.
+        /// Constructs an <see cref="AABB"/> from a position and size.
         /// </summary>
         /// <param name="position">The position.</param>
         /// <param name="size">The size, typically positive.</param>
@@ -587,7 +609,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs an AABB from a position, width, height, and depth.
+        /// Constructs an <see cref="AABB"/> from a <paramref name="position"/>,
+        /// <paramref name="width"/>, <paramref name="height"/>, and <paramref name="depth"/>.
         /// </summary>
         /// <param name="position">The position.</param>
         /// <param name="width">The width, typically positive.</param>
@@ -600,7 +623,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs an AABB from x, y, z, and size.
+        /// Constructs an <see cref="AABB"/> from <paramref name="x"/>,
+        /// <paramref name="y"/>, <paramref name="z"/>, and <paramref name="size"/>.
         /// </summary>
         /// <param name="x">The position's X coordinate.</param>
         /// <param name="y">The position's Y coordinate.</param>
@@ -613,7 +637,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs an AABB from x, y, z, width, height, and depth.
+        /// Constructs an <see cref="AABB"/> from <paramref name="x"/>,
+        /// <paramref name="y"/>, <paramref name="z"/>, <paramref name="width"/>,
+        /// <paramref name="height"/>, and <paramref name="depth"/>.
         /// </summary>
         /// <param name="x">The position's X coordinate.</param>
         /// <param name="y">The position's Y coordinate.</param>
@@ -637,6 +663,11 @@ namespace Godot
             return !left.Equals(right);
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this AABB and <paramref name="obj"/> are equal.
+        /// </summary>
+        /// <param name="obj">The other object to compare.</param>
+        /// <returns>Whether or not the AABB structure and the other object are equal.</returns>
         public override bool Equals(object obj)
         {
             if (obj is AABB)
@@ -647,27 +678,40 @@ namespace Godot
             return false;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this AABB and <paramref name="other"/> are equal
+        /// </summary>
+        /// <param name="other">The other AABB to compare.</param>
+        /// <returns>Whether or not the AABBs are equal.</returns>
         public bool Equals(AABB other)
         {
             return _position == other._position && _size == other._size;
         }
 
         /// <summary>
-        /// Returns true if this AABB and `other` are approximately equal, by running
-        /// <see cref="Vector3.IsEqualApprox(Vector3)"/> on each component.
+        /// Returns <see langword="true"/> if this AABB and <paramref name="other"/> are approximately equal,
+        /// by running <see cref="Vector3.IsEqualApprox(Vector3)"/> on each component.
         /// </summary>
         /// <param name="other">The other AABB to compare.</param>
-        /// <returns>Whether or not the AABBs are approximately equal.</returns>
+        /// <returns>Whether or not the AABBs structures are approximately equal.</returns>
         public bool IsEqualApprox(AABB other)
         {
             return _position.IsEqualApprox(other._position) && _size.IsEqualApprox(other._size);
         }
 
+        /// <summary>
+        /// Serves as the hash function for <see cref="AABB"/>.
+        /// </summary>
+        /// <returns>A hash code for this AABB.</returns>
         public override int GetHashCode()
         {
             return _position.GetHashCode() ^ _size.GetHashCode();
         }
 
+        /// <summary>
+        /// Converts this <see cref="AABB"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this AABB.</returns>
         public override string ToString()
         {
             return String.Format("{0} - {1}", new object[]
@@ -677,6 +721,10 @@ namespace Godot
                 });
         }
 
+        /// <summary>
+        /// Converts this <see cref="AABB"/> to a string with the given <paramref name="format"/>.
+        /// </summary>
+        /// <returns>A string representation of this AABB.</returns>
         public string ToString(string format)
         {
             return String.Format("{0} - {1}", new object[]
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Array.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Array.cs
index f52a767018b..b996ff9d803 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Array.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Array.cs
@@ -93,7 +93,7 @@ namespace Godot.Collections
         /// <summary>
         /// Duplicates this <see cref="Array"/>.
         /// </summary>
-        /// <param name="deep">If true, performs a deep copy.</param>
+        /// <param name="deep">If <see langword="true"/>, performs a deep copy.</param>
         /// <returns>A new Godot Array.</returns>
         public Array Duplicate(bool deep = false)
         {
@@ -155,9 +155,9 @@ namespace Godot.Collections
         bool IList.IsFixedSize => false;
 
         /// <summary>
-        /// Returns the object at the given index.
+        /// Returns the object at the given <paramref name="index"/>.
         /// </summary>
-        /// <value>The object at the given index.</value>
+        /// <value>The object at the given <paramref name="index"/>.</value>
         public object this[int index]
         {
             get => godot_icall_Array_At(GetPtr(), index);
@@ -166,7 +166,7 @@ namespace Godot.Collections
 
         /// <summary>
         /// Adds an object to the end of this <see cref="Array"/>.
-        /// This is the same as `append` or `push_back` in GDScript.
+        /// This is the same as <c>append</c> or <c>push_back</c> in GDScript.
         /// </summary>
         /// <param name="value">The object to add.</param>
         /// <returns>The new size after adding the object.</returns>
@@ -203,7 +203,7 @@ namespace Godot.Collections
         public void Insert(int index, object value) => godot_icall_Array_Insert(GetPtr(), index, value);
 
         /// <summary>
-        /// Removes the first occurrence of the specified value
+        /// Removes the first occurrence of the specified <paramref name="value"/>
         /// from this <see cref="Array"/>.
         /// </summary>
         /// <param name="value">The value to remove.</param>
@@ -425,7 +425,7 @@ namespace Godot.Collections
         /// <summary>
         /// Duplicates this <see cref="Array{T}"/>.
         /// </summary>
-        /// <param name="deep">If true, performs a deep copy.</param>
+        /// <param name="deep">If <see langword="true"/>, performs a deep copy.</param>
         /// <returns>A new Godot Array.</returns>
         public Array<T> Duplicate(bool deep = false)
         {
@@ -464,9 +464,9 @@ namespace Godot.Collections
         // IList<T>
 
         /// <summary>
-        /// Returns the value at the given index.
+        /// Returns the value at the given <paramref name="index"/>.
         /// </summary>
-        /// <value>The value at the given index.</value>
+        /// <value>The value at the given <paramref name="index"/>.</value>
         public T this[int index]
         {
             get { return (T)Array.godot_icall_Array_At_Generic(GetPtr(), index, elemTypeEncoding, elemTypeClass); }
@@ -522,7 +522,7 @@ namespace Godot.Collections
 
         /// <summary>
         /// Adds an item to the end of this <see cref="Array{T}"/>.
-        /// This is the same as `append` or `push_back` in GDScript.
+        /// This is the same as <c>append</c> or <c>push_back</c> in GDScript.
         /// </summary>
         /// <param name="item">The item to add.</param>
         /// <returns>The new size after adding the item.</returns>
@@ -583,7 +583,7 @@ namespace Godot.Collections
         /// from this <see cref="Array{T}"/>.
         /// </summary>
         /// <param name="item">The value to remove.</param>
-        /// <returns>A bool indicating success or failure.</returns>
+        /// <returns>A <see langword="bool"/> indicating success or failure.</returns>
         public bool Remove(T item)
         {
             return Array.godot_icall_Array_Remove(GetPtr(), item);
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/RPCAttributes.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/RPCAttributes.cs
index 1bf6d5199a3..05082663dc8 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/RPCAttributes.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/RPCAttributes.cs
@@ -3,26 +3,26 @@ using System;
 namespace Godot
 {
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public class RemoteAttribute : Attribute {}
+    public class RemoteAttribute : Attribute { }
 
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public class SyncAttribute : Attribute {}
+    public class SyncAttribute : Attribute { }
 
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public class MasterAttribute : Attribute {}
+    public class MasterAttribute : Attribute { }
 
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public class PuppetAttribute : Attribute {}
+    public class PuppetAttribute : Attribute { }
 
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public class SlaveAttribute : Attribute {}
+    public class SlaveAttribute : Attribute { }
 
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public class RemoteSyncAttribute : Attribute {}
+    public class RemoteSyncAttribute : Attribute { }
 
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public class MasterSyncAttribute : Attribute {}
+    public class MasterSyncAttribute : Attribute { }
 
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public class PuppetSyncAttribute : Attribute {}
+    public class PuppetSyncAttribute : Attribute { }
 }
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/SignalAttribute.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/SignalAttribute.cs
index 3957387be95..38e68a89d51 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/SignalAttribute.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/SignalAttribute.cs
@@ -3,7 +3,5 @@ using System;
 namespace Godot
 {
     [AttributeUsage(AttributeTargets.Delegate)]
-    public class SignalAttribute : Attribute
-    {
-    }
+    public class SignalAttribute : Attribute { }
 }
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/ToolAttribute.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/ToolAttribute.cs
index d0437409afb..d2344389f4e 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/ToolAttribute.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Attributes/ToolAttribute.cs
@@ -3,5 +3,5 @@ using System;
 namespace Godot
 {
     [AttributeUsage(AttributeTargets.Class)]
-    public class ToolAttribute : Attribute {}
+    public class ToolAttribute : Attribute { }
 }
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Basis.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Basis.cs
index f3b0ced10b1..6c426d7e377 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Basis.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Basis.cs
@@ -31,7 +31,7 @@ namespace Godot
         /// <summary>
         /// The basis matrix's X vector (column 0).
         /// </summary>
-        /// <value>Equivalent to <see cref="Column0"/> and array index `[0]`.</value>
+        /// <value>Equivalent to <see cref="Column0"/> and array index <c>[0]</c>.</value>
         public Vector3 x
         {
             get => Column0;
@@ -41,7 +41,7 @@ namespace Godot
         /// <summary>
         /// The basis matrix's Y vector (column 1).
         /// </summary>
-        /// <value>Equivalent to <see cref="Column1"/> and array index `[1]`.</value>
+        /// <value>Equivalent to <see cref="Column1"/> and array index <c>[1]</c>.</value>
         public Vector3 y
         {
             get => Column1;
@@ -51,7 +51,7 @@ namespace Godot
         /// <summary>
         /// The basis matrix's Z vector (column 2).
         /// </summary>
-        /// <value>Equivalent to <see cref="Column2"/> and array index `[2]`.</value>
+        /// <value>Equivalent to <see cref="Column2"/> and array index <c>[2]</c>.</value>
         public Vector3 z
         {
             get => Column2;
@@ -82,7 +82,7 @@ namespace Godot
         /// <summary>
         /// Column 0 of the basis matrix (the X vector).
         /// </summary>
-        /// <value>Equivalent to <see cref="x"/> and array index `[0]`.</value>
+        /// <value>Equivalent to <see cref="x"/> and array index <c>[0]</c>.</value>
         public Vector3 Column0
         {
             get => new Vector3(Row0.x, Row1.x, Row2.x);
@@ -97,7 +97,7 @@ namespace Godot
         /// <summary>
         /// Column 1 of the basis matrix (the Y vector).
         /// </summary>
-        /// <value>Equivalent to <see cref="y"/> and array index `[1]`.</value>
+        /// <value>Equivalent to <see cref="y"/> and array index <c>[1]</c>.</value>
         public Vector3 Column1
         {
             get => new Vector3(Row0.y, Row1.y, Row2.y);
@@ -112,7 +112,7 @@ namespace Godot
         /// <summary>
         /// Column 2 of the basis matrix (the Z vector).
         /// </summary>
-        /// <value>Equivalent to <see cref="z"/> and array index `[2]`.</value>
+        /// <value>Equivalent to <see cref="z"/> and array index <c>[2]</c>.</value>
         public Vector3 Column2
         {
             get => new Vector3(Row0.z, Row1.z, Row2.z);
@@ -150,9 +150,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Access whole columns in the form of Vector3.
+        /// Access whole columns in the form of <see cref="Vector3"/>.
         /// </summary>
         /// <param name="column">Which column vector.</param>
+        /// <value>The basis column.</value>
         public Vector3 this[int column]
         {
             get
@@ -193,6 +194,7 @@ namespace Godot
         /// </summary>
         /// <param name="column">Which column, the matrix horizontal position.</param>
         /// <param name="row">Which row, the matrix vertical position.</param>
+        /// <value>The matrix element.</value>
         public real_t this[int column, int row]
         {
             get
@@ -207,6 +209,13 @@ namespace Godot
             }
         }
 
+        /// <summary>
+        /// Returns the <see cref="Basis"/>'s rotation in the form of a
+        /// <see cref="Godot.Quat"/>. See <see cref="GetEuler"/> if you
+        /// need Euler angles, but keep in mind quaternions should generally
+        /// be preferred to Euler angles.
+        /// </summary>
+        /// <returns>The basis rotation.</returns>
         public Quat RotationQuat()
         {
             Basis orthonormalizedBasis = Orthonormalized();
@@ -266,7 +275,7 @@ namespace Godot
         /// Consider using the <see cref="Basis.Quat()"/> method instead, which
         /// returns a <see cref="Godot.Quat"/> quaternion instead of Euler angles.
         /// </summary>
-        /// <returns>A Vector3 representing the basis rotation in Euler angles.</returns>
+        /// <returns>A <see cref="Vector3"/> representing the basis rotation in Euler angles.</returns>
         public Vector3 GetEuler()
         {
             Basis m = Orthonormalized();
@@ -304,7 +313,10 @@ namespace Godot
         /// but are more efficient for some internal calculations.
         /// </summary>
         /// <param name="index">Which row.</param>
-        /// <returns>One of `Row0`, `Row1`, or `Row2`.</returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when the <paramref name="index"/> is not 0, 1 or 2.
+        /// </exception>
+        /// <returns>One of <c>Row0</c>, <c>Row1</c>, or <c>Row2</c>.</returns>
         public Vector3 GetRow(int index)
         {
             switch (index)
@@ -326,6 +338,9 @@ namespace Godot
         /// </summary>
         /// <param name="index">Which row.</param>
         /// <param name="value">The vector to set the row to.</param>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when the <paramref name="index"/> is not 0, 1 or 2.
+        /// </exception>
         public void SetRow(int index, Vector3 value)
         {
             switch (index)
@@ -485,8 +500,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Introduce an additional rotation around the given `axis`
-        /// by `phi` (in radians). The axis must be a normalized vector.
+        /// Introduce an additional rotation around the given <paramref name="axis"/>
+        /// by <paramref name="phi"/> (in radians). The axis must be a normalized vector.
         /// </summary>
         /// <param name="axis">The axis to rotate around. Must be normalized.</param>
         /// <param name="phi">The angle to rotate, in radians.</param>
@@ -586,6 +601,7 @@ namespace Godot
         /// <summary>
         /// Returns a vector transformed (multiplied) by the basis matrix.
         /// </summary>
+        /// <seealso cref="XformInv(Vector3)"/>
         /// <param name="v">A vector to transform.</param>
         /// <returns>The transformed vector.</returns>
         public Vector3 Xform(Vector3 v)
@@ -604,6 +620,7 @@ namespace Godot
         /// Note: This results in a multiplication by the inverse of the
         /// basis matrix only if it represents a rotation-reflection.
         /// </summary>
+        /// <seealso cref="Xform(Vector3)"/>
         /// <param name="v">A vector to inversely transform.</param>
         /// <returns>The inversely transformed vector.</returns>
         public Vector3 XformInv(Vector3 v)
@@ -708,25 +725,25 @@ namespace Godot
 
         /// <summary>
         /// The identity basis, with no rotation or scaling applied.
-        /// This is used as a replacement for `Basis()` in GDScript.
-        /// Do not use `new Basis()` with no arguments in C#, because it sets all values to zero.
+        /// This is used as a replacement for <c>Basis()</c> in GDScript.
+        /// Do not use <c>new Basis()</c> with no arguments in C#, because it sets all values to zero.
         /// </summary>
-        /// <value>Equivalent to `new Basis(Vector3.Right, Vector3.Up, Vector3.Back)`.</value>
+        /// <value>Equivalent to <c>new Basis(Vector3.Right, Vector3.Up, Vector3.Back)</c>.</value>
         public static Basis Identity { get { return _identity; } }
         /// <summary>
         /// The basis that will flip something along the X axis when used in a transformation.
         /// </summary>
-        /// <value>Equivalent to `new Basis(Vector3.Left, Vector3.Up, Vector3.Back)`.</value>
+        /// <value>Equivalent to <c>new Basis(Vector3.Left, Vector3.Up, Vector3.Back)</c>.</value>
         public static Basis FlipX { get { return _flipX; } }
         /// <summary>
         /// The basis that will flip something along the Y axis when used in a transformation.
         /// </summary>
-        /// <value>Equivalent to `new Basis(Vector3.Right, Vector3.Down, Vector3.Back)`.</value>
+        /// <value>Equivalent to <c>new Basis(Vector3.Right, Vector3.Down, Vector3.Back)</c>.</value>
         public static Basis FlipY { get { return _flipY; } }
         /// <summary>
         /// The basis that will flip something along the Z axis when used in a transformation.
         /// </summary>
-        /// <value>Equivalent to `new Basis(Vector3.Right, Vector3.Up, Vector3.Forward)`.</value>
+        /// <value>Equivalent to <c>new Basis(Vector3.Right, Vector3.Up, Vector3.Forward)</c>.</value>
         public static Basis FlipZ { get { return _flipZ; } }
 
         /// <summary>
@@ -785,8 +802,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a pure rotation basis matrix, rotated around the given `axis`
-        /// by `phi` (in radians). The axis must be a normalized vector.
+        /// Constructs a pure rotation basis matrix, rotated around the given <paramref name="axis"/>
+        /// by <paramref name="phi"/> (in radians). The axis must be a normalized vector.
         /// </summary>
         /// <param name="axis">The axis to rotate around. Must be normalized.</param>
         /// <param name="phi">The angle to rotate, in radians.</param>
@@ -863,6 +880,11 @@ namespace Godot
             return !left.Equals(right);
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this basis and <paramref name="obj"/> are equal.
+        /// </summary>
+        /// <param name="obj">The other object to compare.</param>
+        /// <returns>Whether or not the basis and the other object are equal.</returns>
         public override bool Equals(object obj)
         {
             if (obj is Basis)
@@ -873,27 +895,40 @@ namespace Godot
             return false;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this basis and <paramref name="other"/> are equal
+        /// </summary>
+        /// <param name="other">The other basis to compare.</param>
+        /// <returns>Whether or not the bases are equal.</returns>
         public bool Equals(Basis other)
         {
             return Row0.Equals(other.Row0) && Row1.Equals(other.Row1) && Row2.Equals(other.Row2);
         }
 
         /// <summary>
-        /// Returns true if this basis and `other` are approximately equal, by running
-        /// <see cref="Vector3.IsEqualApprox(Vector3)"/> on each component.
+        /// Returns <see langword="true"/> if this basis and <paramref name="other"/> are approximately equal,
+        /// by running <see cref="Vector3.IsEqualApprox(Vector3)"/> on each component.
         /// </summary>
         /// <param name="other">The other basis to compare.</param>
-        /// <returns>Whether or not the matrices are approximately equal.</returns>
+        /// <returns>Whether or not the bases are approximately equal.</returns>
         public bool IsEqualApprox(Basis other)
         {
             return Row0.IsEqualApprox(other.Row0) && Row1.IsEqualApprox(other.Row1) && Row2.IsEqualApprox(other.Row2);
         }
 
+        /// <summary>
+        /// Serves as the hash function for <see cref="Basis"/>.
+        /// </summary>
+        /// <returns>A hash code for this basis.</returns>
         public override int GetHashCode()
         {
             return Row0.GetHashCode() ^ Row1.GetHashCode() ^ Row2.GetHashCode();
         }
 
+        /// <summary>
+        /// Converts this <see cref="Basis"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this basis.</returns>
         public override string ToString()
         {
             return String.Format("({0}, {1}, {2})", new object[]
@@ -904,6 +939,10 @@ namespace Godot
             });
         }
 
+        /// <summary>
+        /// Converts this <see cref="Basis"/> to a string with the given <paramref name="format"/>.
+        /// </summary>
+        /// <returns>A string representation of this basis.</returns>
         public string ToString(string format)
         {
             return String.Format("({0}, {1}, {2})", new object[]
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Color.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Color.cs
index 7732c19d900..59464f72760 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Color.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Color.cs
@@ -7,11 +7,11 @@ namespace Godot
     /// A color represented by red, green, blue, and alpha (RGBA) components.
     /// The alpha component is often used for transparency.
     /// Values are in floating-point and usually range from 0 to 1.
-    /// Some properties (such as CanvasItem.modulate) may accept values
+    /// Some properties (such as <see cref="CanvasItem.Modulate"/>) may accept values
     /// greater than 1 (overbright or HDR colors).
     ///
     /// If you want to supply values in a range of 0 to 255, you should use
-    /// <see cref="Color8"/> and the `r8`/`g8`/`b8`/`a8` properties.
+    /// <see cref="Color8"/> and the <c>r8</c>/<c>g8</c>/<c>b8</c>/<c>a8</c> properties.
     /// </summary>
     [Serializable]
     [StructLayout(LayoutKind.Sequential)]
@@ -173,7 +173,7 @@ namespace Godot
         /// <summary>
         /// The HSV value (brightness) of this color, on the range 0 to 1.
         /// </summary>
-        /// <value>Getting is equivalent to using `Max()` on the RGB components. Setting uses <see cref="FromHsv"/>.</value>
+        /// <value>Getting is equivalent to using <see cref="Math.Max(float, float)"/> on the RGB components. Setting uses <see cref="FromHsv"/>.</value>
         public float v
         {
             get
@@ -216,7 +216,12 @@ namespace Godot
         /// <summary>
         /// Access color components using their index.
         /// </summary>
-        /// <value>`[0]` is equivalent to `.r`, `[1]` is equivalent to `.g`, `[2]` is equivalent to `.b`, `[3]` is equivalent to `.a`.</value>
+        /// <value>
+        /// <c>[0]</c> is equivalent to <see cref="r"/>,
+        /// <c>[1]</c> is equivalent to <see cref="g"/>,
+        /// <c>[2]</c> is equivalent to <see cref="b"/>,
+        /// <c>[3]</c> is equivalent to <see cref="a"/>.
+        /// </value>
         public float this[int index]
         {
             get
@@ -259,7 +264,7 @@ namespace Godot
 
         /// <summary>
         /// Converts a color to HSV values. This is equivalent to using each of
-        /// the `h`/`s`/`v` properties, but much more efficient.
+        /// the <c>h</c>/<c>s</c>/<c>v</c> properties, but much more efficient.
         /// </summary>
         /// <param name="hue">Output parameter for the HSV hue.</param>
         /// <param name="saturation">Output parameter for the HSV saturation.</param>
@@ -297,7 +302,7 @@ namespace Godot
         /// <summary>
         /// Constructs a color from an HSV profile, with values on the
         /// range of 0 to 1. This is equivalent to using each of
-        /// the `h`/`s`/`v` properties, but much more efficient.
+        /// the <c>h</c>/<c>s</c>/<c>v</c> properties, but much more efficient.
         /// </summary>
         /// <param name="hue">The HSV hue, typically on the range of 0 to 1.</param>
         /// <param name="saturation">The HSV saturation, typically on the range of 0 to 1.</param>
@@ -347,7 +352,7 @@ namespace Godot
         /// The second color may have a range of alpha values.
         /// </summary>
         /// <param name="over">The color to blend over.</param>
-        /// <returns>This color blended over `over`.</returns>
+        /// <returns>This color blended over <paramref name="over"/>.</returns>
         public Color Blend(Color over)
         {
             Color res;
@@ -397,7 +402,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the inverted color: `(1 - r, 1 - g, 1 - b, a)`.
+        /// Returns the inverted color: <c>(1 - r, 1 - g, 1 - b, a)</c>.
         /// </summary>
         /// <returns>The inverted color.</returns>
         public Color Inverted()
@@ -427,7 +432,7 @@ namespace Godot
 
         /// <summary>
         /// Returns the result of the linear interpolation between
-        /// this color and `to` by amount `weight`.
+        /// this color and <paramref name="to"/> by amount <paramref name="weight"/>.
         /// </summary>
         /// <param name="to">The destination color for interpolation.</param>
         /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
@@ -445,7 +450,7 @@ namespace Godot
 
         /// <summary>
         /// Returns the result of the linear interpolation between
-        /// this color and `to` by color amount `weight`.
+        /// this color and <paramref name="to"/> by color amount <paramref name="weight"/>.
         /// </summary>
         /// <param name="to">The destination color for interpolation.</param>
         /// <param name="weight">A color with components on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
@@ -466,7 +471,7 @@ namespace Godot
         /// format (each byte represents a color channel).
         /// ABGR is the reversed version of the default format.
         /// </summary>
-        /// <returns>An int representing this color in ABGR32 format.</returns>
+        /// <returns>A <see langword="int"/> representing this color in ABGR32 format.</returns>
         public int ToAbgr32()
         {
             int c = (byte)Math.Round(a * 255);
@@ -485,7 +490,7 @@ namespace Godot
         /// format (each word represents a color channel).
         /// ABGR is the reversed version of the default format.
         /// </summary>
-        /// <returns>An int representing this color in ABGR64 format.</returns>
+        /// <returns>A <see langword="long"/> representing this color in ABGR64 format.</returns>
         public long ToAbgr64()
         {
             long c = (ushort)Math.Round(a * 65535);
@@ -504,7 +509,7 @@ namespace Godot
         /// format (each byte represents a color channel).
         /// ARGB is more compatible with DirectX, but not used much in Godot.
         /// </summary>
-        /// <returns>An int representing this color in ARGB32 format.</returns>
+        /// <returns>A <see langword="int"/> representing this color in ARGB32 format.</returns>
         public int ToArgb32()
         {
             int c = (byte)Math.Round(a * 255);
@@ -523,7 +528,7 @@ namespace Godot
         /// format (each word represents a color channel).
         /// ARGB is more compatible with DirectX, but not used much in Godot.
         /// </summary>
-        /// <returns>A long representing this color in ARGB64 format.</returns>
+        /// <returns>A <see langword="long"/> representing this color in ARGB64 format.</returns>
         public long ToArgb64()
         {
             long c = (ushort)Math.Round(a * 65535);
@@ -542,7 +547,7 @@ namespace Godot
         /// format (each byte represents a color channel).
         /// RGBA is Godot's default and recommended format.
         /// </summary>
-        /// <returns>An int representing this color in RGBA32 format.</returns>
+        /// <returns>A <see langword="int"/> representing this color in RGBA32 format.</returns>
         public int ToRgba32()
         {
             int c = (byte)Math.Round(r * 255);
@@ -561,7 +566,7 @@ namespace Godot
         /// format (each word represents a color channel).
         /// RGBA is Godot's default and recommended format.
         /// </summary>
-        /// <returns>A long representing this color in RGBA64 format.</returns>
+        /// <returns>A <see langword="long"/> representing this color in RGBA64 format.</returns>
         public long ToRgba64()
         {
             long c = (ushort)Math.Round(r * 65535);
@@ -578,7 +583,9 @@ namespace Godot
         /// <summary>
         /// Returns the color's HTML hexadecimal color string in RGBA format.
         /// </summary>
-        /// <param name="includeAlpha">Whether or not to include alpha. If false, the color is RGB instead of RGBA.</param>
+        /// <param name="includeAlpha">
+        /// Whether or not to include alpha. If <see langword="false"/>, the color is RGB instead of RGBA.
+        /// </param>
         /// <returns>A string for the HTML hexadecimal representation of this color.</returns>
         public string ToHtml(bool includeAlpha = true)
         {
@@ -595,7 +602,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a color from RGBA values, typically on the range of 0 to 1.
+        /// Constructs a <see cref="Color"/> from RGBA values, typically on the range of 0 to 1.
         /// </summary>
         /// <param name="r">The color's red component, typically on the range of 0 to 1.</param>
         /// <param name="g">The color's green component, typically on the range of 0 to 1.</param>
@@ -610,7 +617,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a color from an existing color and an alpha value.
+        /// Constructs a <see cref="Color"/> from an existing color and an alpha value.
         /// </summary>
         /// <param name="c">The color to construct from. Only its RGB values are used.</param>
         /// <param name="a">The color's alpha (transparency) value, typically on the range of 0 to 1. Default: 1.</param>
@@ -623,10 +630,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a color from a 32-bit integer in RGBA format
+        /// Constructs a <see cref="Color"/> from a 32-bit integer in RGBA format
         /// (each byte represents a color channel).
         /// </summary>
-        /// <param name="rgba">The int representing the color.</param>
+        /// <param name="rgba">The <see langword="int"/> representing the color.</param>
         public Color(int rgba)
         {
             a = (rgba & 0xFF) / 255.0f;
@@ -639,10 +646,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a color from a 64-bit integer in RGBA format
+        /// Constructs a <see cref="Color"/> from a 64-bit integer in RGBA format
         /// (each word represents a color channel).
         /// </summary>
-        /// <param name="rgba">The long representing the color.</param>
+        /// <param name="rgba">The <see langword="long"/> representing the color.</param>
         public Color(long rgba)
         {
             a = (rgba & 0xFFFF) / 65535.0f;
@@ -762,9 +769,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a color from the HTML hexadecimal color string in RGBA format.
+        /// Constructs a <see cref="Color"/> from the HTML hexadecimal color string in RGBA format.
         /// </summary>
         /// <param name="rgba">A string for the HTML hexadecimal representation of this color.</param>
+        /// <exception name="ArgumentOutOfRangeException">
+        /// Thrown when the given <paramref name="rgba"/> color code is invalid.
+        /// </exception>
         public Color(string rgba)
         {
             if (rgba.Length == 0)
@@ -936,6 +946,11 @@ namespace Godot
             return left.r > right.r;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this color and <paramref name="obj"/> are equal.
+        /// </summary>
+        /// <param name="obj">The other object to compare.</param>
+        /// <returns>Whether or not the color and the other object are equal.</returns>
         public override bool Equals(object obj)
         {
             if (obj is Color)
@@ -946,14 +961,19 @@ namespace Godot
             return false;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this color and <paramref name="other"/> are equal
+        /// </summary>
+        /// <param name="other">The other color to compare.</param>
+        /// <returns>Whether or not the colors are equal.</returns>
         public bool Equals(Color other)
         {
             return r == other.r && g == other.g && b == other.b && a == other.a;
         }
 
         /// <summary>
-        /// Returns true if this color and `other` are approximately equal, by running
-        /// <see cref="Godot.Mathf.IsEqualApprox(float, float)"/> on each component.
+        /// Returns <see langword="true"/> if this color and <paramref name="other"/> are approximately equal,
+        /// by running <see cref="Mathf.IsEqualApprox(float, float)"/> on each component.
         /// </summary>
         /// <param name="other">The other color to compare.</param>
         /// <returns>Whether or not the colors are approximately equal.</returns>
@@ -962,16 +982,28 @@ namespace Godot
             return Mathf.IsEqualApprox(r, other.r) && Mathf.IsEqualApprox(g, other.g) && Mathf.IsEqualApprox(b, other.b) && Mathf.IsEqualApprox(a, other.a);
         }
 
+        /// <summary>
+        /// Serves as the hash function for <see cref="Color"/>.
+        /// </summary>
+        /// <returns>A hash code for this color.</returns>
         public override int GetHashCode()
         {
             return r.GetHashCode() ^ g.GetHashCode() ^ b.GetHashCode() ^ a.GetHashCode();
         }
 
+        /// <summary>
+        /// Converts this <see cref="Color"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this color.</returns>
         public override string ToString()
         {
             return String.Format("{0},{1},{2},{3}", r.ToString(), g.ToString(), b.ToString(), a.ToString());
         }
 
+        /// <summary>
+        /// Converts this <see cref="Color"/> to a string with the given <paramref name="format"/>.
+        /// </summary>
+        /// <returns>A string representation of this color.</returns>
         public string ToString(string format)
         {
             return String.Format("{0},{1},{2},{3}", r.ToString(format), g.ToString(format), b.ToString(format), a.ToString(format));
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/DynamicObject.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/DynamicObject.cs
index 0fa970861db..8fbf52208f8 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/DynamicObject.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/DynamicObject.cs
@@ -7,20 +7,20 @@ using System.Runtime.CompilerServices;
 namespace Godot
 {
     /// <summary>
-    /// Represents an <see cref="Godot.Object"/> whose members can be dynamically accessed at runtime through the Variant API.
+    /// Represents an <see cref="Object"/> whose members can be dynamically accessed at runtime through the Variant API.
     /// </summary>
     /// <remarks>
     /// <para>
-    /// The <see cref="Godot.DynamicGodotObject"/> class enables access to the Variant
-    /// members of a <see cref="Godot.Object"/> instance at runtime.
+    /// The <see cref="DynamicGodotObject"/> class enables access to the Variant
+    /// members of a <see cref="Object"/> instance at runtime.
     /// </para>
     /// <para>
     /// This allows accessing the class members using their original names in the engine as well as the members from the
-    /// script attached to the <see cref="Godot.Object"/>, regardless of the scripting language it was written in.
+    /// script attached to the <see cref="Object"/>, regardless of the scripting language it was written in.
     /// </para>
     /// </remarks>
     /// <example>
-    /// This sample shows how to use <see cref="Godot.DynamicGodotObject"/> to dynamically access the engine members of a <see cref="Godot.Object"/>.
+    /// This sample shows how to use <see cref="DynamicGodotObject"/> to dynamically access the engine members of a <see cref="Object"/>.
     /// <code>
     /// dynamic sprite = GetNode("Sprite").DynamicGodotObject;
     /// sprite.add_child(this);
@@ -30,7 +30,7 @@ namespace Godot
     /// </code>
     /// </example>
     /// <example>
-    /// This sample shows how to use <see cref="Godot.DynamicGodotObject"/> to dynamically access the members of the script attached to a <see cref="Godot.Object"/>.
+    /// This sample shows how to use <see cref="DynamicGodotObject"/> to dynamically access the members of the script attached to a <see cref="Object"/>.
     /// <code>
     /// dynamic childNode = GetNode("ChildNode").DynamicGodotObject;
     ///
@@ -54,18 +54,18 @@ namespace Godot
     public class DynamicGodotObject : DynamicObject
     {
         /// <summary>
-        /// Gets the <see cref="Godot.Object"/> associated with this <see cref="Godot.DynamicGodotObject"/>.
+        /// Gets the <see cref="Object"/> associated with this <see cref="DynamicGodotObject"/>.
         /// </summary>
         public Object Value { get; }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="Godot.DynamicGodotObject"/> class.
+        /// Initializes a new instance of the <see cref="DynamicGodotObject"/> class.
         /// </summary>
         /// <param name="godotObject">
-        /// The <see cref="Godot.Object"/> that will be associated with this <see cref="Godot.DynamicGodotObject"/>.
+        /// The <see cref="Object"/> that will be associated with this <see cref="DynamicGodotObject"/>.
         /// </param>
-        /// <exception cref="System.ArgumentNullException">
-        /// Thrown when the <paramref name="godotObject"/> parameter is null.
+        /// <exception cref="ArgumentNullException">
+        /// Thrown when the <paramref name="godotObject"/> parameter is <see langword="null"/>.
         /// </exception>
         public DynamicGodotObject(Object godotObject)
         {
@@ -75,11 +75,13 @@ namespace Godot
             this.Value = godotObject;
         }
 
+        /// <inheritdoc/>
         public override IEnumerable<string> GetDynamicMemberNames()
         {
             return godot_icall_DynamicGodotObject_SetMemberList(Object.GetPtr(Value));
         }
 
+        /// <inheritdoc/>
         public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
         {
             switch (binder.Operation)
@@ -121,6 +123,7 @@ namespace Godot
             return base.TryBinaryOperation(binder, arg, out result);
         }
 
+        /// <inheritdoc/>
         public override bool TryConvert(ConvertBinder binder, out object result)
         {
             if (binder.Type == typeof(Object))
@@ -139,6 +142,7 @@ namespace Godot
             return base.TryConvert(binder, out result);
         }
 
+        /// <inheritdoc/>
         public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
         {
             if (indexes.Length == 1)
@@ -152,16 +156,19 @@ namespace Godot
             return base.TryGetIndex(binder, indexes, out result);
         }
 
+        /// <inheritdoc/>
         public override bool TryGetMember(GetMemberBinder binder, out object result)
         {
             return godot_icall_DynamicGodotObject_GetMember(Object.GetPtr(Value), binder.Name, out result);
         }
 
+        /// <inheritdoc/>
         public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
         {
             return godot_icall_DynamicGodotObject_InvokeMember(Object.GetPtr(Value), binder.Name, args, out result);
         }
 
+        /// <inheritdoc/>
         public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value)
         {
             if (indexes.Length == 1)
@@ -175,6 +182,7 @@ namespace Godot
             return base.TrySetIndex(binder, indexes, value);
         }
 
+        /// <inheritdoc/>
         public override bool TrySetMember(SetMemberBinder binder, object value)
         {
             return godot_icall_DynamicGodotObject_SetMember(Object.GetPtr(Value), binder.Name, value);
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/NodeExtensions.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/NodeExtensions.cs
index 5d16260f5d6..1dc21b6303b 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/NodeExtensions.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/NodeExtensions.cs
@@ -1,42 +1,192 @@
+using System;
+
 namespace Godot
 {
     public partial class Node
     {
+        /// <summary>
+        /// Fetches a node. The <see cref="NodePath"/> can be either a relative path (from
+        /// the current node) or an absolute path (in the scene tree) to a node. If the path
+        /// does not exist, a <see langword="null"/> instance is returned and an error
+        /// is logged. Attempts to access methods on the return value will result in an
+        /// "Attempt to call &lt;method&gt; on a null instance." error.
+        /// Note: Fetching absolute paths only works when the node is inside the scene tree
+        /// (see <see cref="IsInsideTree"/>).
+        /// </summary>
+        /// <example>
+        /// Example: Assume your current node is Character and the following tree:
+        /// <code>
+        /// /root
+        /// /root/Character
+        /// /root/Character/Sword
+        /// /root/Character/Backpack/Dagger
+        /// /root/MyGame
+        /// /root/Swamp/Alligator
+        /// /root/Swamp/Mosquito
+        /// /root/Swamp/Goblin
+        /// </code>
+        /// Possible paths are:
+        /// <code>
+        /// GetNode("Sword");
+        /// GetNode("Backpack/Dagger");
+        /// GetNode("../Swamp/Alligator");
+        /// GetNode("/root/MyGame");
+        /// </code>
+        /// </example>
+        /// <seealso cref="GetNodeOrNull{T}(NodePath)"/>
+        /// <param name="path">The path to the node to fetch.</param>
+        /// <exception cref="InvalidCastException">
+        /// Thrown when the given the fetched node can't be casted to the given type <typeparamref name="T"/>.
+        /// </exception>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Node"/>.</typeparam>
+        /// <returns>
+        /// The <see cref="Node"/> at the given <paramref name="path"/>.
+        /// </returns>
         public T GetNode<T>(NodePath path) where T : class
         {
             return (T)(object)GetNode(path);
         }
 
+        /// <summary>
+        /// Fetches a node. The <see cref="NodePath"/> can be either a relative path (from
+        /// the current node) or an absolute path (in the scene tree) to a node. If the path
+        /// does not exist, a <see langword="null"/> instance is returned and an error
+        /// is logged. Attempts to access methods on the return value will result in an
+        /// "Attempt to call &lt;method&gt; on a null instance." error.
+        /// Note: Fetching absolute paths only works when the node is inside the scene tree
+        /// (see <see cref="IsInsideTree"/>).
+        /// </summary>
+        /// <example>
+        /// Example: Assume your current node is Character and the following tree:
+        /// <code>
+        /// /root
+        /// /root/Character
+        /// /root/Character/Sword
+        /// /root/Character/Backpack/Dagger
+        /// /root/MyGame
+        /// /root/Swamp/Alligator
+        /// /root/Swamp/Mosquito
+        /// /root/Swamp/Goblin
+        /// </code>
+        /// Possible paths are:
+        /// <code>
+        /// GetNode("Sword");
+        /// GetNode("Backpack/Dagger");
+        /// GetNode("../Swamp/Alligator");
+        /// GetNode("/root/MyGame");
+        /// </code>
+        /// </example>
+        /// <seealso cref="GetNode{T}(NodePath)"/>
+        /// <param name="path">The path to the node to fetch.</param>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Node"/>.</typeparam>
+        /// <returns>
+        /// The <see cref="Node"/> at the given <paramref name="path"/>, or <see langword="null"/> if not found.
+        /// </returns>
         public T GetNodeOrNull<T>(NodePath path) where T : class
         {
             return GetNodeOrNull(path) as T;
         }
 
+        /// <summary>
+        /// Returns a child node by its index (see <see cref="GetChildCount"/>).
+        /// This method is often used for iterating all children of a node.
+        /// Negative indices access the children from the last one.
+        /// To access a child node via its name, use <see cref="GetNode"/>.
+        /// </summary>
+        /// <seealso cref="GetChildOrNull{T}(int)"/>
+        /// <param name="idx">Child index.</param>
+        /// <exception cref="InvalidCastException">
+        /// Thrown when the given the fetched node can't be casted to the given type <typeparamref name="T"/>.
+        /// </exception>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Node"/>.</typeparam>
+        /// <returns>
+        /// The child <see cref="Node"/> at the given index <paramref name="idx"/>.
+        /// </returns>
         public T GetChild<T>(int idx) where T : class
         {
             return (T)(object)GetChild(idx);
         }
 
+        /// <summary>
+        /// Returns a child node by its index (see <see cref="GetChildCount"/>).
+        /// This method is often used for iterating all children of a node.
+        /// Negative indices access the children from the last one.
+        /// To access a child node via its name, use <see cref="GetNode"/>.
+        /// </summary>
+        /// <seealso cref="GetChild{T}(int)"/>
+        /// <param name="idx">Child index.</param>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Node"/>.</typeparam>
+        /// <returns>
+        /// The child <see cref="Node"/> at the given index <paramref name="idx"/>, or <see langword="null"/> if not found.
+        /// </returns>
         public T GetChildOrNull<T>(int idx) where T : class
         {
             return GetChild(idx) as T;
         }
 
+        /// <summary>
+        /// The node owner. A node can have any other node as owner (as long as it is
+        /// a valid parent, grandparent, etc. ascending in the tree). When saving a
+        /// node (using <see cref="PackedScene"/>), all the nodes it owns will be saved
+        /// with it. This allows for the creation of complex <see cref="SceneTree"/>s,
+        /// with instancing and subinstancing.
+        /// </summary>
+        /// <seealso cref="GetOwnerOrNull{T}"/>
+        /// <exception cref="InvalidCastException">
+        /// Thrown when the given the fetched node can't be casted to the given type <typeparamref name="T"/>.
+        /// </exception>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Node"/>.</typeparam>
+        /// <returns>
+        /// The owner <see cref="Node"/>.
+        /// </returns>
         public T GetOwner<T>() where T : class
         {
             return (T)(object)Owner;
         }
 
+        /// <summary>
+        /// The node owner. A node can have any other node as owner (as long as it is
+        /// a valid parent, grandparent, etc. ascending in the tree). When saving a
+        /// node (using <see cref="PackedScene"/>), all the nodes it owns will be saved
+        /// with it. This allows for the creation of complex <see cref="SceneTree"/>s,
+        /// with instancing and subinstancing.
+        /// </summary>
+        /// <seealso cref="GetOwner{T}"/>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Node"/>.</typeparam>
+        /// <returns>
+        /// The owner <see cref="Node"/>, or <see langword="null"/> if there is no owner.
+        /// </returns>
         public T GetOwnerOrNull<T>() where T : class
         {
             return Owner as T;
         }
 
+        /// <summary>
+        /// Returns the parent node of the current node, or a <see langword="null"/> instance
+        /// if the node lacks a parent.
+        /// </summary>
+        /// <seealso cref="GetParentOrNull{T}"/>
+        /// <exception cref="InvalidCastException">
+        /// Thrown when the given the fetched node can't be casted to the given type <typeparamref name="T"/>.
+        /// </exception>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Node"/>.</typeparam>
+        /// <returns>
+        /// The parent <see cref="Node"/>.
+        /// </returns>
         public T GetParent<T>() where T : class
         {
             return (T)(object)GetParent();
         }
 
+        /// <summary>
+        /// Returns the parent node of the current node, or a <see langword="null"/> instance
+        /// if the node lacks a parent.
+        /// </summary>
+        /// <seealso cref="GetParent{T}"/>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Node"/>.</typeparam>
+        /// <returns>
+        /// The parent <see cref="Node"/>, or <see langword="null"/> if the node has no parent.
+        /// </returns>
         public T GetParentOrNull<T>() where T : class
         {
             return GetParent() as T;
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/ObjectExtensions.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/ObjectExtensions.cs
index 9ef09597500..e1f8773ccda 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/ObjectExtensions.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/ObjectExtensions.cs
@@ -5,14 +5,34 @@ namespace Godot
 {
     public partial class Object
     {
+        /// <summary>
+        /// Returns whether <paramref name="instance"/> is a valid object
+        /// (e.g. has not been deleted from memory).
+        /// </summary>
+        /// <param name="instance">The instance to check.</param>
+        /// <returns>If the instance is a valid object.</returns>
         public static bool IsInstanceValid(Object instance)
         {
             return instance != null && instance.NativeInstance != IntPtr.Zero;
         }
 
+        /// <summary>
+        /// Returns a weak reference to an object, or <see langword="null"/>
+        /// if the argument is invalid.
+        /// A weak reference to an object is not enough to keep the object alive:
+        /// when the only remaining references to a referent are weak references,
+        /// garbage collection is free to destroy the referent and reuse its memory
+        /// for something else. However, until the object is actually destroyed the
+        /// weak reference may return the object even if there are no strong references
+        /// to it.
+        /// </summary>
+        /// <param name="obj">The object.</param>
+        /// <returns>
+        /// The <see cref="WeakRef"/> reference to the object or <see langword="null"/>.
+        /// </returns>
         public static WeakRef WeakRef(Object obj)
         {
-            return godot_icall_Object_weakref(Object.GetPtr(obj));
+            return godot_icall_Object_weakref(GetPtr(obj));
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/PackedSceneExtensions.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/PackedSceneExtensions.cs
index 763f470504b..6f8b2598380 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/PackedSceneExtensions.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/PackedSceneExtensions.cs
@@ -1,3 +1,5 @@
+using System;
+
 namespace Godot
 {
     public partial class PackedScene
@@ -5,20 +7,27 @@ namespace Godot
         /// <summary>
         /// Instantiates the scene's node hierarchy, erroring on failure.
         /// Triggers child scene instantiation(s). Triggers a
-        /// `Node.NotificationInstanced` notification on the root node.
+        /// <see cref="Node.NotificationInstanced"/> notification on the root node.
         /// </summary>
-        /// <typeparam name="T">The type to cast to. Should be a descendant of Node.</typeparam>
+        /// <seealso cref="InstanceOrNull{T}(GenEditState)"/>
+        /// <exception cref="InvalidCastException">
+        /// Thrown when the given the instantiated node can't be casted to the given type <typeparamref name="T"/>.
+        /// </exception>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Node"/>.</typeparam>
+        /// <returns>The instantiated scene.</returns>
         public T Instance<T>(PackedScene.GenEditState editState = (PackedScene.GenEditState)0) where T : class
         {
             return (T)(object)Instance(editState);
         }
 
         /// <summary>
-        /// Instantiates the scene's node hierarchy, returning null on failure.
+        /// Instantiates the scene's node hierarchy, returning <see langword="null"/> on failure.
         /// Triggers child scene instantiation(s). Triggers a
-        /// `Node.NotificationInstanced` notification on the root node.
+        /// <see cref="Node.NotificationInstanced"/> notification on the root node.
         /// </summary>
-        /// <typeparam name="T">The type to cast to. Should be a descendant of Node.</typeparam>
+        /// <seealso cref="Instance{T}(GenEditState)"/>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Node"/>.</typeparam>
+        /// <returns>The instantiated scene.</returns>
         public T InstanceOrNull<T>(PackedScene.GenEditState editState = (PackedScene.GenEditState)0) where T : class
         {
             return Instance(editState) as T;
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/ResourceLoaderExtensions.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/ResourceLoaderExtensions.cs
index 5f64c09a898..49f3b52afee 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/ResourceLoaderExtensions.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Extensions/ResourceLoaderExtensions.cs
@@ -1,7 +1,27 @@
+using System;
+
 namespace Godot
 {
     public static partial class ResourceLoader
     {
+        /// <summary>
+        /// Loads a resource at the given <paramref name="path"/>, caching the result
+        /// for further access.
+        /// The registered <see cref="ResourceFormatLoader"/> instances are queried sequentially
+        /// to find the first one which can handle the file's extension, and then attempt
+        /// loading. If loading fails, the remaining ResourceFormatLoaders are also attempted.
+        /// An optional <paramref name="typeHint"/> can be used to further specify the
+        /// <see cref="Resource"/> type that should be handled by the <see cref="ResourceFormatLoader"/>.
+        /// Anything that inherits from <see cref="Resource"/> can be used as a type hint,
+        /// for example <see cref="Image"/>.
+        /// If <paramref name="noCache"/> is <see langword="true"/>, the resource cache will be bypassed and
+        /// the resource will be loaded anew. Otherwise, the cached resource will be returned if it exists.
+        /// Returns an empty resource if no <see cref="ResourceFormatLoader"/> could handle the file.
+        /// </summary>
+        /// <exception cref="InvalidCastException">
+        /// Thrown when the given the loaded resource can't be casted to the given type <typeparamref name="T"/>.
+        /// </exception>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Resource"/>.</typeparam>
         public static T Load<T>(string path, string typeHint = null, bool noCache = false) where T : class
         {
             return (T)(object)Load(path, typeHint, noCache);
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs
index 87ff3416f72..45ff889656a 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs
@@ -7,27 +7,77 @@ using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 
-// TODO: Add comments describing what this class does. It is not obvious.
-
 namespace Godot
 {
+    /// <summary>
+    /// Godot's global functions.
+    /// </summary>
     public static partial class GD
     {
-        public static object Bytes2Var(byte[] bytes, bool allow_objects = false)
+        /// <summary>
+        /// Decodes a byte array back to a <c>Variant</c> value.
+        /// If <paramref name="allowObjects"/> is <see langword="true"/> decoding objects is allowed.
+        ///
+        /// WARNING: Deserialized object can contain code which gets executed.
+        /// Do not set <paramref name="allowObjects"/> to <see langword="true"/>
+        /// if the serialized object comes from untrusted sources to avoid
+        /// potential security threats (remote code execution).
+        /// </summary>
+        /// <param name="bytes">Byte array that will be decoded to a <c>Variant</c>.</param>
+        /// <param name="allowObjects">If objects should be decoded.</param>
+        /// <returns>The decoded <c>Variant</c>.</returns>
+        public static object Bytes2Var(byte[] bytes, bool allowObjects = false)
         {
-            return godot_icall_GD_bytes2var(bytes, allow_objects);
+            return godot_icall_GD_bytes2var(bytes, allowObjects);
         }
 
+        /// <summary>
+        /// Converts from a <c>Variant</c> type to another in the best way possible.
+        /// The <paramref name="type"/> parameter uses the <see cref="Variant.Type"/> values.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// var a = new Vector2(1, 0);
+        /// // Prints 1
+        /// GD.Print(a.Length());
+        /// var b = GD.Convert(a, Variant.Type.String)
+        /// // Prints 6 as "(1, 0)" is 6 characters
+        /// GD.Print(b.Length);
+        /// </code>
+        /// </example>
+        /// <returns>The <c>Variant</c> converted to the given <paramref name="type"/>.</returns>
         public static object Convert(object what, Variant.Type type)
         {
             return godot_icall_GD_convert(what, type);
         }
 
+        /// <summary>
+        /// Converts from decibels to linear energy (audio).
+        /// </summary>
+        /// <seealso cref="Linear2Db(real_t)"/>
+        /// <param name="db">Decibels to convert.</param>
+        /// <returns>Audio volume as linear energy.</returns>
         public static real_t Db2Linear(real_t db)
         {
             return (real_t)Math.Exp(db * 0.11512925464970228420089957273422);
         }
 
+        /// <summary>
+        /// Returns the result of <paramref name="value"/> decreased by
+        /// <paramref name="step"/> * <paramref name="amount"/>.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// // a = 59;
+        /// // float a = GD.DecTime(60, 10, 0.1f);
+        /// </code>
+        /// </example>
+        /// <param name="value">Value that will be decreased.</param>
+        /// <param name="amount">
+        /// Amount that will be decreased from <paramref name="value"/> for every <paramref name="step"/>.
+        /// </param>
+        /// <param name="step">Times the <paramref name="value"/> will be decreased by <paramref name="amount"/></param>
+        /// <returns>The decreased value.</returns>
         public static real_t DecTime(real_t value, real_t amount, real_t step)
         {
             real_t sgn = Mathf.Sign(value);
@@ -38,6 +88,14 @@ namespace Godot
             return val * sgn;
         }
 
+        /// <summary>
+        /// Get the <see cref="FuncRef"/> that refers to the function
+        /// with the given name <paramref name="funcname"/> in the
+        /// given object <paramref name="instance"/>.
+        /// </summary>
+        /// <param name="instance">The object that contains the function.</param>
+        /// <param name="funcname">The name of the function.</param>
+        /// <returns>A reference to the given object's function.</returns>
         public static FuncRef FuncRef(Object instance, string funcname)
         {
             var ret = new FuncRef();
@@ -56,106 +114,342 @@ namespace Godot
             return Array.ConvertAll(parameters, x => x?.ToString() ?? "null");
         }
 
+        /// <summary>
+        /// Returns the integer hash of the variable passed.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// GD.Print(GD.Hash("a")); // Prints 177670
+        /// </code>
+        /// </example>
+        /// <param name="var">Variable that will be hashed.</param>
+        /// <returns>Hash of the variable passed.</returns>
         public static int Hash(object var)
         {
             return godot_icall_GD_hash(var);
         }
 
+        /// <summary>
+        /// Returns the <see cref="Object"/> that corresponds to <paramref name="instanceId"/>.
+        /// All Objects have a unique instance ID.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// public class MyNode : Node
+        /// {
+        ///     public string foo = "bar";
+        ///
+        ///     public override void _Ready()
+        ///     {
+        ///         ulong id = GetInstanceId();
+        ///         var inst = (MyNode)GD.InstanceFromId(Id);
+        ///         GD.Print(inst.foo); // Prints bar
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        /// <param name="instanceId">Instance ID of the Object to retrieve.</param>
+        /// <returns>The <see cref="Object"/> instance.</returns>
         public static Object InstanceFromId(ulong instanceId)
         {
             return godot_icall_GD_instance_from_id(instanceId);
         }
 
+        /// <summary>
+        /// Converts from linear energy to decibels (audio).
+        /// This can be used to implement volume sliders that behave as expected (since volume isn't linear).
+        /// </summary>
+        /// <seealso cref="Db2Linear(real_t)"/>
+        /// <example>
+        /// <code>
+        /// // "slider" refers to a node that inherits Range such as HSlider or VSlider.
+        /// // Its range must be configured to go from 0 to 1.
+        /// // Change the bus name if you'd like to change the volume of a specific bus only.
+        /// AudioServer.SetBusVolumeDb(AudioServer.GetBusIndex("Master"), GD.Linear2Db(slider.value));
+        /// </code>
+        /// </example>
+        /// <param name="linear">The linear energy to convert.</param>
+        /// <returns>Audio as decibels.</returns>
         public static real_t Linear2Db(real_t linear)
         {
             return (real_t)(Math.Log(linear) * 8.6858896380650365530225783783321);
         }
 
+        /// <summary>
+        /// Loads a resource from the filesystem located at <paramref name="path"/>.
+        /// The resource is loaded on the method call (unless it's referenced already
+        /// elsewhere, e.g. in another script or in the scene), which might cause slight delay,
+        /// especially when loading scenes. To avoid unnecessary delays when loading something
+        /// multiple times, either store the resource in a variable.
+        ///
+        /// Note: Resource paths can be obtained by right-clicking on a resource in the FileSystem
+        /// dock and choosing "Copy Path" or by dragging the file from the FileSystem dock into the script.
+        ///
+        /// Important: The path must be absolute, a local path will just return <see langword="null"/>.
+        /// This method is a simplified version of <see cref="ResourceLoader.Load"/>, which can be used
+        /// for more advanced scenarios.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// // Load a scene called main located in the root of the project directory and cache it in a variable.
+        /// var main = GD.Load("res://main.tscn"); // main will contain a PackedScene resource.
+        /// </code>
+        /// </example>
+        /// <param name="path">Path of the <see cref="Resource"/> to load.</param>
+        /// <returns>The loaded <see cref="Resource"/>.</returns>
         public static Resource Load(string path)
         {
             return ResourceLoader.Load(path);
         }
 
+        /// <summary>
+        /// Loads a resource from the filesystem located at <paramref name="path"/>.
+        /// The resource is loaded on the method call (unless it's referenced already
+        /// elsewhere, e.g. in another script or in the scene), which might cause slight delay,
+        /// especially when loading scenes. To avoid unnecessary delays when loading something
+        /// multiple times, either store the resource in a variable.
+        ///
+        /// Note: Resource paths can be obtained by right-clicking on a resource in the FileSystem
+        /// dock and choosing "Copy Path" or by dragging the file from the FileSystem dock into the script.
+        ///
+        /// Important: The path must be absolute, a local path will just return <see langword="null"/>.
+        /// This method is a simplified version of <see cref="ResourceLoader.Load"/>, which can be used
+        /// for more advanced scenarios.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// // Load a scene called main located in the root of the project directory and cache it in a variable.
+        /// var main = GD.Load&lt;PackedScene&gt;("res://main.tscn"); // main will contain a PackedScene resource.
+        /// </code>
+        /// </example>
+        /// <param name="path">Path of the <see cref="Resource"/> to load.</param>
+        /// <typeparam name="T">The type to cast to. Should be a descendant of <see cref="Resource"/>.</typeparam>
         public static T Load<T>(string path) where T : class
         {
             return ResourceLoader.Load<T>(path);
         }
 
+        /// <summary>
+        /// Pushes an error message to Godot's built-in debugger and to the OS terminal.
+        ///
+        /// Note: Errors printed this way will not pause project execution.
+        /// To print an error message and pause project execution in debug builds,
+        /// use [code]assert(false, "test error")[/code] instead.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// GD.PushError("test_error"); // Prints "test error" to debugger and terminal as error call
+        /// </code>
+        /// </example>
+        /// <param name="message">Error message.</param>
         public static void PushError(string message)
         {
             godot_icall_GD_pusherror(message);
         }
 
+        /// <summary>
+        /// Pushes a warning message to Godot's built-in debugger and to the OS terminal.
+        /// </summary>
+        /// <example>
+        /// GD.PushWarning("test warning"); // Prints "test warning" to debugger and terminal as warning call
+        /// </example>
+        /// <param name="message">Warning message.</param>
         public static void PushWarning(string message)
         {
             godot_icall_GD_pushwarning(message);
         }
 
+        /// <summary>
+        /// Converts one or more arguments of any type to string in the best way possible
+        /// and prints them to the console.
+        ///
+        /// Note: Consider using <see cref="PushError(string)"/> and <see cref="PushWarning(string)"/>
+        /// to print error and warning messages instead of <see cref="Print(object[])"/>.
+        /// This distinguishes them from print messages used for debugging purposes,
+        /// while also displaying a stack trace when an error or warning is printed.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// var a = new int[] { 1, 2, 3 };
+        /// GD.Print("a", "b", a); // Prints ab[1, 2, 3]
+        /// </code>
+        /// </example>
+        /// <param name="what">Arguments that will be printed.</param>
         public static void Print(params object[] what)
         {
             godot_icall_GD_print(GetPrintParams(what));
         }
 
+        /// <summary>
+        /// Prints the current stack trace information to the console.
+        /// </summary>
         public static void PrintStack()
         {
             Print(System.Environment.StackTrace);
         }
 
+        /// <summary>
+        /// Prints one or more arguments to strings in the best way possible to standard error line.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// GD.PrintErr("prints to stderr");
+        /// </code>
+        /// </example>
+        /// <param name="what">Arguments that will be printed.</param>
         public static void PrintErr(params object[] what)
         {
             godot_icall_GD_printerr(GetPrintParams(what));
         }
 
+        /// <summary>
+        /// Prints one or more arguments to strings in the best way possible to console.
+        /// No newline is added at the end.
+        ///
+        /// Note: Due to limitations with Godot's built-in console, this only prints to the terminal.
+        /// If you need to print in the editor, use another method, such as <see cref="Print(object[])"/>.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// GD.PrintRaw("A");
+        /// GD.PrintRaw("B");
+        /// // Prints AB
+        /// </code>
+        /// </example>
+        /// <param name="what">Arguments that will be printed.</param>
         public static void PrintRaw(params object[] what)
         {
             godot_icall_GD_printraw(GetPrintParams(what));
         }
 
+        /// <summary>
+        /// Prints one or more arguments to the console with a space between each argument.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// GD.PrintS("A", "B", "C"); // Prints A B C
+        /// </code>
+        /// </example>
+        /// <param name="what">Arguments that will be printed.</param>
         public static void PrintS(params object[] what)
         {
             godot_icall_GD_prints(GetPrintParams(what));
         }
 
+        /// <summary>
+        /// Prints one or more arguments to the console with a tab between each argument.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// GD.PrintT("A", "B", "C"); // Prints A       B       C
+        /// </code>
+        /// </example>
+        /// <param name="what">Arguments that will be printed.</param>
         public static void PrintT(params object[] what)
         {
             godot_icall_GD_printt(GetPrintParams(what));
         }
 
+        /// <summary>
+        /// Returns a random floating point value between <c>0.0</c> and <c>1.0</c> (inclusive).
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// GD.Randf(); // Returns e.g. 0.375671
+        /// </code>
+        /// </example>
+        /// <returns>A random <see langword="float"/> number.</returns>
         public static float Randf()
         {
             return godot_icall_GD_randf();
         }
 
+        /// <summary>
+        /// Returns a random unsigned 32-bit integer.
+        /// Use remainder to obtain a random value in the interval <c>[0, N - 1]</c> (where N is smaller than 2^32).
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// GD.Randi();           // Returns random integer between 0 and 2^32 - 1
+        /// GD.Randi() % 20;      // Returns random integer between 0 and 19
+        /// GD.Randi() % 100;     // Returns random integer between 0 and 99
+        /// GD.Randi() % 100 + 1; // Returns random integer between 1 and 100
+        /// </code>
+        /// </example>
+        /// <returns>A random <see langword="uint"/> number.</returns>
         public static uint Randi()
         {
             return godot_icall_GD_randi();
         }
 
+        /// <summary>
+        /// Randomizes the seed (or the internal state) of the random number generator.
+        /// Current implementation reseeds using a number based on time.
+        ///
+        /// Note: This method is called automatically when the project is run.
+        /// If you need to fix the seed to have reproducible results, use <see cref="Seed(ulong)"/>
+        /// to initialize the random number generator.
+        /// </summary>
         public static void Randomize()
         {
             godot_icall_GD_randomize();
         }
 
+        /// <summary>
+        /// Returns a random floating point value on the interval between <paramref name="from"/>
+        /// and <paramref name="to"/> (inclusive).
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// GD.PrintS(GD.RandRange(-10.0, 10.0), GD.RandRange(-10.0, 10.0)); // Prints e.g. -3.844535 7.45315
+        /// </code>
+        /// </example>
+        /// <returns>A random <see langword="double"/> number inside the given range.</returns>
         public static double RandRange(double from, double to)
         {
             return godot_icall_GD_rand_range(from, to);
         }
 
+        /// <summary>
+        /// Returns a random unsigned 32-bit integer, using the given <paramref name="seed"/>.
+        /// The <paramref name="newSeed"/> will return the new seed.
+        /// </summary>
+        /// <param name="seed">Seed to use to generate the random number.</param>
+        /// <param name="newSeed">Seed used by the random number generator.</param>
+        /// <returns>A random <see langword="uint"/> number.</returns>
         public static uint RandSeed(ulong seed, out ulong newSeed)
         {
             return godot_icall_GD_rand_seed(seed, out newSeed);
         }
 
+        /// <summary>
+        /// Returns a <see cref="IEnumerable{T}"/> that iterates from
+        /// <c>0</c> to <paramref name="end"/> in steps of <c>1</c>.
+        /// </summary>
+        /// <param name="end">The last index.</param>
         public static IEnumerable<int> Range(int end)
         {
             return Range(0, end, 1);
         }
 
+        /// <summary>
+        /// Returns a <see cref="IEnumerable{T}"/> that iterates from
+        /// <paramref name="start"/> to <paramref name="end"/> in steps of <c>1</c>.
+        /// </summary>
+        /// <param name="start">The first index.</param>
+        /// <param name="end">The last index.</param>
         public static IEnumerable<int> Range(int start, int end)
         {
             return Range(start, end, 1);
         }
 
+        /// <summary>
+        /// Returns a <see cref="IEnumerable{T}"/> that iterates from
+        /// <paramref name="start"/> to <paramref name="end"/> in steps of <paramref name="step"/>.
+        /// </summary>
+        /// <param name="start">The first index.</param>
+        /// <param name="end">The last index.</param>
+        /// <param name="step">The amount by which to increment the index on each iteration.</param>
         public static IEnumerable<int> Range(int start, int end, int step)
         {
             if (end < start && step > 0)
@@ -176,31 +470,82 @@ namespace Godot
             }
         }
 
+        /// <summary>
+        /// Sets seed for the random number generator.
+        /// </summary>
+        /// <param name="seed">Seed that will be used.</param>
         public static void Seed(ulong seed)
         {
             godot_icall_GD_seed(seed);
         }
 
+        /// <summary>
+        /// Converts one or more arguments of any type to string in the best way possible.
+        /// </summary>
+        /// <param name="what">Arguments that will converted to string.</param>
+        /// <returns>The string formed by the given arguments.</returns>
         public static string Str(params object[] what)
         {
             return godot_icall_GD_str(what);
         }
 
+        /// <summary>
+        /// Converts a formatted string that was returned by <see cref="Var2Str(object)"/> to the original value.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// string a = "{\"a\": 1, \"b\": 2 }";
+        /// var b = (Godot.Collections.Dictionary)GD.Str2Var(a);
+        /// GD.Print(b["a"]); // Prints 1
+        /// </code>
+        /// </example>
+        /// <param name="str">String that will be converted to Variant.</param>
+        /// <returns>The decoded <c>Variant</c>.</returns>
         public static object Str2Var(string str)
         {
             return godot_icall_GD_str2var(str);
         }
 
+        /// <summary>
+        /// Returns whether the given class exists in <see cref="ClassDB"/>.
+        /// </summary>
+        /// <returns>If the class exists in <see cref="ClassDB"/>.</returns>
         public static bool TypeExists(string type)
         {
             return godot_icall_GD_type_exists(type);
         }
 
-        public static byte[] Var2Bytes(object var, bool full_objects = false)
+        /// <summary>
+        /// Encodes a <c>Variant</c> value to a byte array.
+        /// If <paramref name="fullObjects"/> is <see langword="true"/> encoding objects is allowed
+        /// (and can potentially include code).
+        /// Deserialization can be done with <see cref="Bytes2Var(byte[], bool)"/>.
+        /// </summary>
+        /// <param name="var">Variant that will be encoded.</param>
+        /// <param name="fullObjects">If objects should be serialized.</param>
+        /// <returns>The <c>Variant</c> encoded as an array of bytes.</returns>
+        public static byte[] Var2Bytes(object var, bool fullObjects = false)
         {
-            return godot_icall_GD_var2bytes(var, full_objects);
+            return godot_icall_GD_var2bytes(var, fullObjects);
         }
 
+        /// <summary>
+        /// Converts a <c>Variant</c> <paramref name="var"/> to a formatted string that
+        /// can later be parsed using <see cref="Str2Var(string)"/>.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// var a = new Godot.Collections.Dictionary { ["a"] = 1, ["b"] = 2 };
+        /// GD.Print(GD.Var2Str(a));
+        /// // Prints
+        /// // {
+        /// //    "a": 1,
+        /// //    "b": 2
+        /// // }
+        /// </code>
+        /// </example>
+        /// <param name="var">Variant that will be converted to string.</param>
+        /// <returns>The <c>Variant</c> encoded as a string.</returns>
         public static string Var2Str(object var)
         {
             return godot_icall_GD_var2str(var);
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/MarshalUtils.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/MarshalUtils.cs
index f508211f686..80bda4e2f5f 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/MarshalUtils.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/MarshalUtils.cs
@@ -7,56 +7,131 @@ namespace Godot
     {
         /// <summary>
         /// Returns <see langword="true"/> if the generic type definition of <paramref name="type"/>
-        /// is <see cref="Godot.Collections.Array{T}"/>; otherwise returns <see langword="false"/>.
+        /// is <see cref="Collections.Array{T}"/>; otherwise returns <see langword="false"/>.
         /// </summary>
-        /// <exception cref="System.InvalidOperationException">
-        /// <paramref name="type"/> is not a generic type. That is, IsGenericType returns false.
+        /// <exception cref="InvalidOperationException">
+        /// Thrown when the given <paramref name="type"/> is not a generic type.
+        /// That is, <see cref="Type.IsGenericType"/> returns <see langword="false"/>.
         /// </exception>
-        static bool TypeIsGenericArray(Type type) =>
-            type.GetGenericTypeDefinition() == typeof(Godot.Collections.Array<>);
+        private static bool TypeIsGenericArray(Type type) =>
+            type.GetGenericTypeDefinition() == typeof(Collections.Array<>);
 
         /// <summary>
         /// Returns <see langword="true"/> if the generic type definition of <paramref name="type"/>
-        /// is <see cref="Godot.Collections.Dictionary{TKey, TValue}"/>; otherwise returns <see langword="false"/>.
+        /// is <see cref="Collections.Dictionary{TKey, TValue}"/>; otherwise returns <see langword="false"/>.
         /// </summary>
-        /// <exception cref="System.InvalidOperationException">
-        /// <paramref name="type"/> is not a generic type. That is, IsGenericType returns false.
+        /// <exception cref="InvalidOperationException">
+        /// Thrown when the given <paramref name="type"/> is not a generic type.
+        /// That is, <see cref="Type.IsGenericType"/> returns <see langword="false"/>.
         /// </exception>
-        static bool TypeIsGenericDictionary(Type type) =>
-            type.GetGenericTypeDefinition() == typeof(Godot.Collections.Dictionary<,>);
+        private static bool TypeIsGenericDictionary(Type type) =>
+            type.GetGenericTypeDefinition() == typeof(Collections.Dictionary<,>);
 
-        static bool TypeIsSystemGenericList(Type type) =>
-            type.GetGenericTypeDefinition() == typeof(System.Collections.Generic.List<>);
+        /// <summary>
+        /// Returns <see langword="true"/> if the generic type definition of <paramref name="type"/>
+        /// is <see cref="List{T}"/>; otherwise returns <see langword="false"/>.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        /// Thrown when the given <paramref name="type"/> is not a generic type.
+        /// That is, <see cref="Type.IsGenericType"/> returns <see langword="false"/>.
+        /// </exception>
+        private static bool TypeIsSystemGenericList(Type type) =>
+            type.GetGenericTypeDefinition() == typeof(List<>);
 
-        static bool TypeIsSystemGenericDictionary(Type type) =>
-            type.GetGenericTypeDefinition() == typeof(System.Collections.Generic.Dictionary<,>);
+        /// <summary>
+        /// Returns <see langword="true"/> if the generic type definition of <paramref name="type"/>
+        /// is <see cref="Dictionary{TKey, TValue}"/>; otherwise returns <see langword="false"/>.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        /// Thrown when the given <paramref name="type"/> is not a generic type.
+        /// That is, <see cref="Type.IsGenericType"/> returns <see langword="false"/>.
+        /// </exception>
+        private static bool TypeIsSystemGenericDictionary(Type type) =>
+            type.GetGenericTypeDefinition() == typeof(Dictionary<,>);
 
-        static bool TypeIsGenericIEnumerable(Type type) => type.GetGenericTypeDefinition() == typeof(IEnumerable<>);
+        /// <summary>
+        /// Returns <see langword="true"/> if the generic type definition of <paramref name="type"/>
+        /// is <see cref="IEnumerable{T}"/>; otherwise returns <see langword="false"/>.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        /// Thrown when the given <paramref name="type"/> is not a generic type.
+        /// That is, <see cref="Type.IsGenericType"/> returns <see langword="false"/>.
+        /// </exception>
+        private static bool TypeIsGenericIEnumerable(Type type) => type.GetGenericTypeDefinition() == typeof(IEnumerable<>);
 
-        static bool TypeIsGenericICollection(Type type) => type.GetGenericTypeDefinition() == typeof(ICollection<>);
+        /// <summary>
+        /// Returns <see langword="true"/> if the generic type definition of <paramref name="type"/>
+        /// is <see cref="ICollection{T}"/>; otherwise returns <see langword="false"/>.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        /// Thrown when the given <paramref name="type"/> is not a generic type.
+        /// That is, <see cref="Type.IsGenericType"/> returns <see langword="false"/>.
+        /// </exception>
+        private static bool TypeIsGenericICollection(Type type) => type.GetGenericTypeDefinition() == typeof(ICollection<>);
 
-        static bool TypeIsGenericIDictionary(Type type) => type.GetGenericTypeDefinition() == typeof(IDictionary<,>);
+        /// <summary>
+        /// Returns <see langword="true"/> if the generic type definition of <paramref name="type"/>
+        /// is <see cref="IDictionary{TKey, TValue}"/>; otherwise returns <see langword="false"/>.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        /// Thrown when the given <paramref name="type"/> is not a generic type.
+        /// That is, <see cref="Type.IsGenericType"/> returns <see langword="false"/>.
+        /// </exception>
+        private static bool TypeIsGenericIDictionary(Type type) => type.GetGenericTypeDefinition() == typeof(IDictionary<,>);
 
-        static void ArrayGetElementType(Type arrayType, out Type elementType)
+        /// <summary>
+        /// Gets the element type for the given <paramref name="arrayType"/>.
+        /// </summary>
+        /// <param name="arrayType">Type for the generic array.</param>
+        /// <param name="elementType">Element type for the generic array.</param>
+        /// <exception cref="InvalidOperationException">
+        /// Thrown when the given <paramref name="arrayType"/> is not a generic type.
+        /// That is, <see cref="Type.IsGenericType"/> returns <see langword="false"/>.
+        /// </exception>
+        private static void ArrayGetElementType(Type arrayType, out Type elementType)
         {
             elementType = arrayType.GetGenericArguments()[0];
         }
 
-        static void DictionaryGetKeyValueTypes(Type dictionaryType, out Type keyType, out Type valueType)
+        /// <summary>
+        /// Gets the key type and the value type for the given <paramref name="dictionaryType"/>.
+        /// </summary>
+        /// <param name="dictionaryType">The type for the generic dictionary.</param>
+        /// <param name="keyType">Key type for the generic dictionary.</param>
+        /// <param name="valueType">Value type for the generic dictionary.</param>
+        /// <exception cref="InvalidOperationException">
+        /// Thrown when the given <paramref name="dictionaryType"/> is not a generic type.
+        /// That is, <see cref="Type.IsGenericType"/> returns <see langword="false"/>.
+        /// </exception>
+        private static void DictionaryGetKeyValueTypes(Type dictionaryType, out Type keyType, out Type valueType)
         {
             var genericArgs = dictionaryType.GetGenericArguments();
             keyType = genericArgs[0];
             valueType = genericArgs[1];
         }
 
-        static Type MakeGenericArrayType(Type elemType)
+        /// <summary>
+        /// Constructs a new <see cref="Type"/> from <see cref="Collections.Array{T}"/>
+        /// where the generic type for the elements is <paramref name="elemType"/>.
+        /// </summary>
+        /// <param name="elemType">Element type for the array.</param>
+        /// <returns>The generic array type with the specified element type.</returns>
+        private static Type MakeGenericArrayType(Type elemType)
         {
-            return typeof(Godot.Collections.Array<>).MakeGenericType(elemType);
+            return typeof(Collections.Array<>).MakeGenericType(elemType);
         }
 
-        static Type MakeGenericDictionaryType(Type keyType, Type valueType)
+        /// <summary>
+        /// Constructs a new <see cref="Type"/> from <see cref="Collections.Dictionary{TKey, TValue}"/>
+        /// where the generic type for the keys is <paramref name="keyType"/> and
+        /// for the values is <paramref name="valueType"/>.
+        /// </summary>
+        /// <param name="keyType">Key type for the dictionary.</param>
+        /// <param name="valueType">Key type for the dictionary.</param>
+        /// <returns>The generic dictionary type with the specified key and value types.</returns>
+        private static Type MakeGenericDictionaryType(Type keyType, Type valueType)
         {
-            return typeof(Godot.Collections.Dictionary<,>).MakeGenericType(keyType, valueType);
+            return typeof(Collections.Dictionary<,>).MakeGenericType(keyType, valueType);
         }
     }
 }
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Mathf.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Mathf.cs
index 0ba3849da6a..149de412159 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Mathf.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Mathf.cs
@@ -7,6 +7,9 @@ using System;
 
 namespace Godot
 {
+    /// <summary>
+    /// Provides constants and static methods for common mathematical functions.
+    /// </summary>
     public static partial class Mathf
     {
         // Define constants with Decimal precision and cast down to double or float.
@@ -19,18 +22,18 @@ namespace Godot
 
         /// <summary>
         /// Constant that represents how many times the diameter of a circle
-        /// fits around its perimeter. This is equivalent to `Mathf.Tau / 2`.
+        /// fits around its perimeter. This is equivalent to <c>Mathf.Tau / 2</c>.
         /// </summary>
         // 3.1415927f and 3.14159265358979
         public const real_t Pi = (real_t)3.1415926535897932384626433833M;
 
         /// <summary>
-        /// Positive infinity. For negative infinity, use `-Mathf.Inf`.
+        /// Positive infinity. For negative infinity, use <c>-Mathf.Inf</c>.
         /// </summary>
         public const real_t Inf = real_t.PositiveInfinity;
 
         /// <summary>
-        /// "Not a Number", an invalid value. `NaN` has special properties, including
+        /// "Not a Number", an invalid value. <c>NaN</c> has special properties, including
         /// that it is not equal to itself. It is output by some invalid operations,
         /// such as dividing zero by zero.
         /// </summary>
@@ -42,68 +45,79 @@ namespace Godot
         private const real_t Rad2DegConst = (real_t)57.295779513082320876798154814M;
 
         /// <summary>
-        /// Returns the absolute value of `s` (i.e. positive value).
+        /// Returns the absolute value of <paramref name="s"/> (i.e. positive value).
         /// </summary>
         /// <param name="s">The input number.</param>
-        /// <returns>The absolute value of `s`.</returns>
+        /// <returns>The absolute value of <paramref name="s"/>.</returns>
         public static int Abs(int s)
         {
             return Math.Abs(s);
         }
 
         /// <summary>
-        /// Returns the absolute value of `s` (i.e. positive value).
+        /// Returns the absolute value of <paramref name="s"/> (i.e. positive value).
         /// </summary>
         /// <param name="s">The input number.</param>
-        /// <returns>The absolute value of `s`.</returns>
+        /// <returns>The absolute value of <paramref name="s"/>.</returns>
         public static real_t Abs(real_t s)
         {
             return Math.Abs(s);
         }
 
         /// <summary>
-        /// Returns the arc cosine of `s` in radians. Use to get the angle of cosine s.
+        /// Returns the arc cosine of <paramref name="s"/> in radians.
+        /// Use to get the angle of cosine <paramref name="s"/>.
         /// </summary>
         /// <param name="s">The input cosine value. Must be on the range of -1.0 to 1.0.</param>
-        /// <returns>An angle that would result in the given cosine value. On the range `0` to `Tau/2`.</returns>
+        /// <returns>
+        /// An angle that would result in the given cosine value. On the range <c>0</c> to <c>Tau/2</c>.
+        /// </returns>
         public static real_t Acos(real_t s)
         {
             return (real_t)Math.Acos(s);
         }
 
         /// <summary>
-        /// Returns the arc sine of `s` in radians. Use to get the angle of sine s.
+        /// Returns the arc sine of <paramref name="s"/> in radians.
+        /// Use to get the angle of sine <paramref name="s"/>.
         /// </summary>
         /// <param name="s">The input sine value. Must be on the range of -1.0 to 1.0.</param>
-        /// <returns>An angle that would result in the given sine value. On the range `-Tau/4` to `Tau/4`.</returns>
+        /// <returns>
+        /// An angle that would result in the given sine value. On the range <c>-Tau/4</c> to <c>Tau/4</c>.
+        /// </returns>
         public static real_t Asin(real_t s)
         {
             return (real_t)Math.Asin(s);
         }
 
         /// <summary>
-        /// Returns the arc tangent of `s` in radians. Use to get the angle of tangent s.
+        /// Returns the arc tangent of <paramref name="s"/> in radians.
+        /// Use to get the angle of tangent <paramref name="s"/>.
         ///
         /// The method cannot know in which quadrant the angle should fall.
-        /// See <see cref="Atan2(real_t, real_t)"/> if you have both `y` and `x`.
+        /// See <see cref="Atan2(real_t, real_t)"/> if you have both <c>y</c> and <c>x</c>.
         /// </summary>
         /// <param name="s">The input tangent value.</param>
-        /// <returns>An angle that would result in the given tangent value. On the range `-Tau/4` to `Tau/4`.</returns>
+        /// <returns>
+        /// An angle that would result in the given tangent value. On the range <c>-Tau/4</c> to <c>Tau/4</c>.
+        /// </returns>
         public static real_t Atan(real_t s)
         {
             return (real_t)Math.Atan(s);
         }
 
         /// <summary>
-        /// Returns the arc tangent of `y` and `x` in radians. Use to get the angle
-        /// of the tangent of `y/x`. To compute the value, the method takes into
+        /// Returns the arc tangent of <paramref name="y"/> and <paramref name="x"/> in radians.
+        /// Use to get the angle of the tangent of <c>y/x</c>. To compute the value, the method takes into
         /// account the sign of both arguments in order to determine the quadrant.
         ///
         /// Important note: The Y coordinate comes first, by convention.
         /// </summary>
         /// <param name="y">The Y coordinate of the point to find the angle to.</param>
         /// <param name="x">The X coordinate of the point to find the angle to.</param>
-        /// <returns>An angle that would result in the given tangent value. On the range `-Tau/2` to `Tau/2`.</returns>
+        /// <returns>
+        /// An angle that would result in the given tangent value. On the range <c>-Tau/2</c> to <c>Tau/2</c>.
+        /// </returns>
         public static real_t Atan2(real_t y, real_t x)
         {
             return (real_t)Math.Atan2(y, x);
@@ -123,17 +137,18 @@ namespace Godot
         }
 
         /// <summary>
-        /// Rounds `s` upward (towards positive infinity).
+        /// Rounds <paramref name="s"/> upward (towards positive infinity).
         /// </summary>
         /// <param name="s">The number to ceil.</param>
-        /// <returns>The smallest whole number that is not less than `s`.</returns>
+        /// <returns>The smallest whole number that is not less than <paramref name="s"/>.</returns>
         public static real_t Ceil(real_t s)
         {
             return (real_t)Math.Ceiling(s);
         }
 
         /// <summary>
-        /// Clamps a `value` so that it is not less than `min` and not more than `max`.
+        /// Clamps a <paramref name="value"/> so that it is not less than <paramref name="min"/>
+        /// and not more than <paramref name="max"/>.
         /// </summary>
         /// <param name="value">The value to clamp.</param>
         /// <param name="min">The minimum allowed value.</param>
@@ -145,7 +160,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Clamps a `value` so that it is not less than `min` and not more than `max`.
+        /// Clamps a <paramref name="value"/> so that it is not less than <paramref name="min"/>
+        /// and not more than <paramref name="max"/>.
         /// </summary>
         /// <param name="value">The value to clamp.</param>
         /// <param name="min">The minimum allowed value.</param>
@@ -157,7 +173,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the cosine of angle `s` in radians.
+        /// Returns the cosine of angle <paramref name="s"/> in radians.
         /// </summary>
         /// <param name="s">The angle in radians.</param>
         /// <returns>The cosine of that angle.</returns>
@@ -167,7 +183,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the hyperbolic cosine of angle `s` in radians.
+        /// Returns the hyperbolic cosine of angle <paramref name="s"/> in radians.
         /// </summary>
         /// <param name="s">The angle in radians.</param>
         /// <returns>The hyperbolic cosine of that angle.</returns>
@@ -187,12 +203,14 @@ namespace Godot
         }
 
         /// <summary>
-        /// Easing function, based on exponent. The curve values are:
-        /// `0` is constant, `1` is linear, `0` to `1` is ease-in, `1` or more is ease-out.
+        /// Easing function, based on exponent. The <paramref name="curve"/> values are:
+        /// <c>0</c> is constant, <c>1</c> is linear, <c>0</c> to <c>1</c> is ease-in, <c>1</c> or more is ease-out.
         /// Negative values are in-out/out-in.
         /// </summary>
         /// <param name="s">The value to ease.</param>
-        /// <param name="curve">`0` is constant, `1` is linear, `0` to `1` is ease-in, `1` or more is ease-out.</param>
+        /// <param name="curve">
+        /// <c>0</c> is constant, <c>1</c> is linear, <c>0</c> to <c>1</c> is ease-in, <c>1</c> or more is ease-out.
+        /// </param>
         /// <returns>The eased value.</returns>
         public static real_t Ease(real_t s, real_t curve)
         {
@@ -230,20 +248,20 @@ namespace Godot
 
         /// <summary>
         /// The natural exponential function. It raises the mathematical
-        /// constant `e` to the power of `s` and returns it.
+        /// constant <c>e</c> to the power of <paramref name="s"/> and returns it.
         /// </summary>
-        /// <param name="s">The exponent to raise `e` to.</param>
-        /// <returns>`e` raised to the power of `s`.</returns>
+        /// <param name="s">The exponent to raise <c>e</c> to.</param>
+        /// <returns><c>e</c> raised to the power of <paramref name="s"/>.</returns>
         public static real_t Exp(real_t s)
         {
             return (real_t)Math.Exp(s);
         }
 
         /// <summary>
-        /// Rounds `s` downward (towards negative infinity).
+        /// Rounds <paramref name="s"/> downward (towards negative infinity).
         /// </summary>
         /// <param name="s">The number to floor.</param>
-        /// <returns>The largest whole number that is not more than `s`.</returns>
+        /// <returns>The largest whole number that is not more than <paramref name="s"/>.</returns>
         public static real_t Floor(real_t s)
         {
             return (real_t)Math.Floor(s);
@@ -263,12 +281,13 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if `a` and `b` are approximately equal to each other.
+        /// Returns <see langword="true"/> if <paramref name="a"/> and <paramref name="b"/> are approximately equal
+        /// to each other.
         /// The comparison is done using a tolerance calculation with <see cref="Epsilon"/>.
         /// </summary>
         /// <param name="a">One of the values.</param>
         /// <param name="b">The other value.</param>
-        /// <returns>A bool for whether or not the two values are approximately equal.</returns>
+        /// <returns>A <see langword="bool"/> for whether or not the two values are approximately equal.</returns>
         public static bool IsEqualApprox(real_t a, real_t b)
         {
             // Check for exact equality first, required to handle "infinity" values.
@@ -286,33 +305,33 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns whether `s` is an infinity value (either positive infinity or negative infinity).
+        /// Returns whether <paramref name="s"/> is an infinity value (either positive infinity or negative infinity).
         /// </summary>
         /// <param name="s">The value to check.</param>
-        /// <returns>A bool for whether or not the value is an infinity value.</returns>
+        /// <returns>A <see langword="bool"/> for whether or not the value is an infinity value.</returns>
         public static bool IsInf(real_t s)
         {
             return real_t.IsInfinity(s);
         }
 
         /// <summary>
-        /// Returns whether `s` is a `NaN` ("Not a Number" or invalid) value.
+        /// Returns whether <paramref name="s"/> is a <c>NaN</c> ("Not a Number" or invalid) value.
         /// </summary>
         /// <param name="s">The value to check.</param>
-        /// <returns>A bool for whether or not the value is a `NaN` value.</returns>
+        /// <returns>A <see langword="bool"/> for whether or not the value is a <c>NaN</c> value.</returns>
         public static bool IsNaN(real_t s)
         {
             return real_t.IsNaN(s);
         }
 
         /// <summary>
-        /// Returns true if `s` is approximately zero.
+        /// Returns <see langword="true"/> if <paramref name="s"/> is approximately zero.
         /// The comparison is done using a tolerance calculation with <see cref="Epsilon"/>.
         ///
         /// This method is faster than using <see cref="IsEqualApprox(real_t, real_t)"/> with one value as zero.
         /// </summary>
         /// <param name="s">The value to check.</param>
-        /// <returns>A bool for whether or not the value is nearly zero.</returns>
+        /// <returns>A <see langword="bool"/> for whether or not the value is nearly zero.</returns>
         public static bool IsZeroApprox(real_t s)
         {
             return Abs(s) < Epsilon;
@@ -354,7 +373,7 @@ namespace Godot
         /// Note: This is not the same as the "log" function on most calculators, which uses a base 10 logarithm.
         /// </summary>
         /// <param name="s">The input value.</param>
-        /// <returns>The natural log of `s`.</returns>
+        /// <returns>The natural log of <paramref name="s"/>.</returns>
         public static real_t Log(real_t s)
         {
             return (real_t)Math.Log(s);
@@ -405,9 +424,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Moves `from` toward `to` by the `delta` value.
+        /// Moves <paramref name="from"/> toward <paramref name="to"/> by the <paramref name="delta"/> value.
         ///
-        /// Use a negative delta value to move away.
+        /// Use a negative <paramref name="delta"/> value to move away.
         /// </summary>
         /// <param name="from">The start value.</param>
         /// <param name="to">The value to move towards.</param>
@@ -419,7 +438,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the nearest larger power of 2 for the integer `value`.
+        /// Returns the nearest larger power of 2 for the integer <paramref name="value"/>.
         /// </summary>
         /// <param name="value">The input value.</param>
         /// <returns>The nearest larger power of 2.</returns>
@@ -437,8 +456,9 @@ namespace Godot
 
         /// <summary>
         /// Converts a 2D point expressed in the polar coordinate
-        /// system (a distance from the origin `r` and an angle `th`)
-        /// to the cartesian coordinate system (X and Y axis).
+        /// system (a distance from the origin <paramref name="r"/>
+        /// and an angle <paramref name="th"/>) to the cartesian
+        /// coordinate system (X and Y axis).
         /// </summary>
         /// <param name="r">The distance from the origin.</param>
         /// <param name="th">The angle of the point.</param>
@@ -449,10 +469,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Performs a canonical Modulus operation, where the output is on the range `[0, b)`.
+        /// Performs a canonical Modulus operation, where the output is on the range [0, <paramref name="b"/>).
         /// </summary>
         /// <param name="a">The dividend, the primary input.</param>
-        /// <param name="b">The divisor. The output is on the range `[0, b)`.</param>
+        /// <param name="b">The divisor. The output is on the range [0, <paramref name="b"/>).</param>
         /// <returns>The resulting output.</returns>
         public static int PosMod(int a, int b)
         {
@@ -465,10 +485,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Performs a canonical Modulus operation, where the output is on the range `[0, b)`.
+        /// Performs a canonical Modulus operation, where the output is on the range [0, <paramref name="b"/>).
         /// </summary>
         /// <param name="a">The dividend, the primary input.</param>
-        /// <param name="b">The divisor. The output is on the range `[0, b)`.</param>
+        /// <param name="b">The divisor. The output is on the range [0, <paramref name="b"/>).</param>
         /// <returns>The resulting output.</returns>
         public static real_t PosMod(real_t a, real_t b)
         {
@@ -481,11 +501,11 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the result of `x` raised to the power of `y`.
+        /// Returns the result of <paramref name="x"/> raised to the power of <paramref name="y"/>.
         /// </summary>
         /// <param name="x">The base.</param>
         /// <param name="y">The exponent.</param>
-        /// <returns>`x` raised to the power of `y`.</returns>
+        /// <returns><paramref name="x"/> raised to the power of <paramref name="y"/>.</returns>
         public static real_t Pow(real_t x, real_t y)
         {
             return (real_t)Math.Pow(x, y);
@@ -502,7 +522,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Rounds `s` to the nearest whole number,
+        /// Rounds <paramref name="s"/> to the nearest whole number,
         /// with halfway cases rounded towards the nearest multiple of two.
         /// </summary>
         /// <param name="s">The number to round.</param>
@@ -513,10 +533,11 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the sign of `s`: `-1` or `1`. Returns `0` if `s` is `0`.
+        /// Returns the sign of <paramref name="s"/>: <c>-1</c> or <c>1</c>.
+        /// Returns <c>0</c> if <paramref name="s"/> is <c>0</c>.
         /// </summary>
         /// <param name="s">The input number.</param>
-        /// <returns>One of three possible values: `1`, `-1`, or `0`.</returns>
+        /// <returns>One of three possible values: <c>1</c>, <c>-1</c>, or <c>0</c>.</returns>
         public static int Sign(int s)
         {
             if (s == 0)
@@ -525,10 +546,11 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the sign of `s`: `-1` or `1`. Returns `0` if `s` is `0`.
+        /// Returns the sign of <paramref name="s"/>: <c>-1</c> or <c>1</c>.
+        /// Returns <c>0</c> if <paramref name="s"/> is <c>0</c>.
         /// </summary>
         /// <param name="s">The input number.</param>
-        /// <returns>One of three possible values: `1`, `-1`, or `0`.</returns>
+        /// <returns>One of three possible values: <c>1</c>, <c>-1</c>, or <c>0</c>.</returns>
         public static int Sign(real_t s)
         {
             if (s == 0)
@@ -537,7 +559,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the sine of angle `s` in radians.
+        /// Returns the sine of angle <paramref name="s"/> in radians.
         /// </summary>
         /// <param name="s">The angle in radians.</param>
         /// <returns>The sine of that angle.</returns>
@@ -547,7 +569,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the hyperbolic sine of angle `s` in radians.
+        /// Returns the hyperbolic sine of angle <paramref name="s"/> in radians.
         /// </summary>
         /// <param name="s">The angle in radians.</param>
         /// <returns>The hyperbolic sine of that angle.</returns>
@@ -557,8 +579,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a number smoothly interpolated between `from` and `to`,
-        /// based on the `weight`. Similar to <see cref="Lerp(real_t, real_t, real_t)"/>,
+        /// Returns a number smoothly interpolated between <paramref name="from"/> and <paramref name="to"/>,
+        /// based on the <paramref name="weight"/>. Similar to <see cref="Lerp(real_t, real_t, real_t)"/>,
         /// but interpolates faster at the beginning and slower at the end.
         /// </summary>
         /// <param name="from">The start value for interpolation.</param>
@@ -576,12 +598,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the square root of `s`, where `s` is a non-negative number.
+        /// Returns the square root of <paramref name="s"/>, where <paramref name="s"/> is a non-negative number.
         ///
-        /// If you need negative inputs, use `System.Numerics.Complex`.
+        /// If you need negative inputs, use <see cref="System.Numerics.Complex"/>.
         /// </summary>
         /// <param name="s">The input number. Must not be negative.</param>
-        /// <returns>The square root of `s`.</returns>
+        /// <returns>The square root of <paramref name="s"/>.</returns>
         public static real_t Sqrt(real_t s)
         {
             return (real_t)Math.Sqrt(s);
@@ -620,9 +642,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Snaps float value `s` to a given `step`.
-        /// This can also be used to round a floating point
-        /// number to an arbitrary number of decimals.
+        /// Snaps float value <paramref name="s"/> to a given <paramref name="step"/>.
+        /// This can also be used to round a floating point number to an arbitrary number of decimals.
         /// </summary>
         /// <param name="s">The value to stepify.</param>
         /// <param name="step">The step size to snap to.</param>
@@ -638,7 +659,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the tangent of angle `s` in radians.
+        /// Returns the tangent of angle <paramref name="s"/> in radians.
         /// </summary>
         /// <param name="s">The angle in radians.</param>
         /// <returns>The tangent of that angle.</returns>
@@ -648,7 +669,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the hyperbolic tangent of angle `s` in radians.
+        /// Returns the hyperbolic tangent of angle <paramref name="s"/> in radians.
         /// </summary>
         /// <param name="s">The angle in radians.</param>
         /// <returns>The hyperbolic tangent of that angle.</returns>
@@ -658,8 +679,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Wraps `value` between `min` and `max`. Usable for creating loop-alike
-        /// behavior or infinite surfaces. If `min` is `0`, this is equivalent
+        /// Wraps <paramref name="value"/> between <paramref name="min"/> and <paramref name="max"/>.
+        /// Usable for creating loop-alike behavior or infinite surfaces.
+        /// If <paramref name="min"/> is <c>0</c>, this is equivalent
         /// to <see cref="PosMod(int, int)"/>, so prefer using that instead.
         /// </summary>
         /// <param name="value">The value to wrap.</param>
@@ -673,8 +695,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Wraps `value` between `min` and `max`. Usable for creating loop-alike
-        /// behavior or infinite surfaces. If `min` is `0`, this is equivalent
+        /// Wraps <paramref name="value"/> between <paramref name="min"/> and <paramref name="max"/>.
+        /// Usable for creating loop-alike behavior or infinite surfaces.
+        /// If <paramref name="min"/> is <c>0</c>, this is equivalent
         /// to <see cref="PosMod(real_t, real_t)"/>, so prefer using that instead.
         /// </summary>
         /// <param name="value">The value to wrap.</param>
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/MathfEx.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/MathfEx.cs
index 0888e33090d..9bb73ce7dd1 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/MathfEx.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/MathfEx.cs
@@ -12,7 +12,7 @@ namespace Godot
         // Define constants with Decimal precision and cast down to double or float.
 
         /// <summary>
-        /// The natural number `e`.
+        /// The natural number <c>e</c>.
         /// </summary>
         public const real_t E = (real_t)2.7182818284590452353602874714M; // 2.7182817f and 2.718281828459045
 
@@ -23,7 +23,7 @@ namespace Godot
 
         /// <summary>
         /// A very small number used for float comparison with error tolerance.
-        /// 1e-06 with single-precision floats, but 1e-14 if `REAL_T_IS_DOUBLE`.
+        /// 1e-06 with single-precision floats, but 1e-14 if <c>REAL_T_IS_DOUBLE</c>.
         /// </summary>
 #if REAL_T_IS_DOUBLE
         public const real_t Epsilon = 1e-14; // Epsilon size should depend on the precision used.
@@ -44,7 +44,7 @@ namespace Godot
         /// <summary>
         /// Returns the amount of digits after the decimal place.
         /// </summary>
-        /// <param name="s">The input <see cref="System.Decimal"/> value.</param>
+        /// <param name="s">The input <see cref="decimal"/> value.</param>
         /// <returns>The amount of digits.</returns>
         public static int DecimalCount(decimal s)
         {
@@ -52,48 +52,51 @@ namespace Godot
         }
 
         /// <summary>
-        /// Rounds `s` upward (towards positive infinity).
+        /// Rounds <paramref name="s"/> upward (towards positive infinity).
         ///
-        /// This is the same as <see cref="Ceil(real_t)"/>, but returns an `int`.
+        /// This is the same as <see cref="Ceil(real_t)"/>, but returns an <c>int</c>.
         /// </summary>
         /// <param name="s">The number to ceil.</param>
-        /// <returns>The smallest whole number that is not less than `s`.</returns>
+        /// <returns>The smallest whole number that is not less than <paramref name="s"/>.</returns>
         public static int CeilToInt(real_t s)
         {
             return (int)Math.Ceiling(s);
         }
 
         /// <summary>
-        /// Rounds `s` downward (towards negative infinity).
+        /// Rounds <paramref name="s"/> downward (towards negative infinity).
         ///
-        /// This is the same as <see cref="Floor(real_t)"/>, but returns an `int`.
+        /// This is the same as <see cref="Floor(real_t)"/>, but returns an <c>int</c>.
         /// </summary>
         /// <param name="s">The number to floor.</param>
-        /// <returns>The largest whole number that is not more than `s`.</returns>
+        /// <returns>The largest whole number that is not more than <paramref name="s"/>.</returns>
         public static int FloorToInt(real_t s)
         {
             return (int)Math.Floor(s);
         }
 
         /// <summary>
+        /// Rounds <paramref name="s"/> to the nearest whole number.
         ///
+        /// This is the same as <see cref="Round(real_t)"/>, but returns an <c>int</c>.
         /// </summary>
-        /// <param name="s"></param>
-        /// <returns></returns>
+        /// <param name="s">The number to round.</param>
+        /// <returns>The rounded number.</returns>
         public static int RoundToInt(real_t s)
         {
             return (int)Math.Round(s);
         }
 
         /// <summary>
-        /// Returns true if `a` and `b` are approximately equal to each other.
+        /// Returns <see langword="true"/> if <paramref name="a"/> and <paramref name="b"/> are approximately
+        /// equal to each other.
         /// The comparison is done using the provided tolerance value.
         /// If you want the tolerance to be calculated for you, use <see cref="IsEqualApprox(real_t, real_t)"/>.
         /// </summary>
         /// <param name="a">One of the values.</param>
         /// <param name="b">The other value.</param>
         /// <param name="tolerance">The pre-calculated tolerance value.</param>
-        /// <returns>A bool for whether or not the two values are equal.</returns>
+        /// <returns>A <see langword="bool"/> for whether or not the two values are equal.</returns>
         public static bool IsEqualApprox(real_t a, real_t b, real_t tolerance)
         {
             // Check for exact equality first, required to handle "infinity" values.
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/NodePath.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/NodePath.cs
index 8c5872ba5ac..1377981ff4d 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/NodePath.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/NodePath.cs
@@ -3,6 +3,42 @@ using System.Runtime.CompilerServices;
 
 namespace Godot
 {
+    /// <summary>
+    /// A pre-parsed relative or absolute path in a scene tree,
+    /// for use with <see cref="Node.GetNode(NodePath)"/> and similar functions.
+    /// It can reference a node, a resource within a node, or a property
+    /// of a node or resource.
+    /// For instance, <c>"Path2D/PathFollow2D/Sprite2D:texture:size"</c>
+    /// would refer to the <c>size</c> property of the <c>texture</c>
+    /// resource on the node named <c>"Sprite2D"</c> which is a child of
+    /// the other named nodes in the path.
+    /// You will usually just pass a string to <see cref="Node.GetNode(NodePath)"/>
+    /// and it will be automatically converted, but you may occasionally
+    /// want to parse a path ahead of time with NodePath.
+    /// Exporting a NodePath variable will give you a node selection widget
+    /// in the properties panel of the editor, which can often be useful.
+    /// A NodePath is composed of a list of slash-separated node names
+    /// (like a filesystem path) and an optional colon-separated list of
+    /// "subnames" which can be resources or properties.
+    ///
+    /// Note: In the editor, NodePath properties are automatically updated when moving,
+    /// renaming or deleting a node in the scene tree, but they are never updated at runtime.
+    /// </summary>
+    /// <example>
+    /// Some examples of NodePaths include the following:
+    /// <code>
+    /// // No leading slash means it is relative to the current node.
+    /// new NodePath("A"); // Immediate child A.
+    /// new NodePath("A/B"); // A's child B.
+    /// new NodePath("."); // The current node.
+    /// new NodePath(".."); // The parent node.
+    /// new NodePath("../C"); // A sibling node C.
+    /// // A leading slash means it is absolute from the SceneTree.
+    /// new NodePath("/root"); // Equivalent to GetTree().Root
+    /// new NodePath("/root/Main"); // If your main scene's root node were named "Main".
+    /// new NodePath("/root/MyAutoload"); // If you have an autoloaded node or scene.
+    /// </code>
+    /// </example>
     public sealed partial class NodePath : IDisposable
     {
         private bool disposed = false;
@@ -25,6 +61,9 @@ namespace Godot
             Dispose(false);
         }
 
+        /// <summary>
+        /// Disposes of this <see cref="NodePath"/>.
+        /// </summary>
         public void Dispose()
         {
             Dispose(true);
@@ -50,68 +89,183 @@ namespace Godot
             this.ptr = ptr;
         }
 
+        /// <summary>
+        /// The pointer to the native instance of this <see cref="NodePath"/>.
+        /// </summary>
         public IntPtr NativeInstance
         {
             get { return ptr; }
         }
 
-        public NodePath() : this(string.Empty) {}
+        /// <summary>
+        /// Constructs an empty <see cref="NodePath"/>.
+        /// </summary>
+        public NodePath() : this(string.Empty) { }
 
+
+        /// <summary>
+        /// Constructs a <see cref="NodePath"/> from a string <paramref name="path"/>,
+        /// e.g.: <c>"Path2D/PathFollow2D/Sprite2D:texture:size"</c>.
+        /// A path is absolute if it starts with a slash. Absolute paths
+        /// are only valid in the global scene tree, not within individual
+        /// scenes. In a relative path, <c>"."</c> and <c>".."</c> indicate
+        /// the current node and its parent.
+        /// The "subnames" optionally included after the path to the target
+        /// node can point to resources or properties, and can also be nested.
+        /// </summary>
+        /// <example>
+        /// Examples of valid NodePaths (assuming that those nodes exist and
+        /// have the referenced resources or properties):
+        /// <code>
+        /// // Points to the Sprite2D node.
+        /// "Path2D/PathFollow2D/Sprite2D"
+        /// // Points to the Sprite2D node and its "texture" resource.
+        /// // GetNode() would retrieve "Sprite2D", while GetNodeAndResource()
+        /// // would retrieve both the Sprite2D node and the "texture" resource.
+        /// "Path2D/PathFollow2D/Sprite2D:texture"
+        /// // Points to the Sprite2D node and its "position" property.
+        /// "Path2D/PathFollow2D/Sprite2D:position"
+        /// // Points to the Sprite2D node and the "x" component of its "position" property.
+        /// "Path2D/PathFollow2D/Sprite2D:position:x"
+        /// // Absolute path (from "root")
+        /// "/root/Level/Path2D"
+        /// </code>
+        /// </example>
+        /// <param name="path"></param>
         public NodePath(string path)
         {
             this.ptr = godot_icall_NodePath_Ctor(path);
         }
 
+        /// <summary>
+        /// Converts a string to a <see cref="NodePath"/>.
+        /// </summary>
+        /// <param name="from">The string to convert.</param>
         public static implicit operator NodePath(string from)
         {
             return new NodePath(from);
         }
 
+        /// <summary>
+        /// Converts this <see cref="NodePath"/> to a string.
+        /// </summary>
+        /// <param name="from">The <see cref="NodePath"/> to convert.</param>
         public static implicit operator string(NodePath from)
         {
             return godot_icall_NodePath_operator_String(NodePath.GetPtr(from));
         }
 
+        /// <summary>
+        /// Converts this <see cref="NodePath"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this <see cref="NodePath"/>.</returns>
         public override string ToString()
         {
             return (string)this;
         }
 
+        /// <summary>
+        /// Returns a node path with a colon character (<c>:</c>) prepended,
+        /// transforming it to a pure property path with no node name (defaults
+        /// to resolving from the current node).
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// // This will be parsed as a node path to the "x" property in the "position" node.
+        /// var nodePath = new NodePath("position:x");
+        /// // This will be parsed as a node path to the "x" component of the "position" property in the current node.
+        /// NodePath propertyPath = nodePath.GetAsPropertyPath();
+        /// GD.Print(propertyPath); // :position:x
+        /// </code>
+        /// </example>
+        /// <returns>The <see cref="NodePath"/> as a pure property path.</returns>
         public NodePath GetAsPropertyPath()
         {
             return new NodePath(godot_icall_NodePath_get_as_property_path(NodePath.GetPtr(this)));
         }
 
+        /// <summary>
+        /// Returns all subnames concatenated with a colon character (<c>:</c>)
+        /// as separator, i.e. the right side of the first colon in a node path.
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// var nodepath = new NodePath("Path2D/PathFollow2D/Sprite2D:texture:load_path");
+        /// GD.Print(nodepath.GetConcatenatedSubnames()); // texture:load_path
+        /// </code>
+        /// </example>
+        /// <returns>The subnames concatenated with <c>:</c>.</returns>
         public string GetConcatenatedSubnames()
         {
             return godot_icall_NodePath_get_concatenated_subnames(NodePath.GetPtr(this));
         }
 
+        /// <summary>
+        /// Gets the node name indicated by <paramref name="idx"/> (0 to <see cref="GetNameCount"/>).
+        /// </summary>
+        /// <example>
+        /// <code>
+        /// var nodePath = new NodePath("Path2D/PathFollow2D/Sprite2D");
+        /// GD.Print(nodePath.GetName(0)); // Path2D
+        /// GD.Print(nodePath.GetName(1)); // PathFollow2D
+        /// GD.Print(nodePath.GetName(2)); // Sprite
+        /// </code>
+        /// </example>
+        /// <param name="idx">The name index.</param>
+        /// <returns>The name at the given index <paramref name="idx"/>.</returns>
         public string GetName(int idx)
         {
             return godot_icall_NodePath_get_name(NodePath.GetPtr(this), idx);
         }
 
+        /// <summary>
+        /// Gets the number of node names which make up the path.
+        /// Subnames (see <see cref="GetSubnameCount"/>) are not included.
+        /// For example, <c>"Path2D/PathFollow2D/Sprite2D"</c> has 3 names.
+        /// </summary>
+        /// <returns>The number of node names which make up the path.</returns>
         public int GetNameCount()
         {
             return godot_icall_NodePath_get_name_count(NodePath.GetPtr(this));
         }
 
+        /// <summary>
+        /// Gets the resource or property name indicated by <paramref name="idx"/> (0 to <see cref="GetSubnameCount"/>).
+        /// </summary>
+        /// <param name="idx">The subname index.</param>
+        /// <returns>The subname at the given index <paramref name="idx"/>.</returns>
         public string GetSubname(int idx)
         {
             return godot_icall_NodePath_get_subname(NodePath.GetPtr(this), idx);
         }
 
+        /// <summary>
+        /// Gets the number of resource or property names ("subnames") in the path.
+        /// Each subname is listed after a colon character (<c>:</c>) in the node path.
+        /// For example, <c>"Path2D/PathFollow2D/Sprite2D:texture:load_path"</c> has 2 subnames.
+        /// </summary>
+        /// <returns>The number of subnames in the path.</returns>
         public int GetSubnameCount()
         {
             return godot_icall_NodePath_get_subname_count(NodePath.GetPtr(this));
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if the node path is absolute (as opposed to relative),
+        /// which means that it starts with a slash character (<c>/</c>). Absolute node paths can
+        /// be used to access the root node (<c>"/root"</c>) or autoloads (e.g. <c>"/global"</c>
+        /// if a "global" autoload was registered).
+        /// </summary>
+        /// <returns>If the <see cref="NodePath"/> is an absolute path.</returns>
         public bool IsAbsolute()
         {
             return godot_icall_NodePath_is_absolute(NodePath.GetPtr(this));
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if the node path is empty.
+        /// </summary>
+        /// <returns>If the <see cref="NodePath"/> is empty.</returns>
         public bool IsEmpty()
         {
             return godot_icall_NodePath_is_empty(NodePath.GetPtr(this));
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Object.base.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Object.base.cs
index de80f7fddc1..21b7e5f9a55 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Object.base.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Object.base.cs
@@ -12,6 +12,9 @@ namespace Godot
         internal IntPtr ptr;
         internal bool memoryOwn;
 
+        /// <summary>
+        /// Constructs a new <see cref="Object"/>.
+        /// </summary>
         public Object() : this(false)
         {
             if (ptr == IntPtr.Zero)
@@ -23,6 +26,9 @@ namespace Godot
             this.memoryOwn = memoryOwn;
         }
 
+        /// <summary>
+        /// The pointer to the native instance of this <see cref="Object"/>.
+        /// </summary>
         public IntPtr NativeInstance
         {
             get { return ptr; }
@@ -44,12 +50,18 @@ namespace Godot
             Dispose(false);
         }
 
+        /// <summary>
+        /// Disposes of this <see cref="Object"/>.
+        /// </summary>
         public void Dispose()
         {
             Dispose(true);
             GC.SuppressFinalize(this);
         }
 
+        /// <summary>
+        /// Disposes implementation of this <see cref="Object"/>.
+        /// </summary>
         protected virtual void Dispose(bool disposing)
         {
             if (disposed)
@@ -73,13 +85,17 @@ namespace Godot
             disposed = true;
         }
 
+        /// <summary>
+        /// Converts this <see cref="Object"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this object.</returns>
         public override string ToString()
         {
             return godot_icall_Object_ToString(GetPtr(this));
         }
 
         /// <summary>
-        /// Returns a new <see cref="Godot.SignalAwaiter"/> awaiter configured to complete when the instance
+        /// Returns a new <see cref="SignalAwaiter"/> awaiter configured to complete when the instance
         /// <paramref name="source"/> emits the signal specified by the <paramref name="signal"/> parameter.
         /// </summary>
         /// <param name="source">
@@ -101,13 +117,17 @@ namespace Godot
         /// }
         /// </code>
         /// </example>
+        /// <returns>
+        /// A <see cref="SignalAwaiter"/> that completes when
+        /// <paramref name="source"/> emits the <paramref name="signal"/>.
+        /// </returns>
         public SignalAwaiter ToSignal(Object source, string signal)
         {
             return new SignalAwaiter(source, signal, this);
         }
 
         /// <summary>
-        /// Gets a new <see cref="Godot.DynamicGodotObject"/> associated with this instance.
+        /// Gets a new <see cref="DynamicGodotObject"/> associated with this instance.
         /// </summary>
         public dynamic DynamicObject => new DynamicGodotObject(this);
 
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Plane.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Plane.cs
index 30f7512ae05..09aca2fd220 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Plane.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Plane.cs
@@ -21,10 +21,10 @@ namespace Godot
 
         /// <summary>
         /// The normal of the plane, which must be normalized.
-        /// In the scalar equation of the plane `ax + by + cz = d`, this is
-        /// the vector `(a, b, c)`, where `d` is the <see cref="D"/> property.
+        /// In the scalar equation of the plane <c>ax + by + cz = d</c>, this is
+        /// the vector <c>(a, b, c)</c>, where <c>d</c> is the <see cref="D"/> property.
         /// </summary>
-        /// <value>Equivalent to `x`, `y`, and `z`.</value>
+        /// <value>Equivalent to <see cref="x"/>, <see cref="y"/>, and <see cref="z"/>.</value>
         public Vector3 Normal
         {
             get { return _normal; }
@@ -82,8 +82,8 @@ namespace Godot
         /// <summary>
         /// The distance from the origin to the plane (in the direction of
         /// <see cref="Normal"/>). This value is typically non-negative.
-        /// In the scalar equation of the plane `ax + by + cz = d`,
-        /// this is `d`, while the `(a, b, c)` coordinates are represented
+        /// In the scalar equation of the plane <c>ax + by + cz = d</c>,
+        /// this is <c>d</c>, while the <c>(a, b, c)</c> coordinates are represented
         /// by the <see cref="Normal"/> property.
         /// </summary>
         /// <value>The plane's distance from the origin.</value>
@@ -92,7 +92,7 @@ namespace Godot
         /// <summary>
         /// The center of the plane, the point where the normal line intersects the plane.
         /// </summary>
-        /// <value>Equivalent to <see cref="Normal"/> multiplied by `D`.</value>
+        /// <value>Equivalent to <see cref="Normal"/> multiplied by <see cref="D"/>.</value>
         public Vector3 Center
         {
             get
@@ -107,7 +107,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the shortest distance from this plane to the position `point`.
+        /// Returns the shortest distance from this plane to the position <paramref name="point"/>.
         /// </summary>
         /// <param name="point">The position to use for the calculation.</param>
         /// <returns>The shortest distance.</returns>
@@ -128,12 +128,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if point is inside the plane.
+        /// Returns <see langword="true"/> if point is inside the plane.
         /// Comparison uses a custom minimum epsilon threshold.
         /// </summary>
         /// <param name="point">The point to check.</param>
         /// <param name="epsilon">The tolerance threshold.</param>
-        /// <returns>A bool for whether or not the plane has the point.</returns>
+        /// <returns>A <see langword="bool"/> for whether or not the plane has the point.</returns>
         public bool HasPoint(Vector3 point, real_t epsilon = Mathf.Epsilon)
         {
             real_t dist = _normal.Dot(point) - D;
@@ -141,12 +141,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the intersection point of the three planes: `b`, `c`,
-        /// and this plane. If no intersection is found, `null` is returned.
+        /// Returns the intersection point of the three planes: <paramref name="b"/>, <paramref name="c"/>,
+        /// and this plane. If no intersection is found, <see langword="null"/> is returned.
         /// </summary>
         /// <param name="b">One of the three planes to use in the calculation.</param>
         /// <param name="c">One of the three planes to use in the calculation.</param>
-        /// <returns>The intersection, or `null` if none is found.</returns>
+        /// <returns>The intersection, or <see langword="null"/> if none is found.</returns>
         public Vector3? Intersect3(Plane b, Plane c)
         {
             real_t denom = _normal.Cross(b._normal).Dot(c._normal);
@@ -164,13 +164,13 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the intersection point of a ray consisting of the
-        /// position `from` and the direction normal `dir` with this plane.
-        /// If no intersection is found, `null` is returned.
+        /// Returns the intersection point of a ray consisting of the position <paramref name="from"/>
+        /// and the direction normal <paramref name="dir"/> with this plane.
+        /// If no intersection is found, <see langword="null"/> is returned.
         /// </summary>
         /// <param name="from">The start of the ray.</param>
         /// <param name="dir">The direction of the ray, normalized.</param>
-        /// <returns>The intersection, or `null` if none is found.</returns>
+        /// <returns>The intersection, or <see langword="null"/> if none is found.</returns>
         public Vector3? IntersectRay(Vector3 from, Vector3 dir)
         {
             real_t den = _normal.Dot(dir);
@@ -193,12 +193,12 @@ namespace Godot
 
         /// <summary>
         /// Returns the intersection point of a line segment from
-        /// position `begin` to position `end` with this plane.
-        /// If no intersection is found, `null` is returned.
+        /// position <paramref name="begin"/> to position <paramref name="end"/> with this plane.
+        /// If no intersection is found, <see langword="null"/> is returned.
         /// </summary>
         /// <param name="begin">The start of the line segment.</param>
         /// <param name="end">The end of the line segment.</param>
-        /// <returns>The intersection, or `null` if none is found.</returns>
+        /// <returns>The intersection, or <see langword="null"/> if none is found.</returns>
         public Vector3? IntersectSegment(Vector3 begin, Vector3 end)
         {
             Vector3 segment = begin - end;
@@ -221,10 +221,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if `point` is located above the plane.
+        /// Returns <see langword="true"/> if <paramref name="point"/> is located above the plane.
         /// </summary>
         /// <param name="point">The point to check.</param>
-        /// <returns>A bool for whether or not the point is above the plane.</returns>
+        /// <returns>A <see langword="bool"/> for whether or not the point is above the plane.</returns>
         public bool IsPointOver(Vector3 point)
         {
             return _normal.Dot(point) > D;
@@ -247,7 +247,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the orthogonal projection of `point` into the plane.
+        /// Returns the orthogonal projection of <paramref name="point"/> into the plane.
         /// </summary>
         /// <param name="point">The point to project.</param>
         /// <returns>The projected point.</returns>
@@ -262,27 +262,28 @@ namespace Godot
         private static readonly Plane _planeXY = new Plane(0, 0, 1, 0);
 
         /// <summary>
-        /// A plane that extends in the Y and Z axes (normal vector points +X).
+        /// A <see cref="Plane"/> that extends in the Y and Z axes (normal vector points +X).
         /// </summary>
-        /// <value>Equivalent to `new Plane(1, 0, 0, 0)`.</value>
+        /// <value>Equivalent to <c>new Plane(1, 0, 0, 0)</c>.</value>
         public static Plane PlaneYZ { get { return _planeYZ; } }
 
         /// <summary>
-        /// A plane that extends in the X and Z axes (normal vector points +Y).
+        /// A <see cref="Plane"/> that extends in the X and Z axes (normal vector points +Y).
         /// </summary>
-        /// <value>Equivalent to `new Plane(0, 1, 0, 0)`.</value>
+        /// <value>Equivalent to <c>new Plane(0, 1, 0, 0)</c>.</value>
         public static Plane PlaneXZ { get { return _planeXZ; } }
 
         /// <summary>
-        /// A plane that extends in the X and Y axes (normal vector points +Z).
+        /// A <see cref="Plane"/> that extends in the X and Y axes (normal vector points +Z).
         /// </summary>
-        /// <value>Equivalent to `new Plane(0, 0, 1, 0)`.</value>
+        /// <value>Equivalent to <c>new Plane(0, 0, 1, 0)</c>.</value>
         public static Plane PlaneXY { get { return _planeXY; } }
 
         /// <summary>
-        /// Constructs a plane from four values. `a`, `b` and `c` become the
+        /// Constructs a <see cref="Plane"/> from four values.
+        /// <paramref name="a"/>, <paramref name="b"/> and <paramref name="c"/> become the
         /// components of the resulting plane's <see cref="Normal"/> vector.
-        /// `d` becomes the plane's distance from the origin.
+        /// <paramref name="d"/> becomes the plane's distance from the origin.
         /// </summary>
         /// <param name="a">The X component of the plane's normal vector.</param>
         /// <param name="b">The Y component of the plane's normal vector.</param>
@@ -295,7 +296,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a plane from a normal vector and the plane's distance to the origin.
+        /// Constructs a <see cref="Plane"/> from a <paramref name="normal"/> vector and
+        /// the plane's distance to the origin <paramref name="d"/>.
         /// </summary>
         /// <param name="normal">The normal of the plane, must be normalized.</param>
         /// <param name="d">The plane's distance from the origin. This value is typically non-negative.</param>
@@ -306,7 +308,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a plane from the three points, given in clockwise order.
+        /// Constructs a <see cref="Plane"/> from the three points, given in clockwise order.
         /// </summary>
         /// <param name="v1">The first point.</param>
         /// <param name="v2">The second point.</param>
@@ -333,6 +335,11 @@ namespace Godot
             return !left.Equals(right);
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this plane and <paramref name="obj"/> are equal.
+        /// </summary>
+        /// <param name="obj">The other object to compare.</param>
+        /// <returns>Whether or not the plane and the other object are equal.</returns>
         public override bool Equals(object obj)
         {
             if (obj is Plane)
@@ -343,14 +350,19 @@ namespace Godot
             return false;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this plane and <paramref name="other"/> are equal.
+        /// </summary>
+        /// <param name="other">The other plane to compare.</param>
+        /// <returns>Whether or not the planes are equal.</returns>
         public bool Equals(Plane other)
         {
             return _normal == other._normal && D == other.D;
         }
 
         /// <summary>
-        /// Returns true if this plane and `other` are approximately equal, by running
-        /// <see cref="Mathf.IsEqualApprox(real_t, real_t)"/> on each component.
+        /// Returns <see langword="true"/> if this plane and <paramref name="other"/> are
+        /// approximately equal, by running <see cref="Mathf.IsEqualApprox(real_t, real_t)"/> on each component.
         /// </summary>
         /// <param name="other">The other plane to compare.</param>
         /// <returns>Whether or not the planes are approximately equal.</returns>
@@ -359,11 +371,19 @@ namespace Godot
             return _normal.IsEqualApprox(other._normal) && Mathf.IsEqualApprox(D, other.D);
         }
 
+        /// <summary>
+        /// Serves as the hash function for <see cref="Plane"/>.
+        /// </summary>
+        /// <returns>A hash code for this plane.</returns>
         public override int GetHashCode()
         {
             return _normal.GetHashCode() ^ D.GetHashCode();
         }
 
+        /// <summary>
+        /// Converts this <see cref="Plane"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this plane.</returns>
         public override string ToString()
         {
             return String.Format("({0}, {1})", new object[]
@@ -373,6 +393,10 @@ namespace Godot
             });
         }
 
+        /// <summary>
+        /// Converts this <see cref="Plane"/> to a string with the given <paramref name="format"/>.
+        /// </summary>
+        /// <returns>A string representation of this plane.</returns>
         public string ToString(string format)
         {
             return String.Format("({0}, {1})", new object[]
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Quat.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Quat.cs
index bc8d715c96a..1d21c706dfb 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Quat.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Quat.cs
@@ -12,10 +12,10 @@ namespace Godot
     /// A unit quaternion used for representing 3D rotations.
     /// Quaternions need to be normalized to be used for rotation.
     ///
-    /// It is similar to Basis, which implements matrix representation of
-    /// rotations, and can be parametrized using both an axis-angle pair
-    /// or Euler angles. Basis stores rotation, scale, and shearing,
-    /// while Quat only stores rotation.
+    /// It is similar to <see cref="Basis"/>, which implements matrix
+    /// representation of rotations, and can be parametrized using both
+    /// an axis-angle pair or Euler angles. Basis stores rotation, scale,
+    /// and shearing, while Quat only stores rotation
     ///
     /// Due to its compactness and the way it is stored in memory, certain
     /// operations (obtaining axis-angle and performing SLERP, in particular)
@@ -26,19 +26,19 @@ namespace Godot
     public struct Quat : IEquatable<Quat>
     {
         /// <summary>
-        /// X component of the quaternion (imaginary `i` axis part).
+        /// X component of the quaternion (imaginary <c>i</c> axis part).
         /// Quaternion components should usually not be manipulated directly.
         /// </summary>
         public real_t x;
 
         /// <summary>
-        /// Y component of the quaternion (imaginary `j` axis part).
+        /// Y component of the quaternion (imaginary <c>j</c> axis part).
         /// Quaternion components should usually not be manipulated directly.
         /// </summary>
         public real_t y;
 
         /// <summary>
-        /// Z component of the quaternion (imaginary `k` axis part).
+        /// Z component of the quaternion (imaginary <c>k</c> axis part).
         /// Quaternion components should usually not be manipulated directly.
         /// </summary>
         public real_t z;
@@ -52,7 +52,12 @@ namespace Godot
         /// <summary>
         /// Access quaternion components using their index.
         /// </summary>
-        /// <value>`[0]` is equivalent to `.x`, `[1]` is equivalent to `.y`, `[2]` is equivalent to `.z`, `[3]` is equivalent to `.w`.</value>
+        /// <value>
+        /// <c>[0]</c> is equivalent to <see cref="x"/>,
+        /// <c>[1]</c> is equivalent to <see cref="y"/>,
+        /// <c>[2]</c> is equivalent to <see cref="z"/>,
+        /// <c>[3]</c> is equivalent to <see cref="w"/>.
+        /// </value>
         public real_t this[int index]
         {
             get
@@ -96,7 +101,8 @@ namespace Godot
         /// <summary>
         /// Returns the length (magnitude) of the quaternion.
         /// </summary>
-        /// <value>Equivalent to `Mathf.Sqrt(LengthSquared)`.</value>
+        /// <seealso cref="LengthSquared"/>
+        /// <value>Equivalent to <c>Mathf.Sqrt(LengthSquared)</c>.</value>
         public real_t Length
         {
             get { return Mathf.Sqrt(LengthSquared); }
@@ -107,14 +113,14 @@ namespace Godot
         /// This method runs faster than <see cref="Length"/>, so prefer it if
         /// you need to compare quaternions or need the squared length for some formula.
         /// </summary>
-        /// <value>Equivalent to `Dot(this)`.</value>
+        /// <value>Equivalent to <c>Dot(this)</c>.</value>
         public real_t LengthSquared
         {
             get { return Dot(this); }
         }
 
         /// <summary>
-        /// Returns the angle between this quaternion and `to`.
+        /// Returns the angle between this quaternion and <paramref name="to"/>.
         /// This is the magnitude of the angle you would need to rotate
         /// by to get from one to the other.
         ///
@@ -131,12 +137,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Performs a cubic spherical interpolation between quaternions `preA`,
-        /// this vector, `b`, and `postB`, by the given amount `t`.
+        /// Performs a cubic spherical interpolation between quaternions <paramref name="preA"/>, this quaternion,
+        /// <paramref name="b"/>, and <paramref name="postB"/>, by the given amount <paramref name="weight"/>.
         /// </summary>
         /// <param name="b">The destination quaternion.</param>
         /// <param name="preA">A quaternion before this quaternion.</param>
-        /// <param name="postB">A quaternion after `b`.</param>
+        /// <param name="postB">A quaternion after <paramref name="b"/>.</param>
         /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
         /// <returns>The interpolated quaternion.</returns>
         public Quat CubicSlerp(Quat b, Quat preA, Quat postB, real_t weight)
@@ -195,7 +201,7 @@ namespace Godot
         /// <summary>
         /// Returns whether the quaternion is normalized or not.
         /// </summary>
-        /// <returns>A bool for whether the quaternion is normalized or not.</returns>
+        /// <returns>A <see langword="bool"/> for whether the quaternion is normalized or not.</returns>
         public bool IsNormalized()
         {
             return Mathf.Abs(LengthSquared - 1) <= Mathf.Epsilon;
@@ -239,7 +245,7 @@ namespace Godot
 
         /// <summary>
         /// Returns the result of the spherical linear interpolation between
-        /// this quaternion and `to` by amount `weight`.
+        /// this quaternion and <paramref name="to"/> by amount <paramref name="weight"/>.
         ///
         /// Note: Both quaternions must be normalized.
         /// </summary>
@@ -311,7 +317,7 @@ namespace Godot
 
         /// <summary>
         /// Returns the result of the spherical linear interpolation between
-        /// this quaternion and `to` by amount `weight`, but without
+        /// this quaternion and <paramref name="to"/> by amount <paramref name="weight"/>, but without
         /// checking if the rotation path is not bigger than 90 degrees.
         /// </summary>
         /// <param name="to">The destination quaternion for interpolation. Must be normalized.</param>
@@ -366,15 +372,15 @@ namespace Godot
         /// Equivalent to an identity <see cref="Basis"/> matrix. If a vector is transformed by
         /// an identity quaternion, it will not change.
         /// </summary>
-        /// <value>Equivalent to `new Quat(0, 0, 0, 1)`.</value>
+        /// <value>Equivalent to <c>new Quat(0, 0, 0, 1)</c>.</value>
         public static Quat Identity { get { return _identity; } }
 
         /// <summary>
-        /// Constructs a quaternion defined by the given values.
+        /// Constructs a <see cref="Quat"/> defined by the given values.
         /// </summary>
-        /// <param name="x">X component of the quaternion (imaginary `i` axis part).</param>
-        /// <param name="y">Y component of the quaternion (imaginary `j` axis part).</param>
-        /// <param name="z">Z component of the quaternion (imaginary `k` axis part).</param>
+        /// <param name="x">X component of the quaternion (imaginary <c>i</c> axis part).</param>
+        /// <param name="y">Y component of the quaternion (imaginary <c>j</c> axis part).</param>
+        /// <param name="z">Z component of the quaternion (imaginary <c>k</c> axis part).</param>
         /// <param name="w">W component of the quaternion (real part).</param>
         public Quat(real_t x, real_t y, real_t z, real_t w)
         {
@@ -385,7 +391,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a quaternion from the given quaternion.
+        /// Constructs a <see cref="Quat"/> from the given <see cref="Quat"/>.
         /// </summary>
         /// <param name="q">The existing quaternion.</param>
         public Quat(Quat q)
@@ -394,21 +400,20 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a quaternion from the given <see cref="Basis"/>.
+        /// Constructs a <see cref="Quat"/> from the given <see cref="Basis"/>.
         /// </summary>
-        /// <param name="basis">The basis to construct from.</param>
+        /// <param name="basis">The <see cref="Basis"/> to construct from.</param>
         public Quat(Basis basis)
         {
             this = basis.Quat();
         }
 
         /// <summary>
-        /// Constructs a quaternion that will perform a rotation specified by
-        /// Euler angles (in the YXZ convention: when decomposing,
-        /// first Z, then X, and Y last),
+        /// Constructs a <see cref="Quat"/> that will perform a rotation specified by
+        /// Euler angles (in the YXZ convention: when decomposing, first Z, then X, and Y last),
         /// given in the vector format as (X angle, Y angle, Z angle).
         /// </summary>
-        /// <param name="eulerYXZ"></param>
+        /// <param name="eulerYXZ">Euler angles that the quaternion will be rotated by.</param>
         public Quat(Vector3 eulerYXZ)
         {
             real_t half_a1 = eulerYXZ.y * 0.5f;
@@ -433,7 +438,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a quaternion that will rotate around the given axis
+        /// Constructs a <see cref="Quat"/> that will rotate around the given axis
         /// by the specified angle. The axis must be a normalized vector.
         /// </summary>
         /// <param name="axis">The axis to rotate around. Must be normalized.</param>
@@ -542,6 +547,11 @@ namespace Godot
             return !left.Equals(right);
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this quaternion and <paramref name="obj"/> are equal.
+        /// </summary>
+        /// <param name="obj">The other object to compare.</param>
+        /// <returns>Whether or not the quaternion and the other object are equal.</returns>
         public override bool Equals(object obj)
         {
             if (obj is Quat)
@@ -552,14 +562,19 @@ namespace Godot
             return false;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this quaternion and <paramref name="other"/> are equal.
+        /// </summary>
+        /// <param name="other">The other quaternion to compare.</param>
+        /// <returns>Whether or not the quaternions are equal.</returns>
         public bool Equals(Quat other)
         {
             return x == other.x && y == other.y && z == other.z && w == other.w;
         }
 
         /// <summary>
-        /// Returns true if this quaternion and `other` are approximately equal, by running
-        /// <see cref="Mathf.IsEqualApprox(real_t, real_t)"/> on each component.
+        /// Returns <see langword="true"/> if this quaternion and <paramref name="other"/> are approximately equal,
+        /// by running <see cref="Mathf.IsEqualApprox(real_t, real_t)"/> on each component.
         /// </summary>
         /// <param name="other">The other quaternion to compare.</param>
         /// <returns>Whether or not the quaternions are approximately equal.</returns>
@@ -568,16 +583,28 @@ namespace Godot
             return Mathf.IsEqualApprox(x, other.x) && Mathf.IsEqualApprox(y, other.y) && Mathf.IsEqualApprox(z, other.z) && Mathf.IsEqualApprox(w, other.w);
         }
 
+        /// <summary>
+        /// Serves as the hash function for <see cref="Quat"/>.
+        /// </summary>
+        /// <returns>A hash code for this quaternion.</returns>
         public override int GetHashCode()
         {
             return y.GetHashCode() ^ x.GetHashCode() ^ z.GetHashCode() ^ w.GetHashCode();
         }
 
+        /// <summary>
+        /// Converts this <see cref="Quat"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this quaternion.</returns>
         public override string ToString()
         {
             return String.Format("({0}, {1}, {2}, {3})", x.ToString(), y.ToString(), z.ToString(), w.ToString());
         }
 
+        /// <summary>
+        /// Converts this <see cref="Quat"/> to a string with the given <paramref name="format"/>.
+        /// </summary>
+        /// <returns>A string representation of this quaternion.</returns>
         public string ToString(string format)
         {
             return String.Format("({0}, {1}, {2}, {3})", x.ToString(format), y.ToString(format), z.ToString(format), w.ToString(format));
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/RID.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/RID.cs
index 94761531b12..f5c5d6fd0e0 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/RID.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/RID.cs
@@ -3,6 +3,12 @@ using System.Runtime.CompilerServices;
 
 namespace Godot
 {
+    /// <summary>
+    /// The RID type is used to access the unique integer ID of a resource.
+    /// They are opaque, which means they do not grant access to the associated
+    /// resource by themselves. They are used by and with the low-level Server
+    /// classes such as <see cref="VisualServer"/>.
+    /// </summary>
     public sealed partial class RID : IDisposable
     {
         private bool disposed = false;
@@ -25,6 +31,9 @@ namespace Godot
             Dispose(false);
         }
 
+        /// <summary>
+        /// Disposes of this <see cref="RID"/>.
+        /// </summary>
         public void Dispose()
         {
             Dispose(true);
@@ -50,6 +59,9 @@ namespace Godot
             this.ptr = ptr;
         }
 
+        /// <summary>
+        /// The pointer to the native instance of this <see cref="RID"/>.
+        /// </summary>
         public IntPtr NativeInstance
         {
             get { return ptr; }
@@ -60,16 +72,27 @@ namespace Godot
             this.ptr = IntPtr.Zero;
         }
 
+        /// <summary>
+        /// Constructs a new <see cref="RID"/> for the given <see cref="Object"/> <paramref name="from"/>.
+        /// </summary>
         public RID(Object from)
         {
             this.ptr = godot_icall_RID_Ctor(Object.GetPtr(from));
         }
 
+        /// <summary>
+        /// Returns the ID of the referenced resource.
+        /// </summary>
+        /// <returns>The ID of the referenced resource.</returns>
         public int GetId()
         {
-            return godot_icall_RID_get_id(RID.GetPtr(this));
+            return godot_icall_RID_get_id(GetPtr(this));
         }
 
+        /// <summary>
+        /// Converts this <see cref="RID"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this RID.</returns>
         public override string ToString() => "[RID]";
 
         [MethodImpl(MethodImplOptions.InternalCall)]
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Rect2.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Rect2.cs
index 42adc1db532..1b007cb55b9 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Rect2.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Rect2.cs
@@ -20,7 +20,7 @@ namespace Godot
         private Vector2 _size;
 
         /// <summary>
-        /// Beginning corner. Typically has values lower than End.
+        /// Beginning corner. Typically has values lower than <see cref="End"/>.
         /// </summary>
         /// <value>Directly uses a private field.</value>
         public Vector2 Position
@@ -30,7 +30,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Size from Position to End. Typically all components are positive.
+        /// Size from <see cref="Position"/> to <see cref="End"/>. Typically all components are positive.
         /// If the size is negative, you can use <see cref="Abs"/> to fix it.
         /// </summary>
         /// <value>Directly uses a private field.</value>
@@ -41,10 +41,13 @@ namespace Godot
         }
 
         /// <summary>
-        /// Ending corner. This is calculated as <see cref="Position"/> plus
-        /// <see cref="Size"/>. Setting this value will change the size.
+        /// Ending corner. This is calculated as <see cref="Position"/> plus <see cref="Size"/>.
+        /// Setting this value will change the size.
         /// </summary>
-        /// <value>Getting is equivalent to `value = Position + Size`, setting is equivalent to `Size = value - Position`.</value>
+        /// <value>
+        /// Getting is equivalent to <paramref name="value"/> = <see cref="Position"/> + <see cref="Size"/>,
+        /// setting is equivalent to <see cref="Size"/> = <paramref name="value"/> - <see cref="Position"/>
+        /// </value>
         public Vector2 End
         {
             get { return _position + _size; }
@@ -52,7 +55,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// The area of this rect.
+        /// The area of this <see cref="Rect2"/>.
         /// </summary>
         /// <value>Equivalent to <see cref="GetArea()"/>.</value>
         public real_t Area
@@ -61,10 +64,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a Rect2 with equivalent position and size, modified so that
+        /// Returns a <see cref="Rect2"/> with equivalent position and size, modified so that
         /// the top-left corner is the origin and width and height are positive.
         /// </summary>
-        /// <returns>The modified rect.</returns>
+        /// <returns>The modified <see cref="Rect2"/>.</returns>
         public Rect2 Abs()
         {
             Vector2 end = End;
@@ -73,10 +76,11 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the intersection of this Rect2 and `b`.
+        /// Returns the intersection of this <see cref="Rect2"/> and <paramref name="b"/>.
+        /// If the rectangles do not intersect, an empty <see cref="Rect2"/> is returned.
         /// </summary>
-        /// <param name="b">The other rect.</param>
-        /// <returns>The clipped rect.</returns>
+        /// <param name="b">The other <see cref="Rect2"/>.</param>
+        /// <returns>The clipped <see cref="Rect2"/>.</returns>
         public Rect2 Clip(Rect2 b)
         {
             var newRect = b;
@@ -99,10 +103,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if this Rect2 completely encloses another one.
+        /// Returns <see langword="true"/> if this <see cref="Rect2"/> completely encloses another one.
         /// </summary>
-        /// <param name="b">The other rect that may be enclosed.</param>
-        /// <returns>A bool for whether or not this rect encloses `b`.</returns>
+        /// <param name="b">The other <see cref="Rect2"/> that may be enclosed.</param>
+        /// <returns>
+        /// A <see langword="bool"/> for whether or not this <see cref="Rect2"/> encloses <paramref name="b"/>.
+        /// </returns>
         public bool Encloses(Rect2 b)
         {
             return b._position.x >= _position.x && b._position.y >= _position.y &&
@@ -111,10 +117,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns this Rect2 expanded to include a given point.
+        /// Returns this <see cref="Rect2"/> expanded to include a given point.
         /// </summary>
         /// <param name="to">The point to include.</param>
-        /// <returns>The expanded rect.</returns>
+        /// <returns>The expanded <see cref="Rect2"/>.</returns>
         public Rect2 Expand(Vector2 to)
         {
             var expanded = this;
@@ -147,7 +153,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the area of the Rect2.
+        /// Returns the area of the <see cref="Rect2"/>.
         /// </summary>
         /// <returns>The area.</returns>
         public real_t GetArea()
@@ -156,10 +162,13 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a copy of the Rect2 grown a given amount of units towards all the sides.
+        /// Returns a copy of the <see cref="Rect2"/> grown a given amount of units towards
+        /// all the sides.
         /// </summary>
+        /// <seealso cref="GrowIndividual(real_t, real_t, real_t, real_t)"/>
+        /// <seealso cref="GrowMargin(Margin, real_t)"/>
         /// <param name="by">The amount to grow by.</param>
-        /// <returns>The grown rect.</returns>
+        /// <returns>The grown <see cref="Rect2"/>.</returns>
         public Rect2 Grow(real_t by)
         {
             var g = this;
@@ -173,13 +182,16 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a copy of the Rect2 grown a given amount of units towards each direction individually.
+        /// Returns a copy of the <see cref="Rect2"/> grown a given amount of units towards
+        /// each direction individually.
         /// </summary>
+        /// <seealso cref="Grow(real_t)"/>
+        /// <seealso cref="GrowMargin(Margin, real_t)"/>
         /// <param name="left">The amount to grow by on the left.</param>
         /// <param name="top">The amount to grow by on the top.</param>
         /// <param name="right">The amount to grow by on the right.</param>
         /// <param name="bottom">The amount to grow by on the bottom.</param>
-        /// <returns>The grown rect.</returns>
+        /// <returns>The grown <see cref="Rect2"/>.</returns>
         public Rect2 GrowIndividual(real_t left, real_t top, real_t right, real_t bottom)
         {
             var g = this;
@@ -193,11 +205,14 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a copy of the Rect2 grown a given amount of units towards the <see cref="Margin"/> direction.
+        /// Returns a copy of the <see cref="Rect2"/> grown a given amount of units towards
+        /// the <see cref="Margin"/> direction.
         /// </summary>
+        /// <seealso cref="Grow(real_t)"/>
+        /// <seealso cref="GrowIndividual(real_t, real_t, real_t, real_t)"/>
         /// <param name="margin">The direction to grow in.</param>
         /// <param name="by">The amount to grow by.</param>
-        /// <returns>The grown rect.</returns>
+        /// <returns>The grown <see cref="Rect2"/>.</returns>
         public Rect2 GrowMargin(Margin margin, real_t by)
         {
             var g = this;
@@ -211,19 +226,25 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if the Rect2 is flat or empty, or false otherwise.
+        /// Returns <see langword="true"/> if the <see cref="Rect2"/> is flat or empty,
+        /// or <see langword="false"/> otherwise.
         /// </summary>
-        /// <returns>A bool for whether or not the rect has area.</returns>
+        /// <returns>
+        /// A <see langword="bool"/> for whether or not the <see cref="Rect2"/> has area.
+        /// </returns>
         public bool HasNoArea()
         {
             return _size.x <= 0 || _size.y <= 0;
         }
 
         /// <summary>
-        /// Returns true if the Rect2 contains a point, or false otherwise.
+        /// Returns <see langword="true"/> if the <see cref="Rect2"/> contains a point,
+        /// or <see langword="false"/> otherwise.
         /// </summary>
         /// <param name="point">The point to check.</param>
-        /// <returns>A bool for whether or not the rect contains `point`.</returns>
+        /// <returns>
+        /// A <see langword="bool"/> for whether or not the <see cref="Rect2"/> contains <paramref name="point"/>.
+        /// </returns>
         public bool HasPoint(Vector2 point)
         {
             if (point.x < _position.x)
@@ -240,15 +261,16 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if the Rect2 overlaps with `b`
+        /// Returns <see langword="true"/> if the <see cref="Rect2"/> overlaps with <paramref name="b"/>
         /// (i.e. they have at least one point in common).
         ///
-        /// If `includeBorders` is true, they will also be considered overlapping
-        /// if their borders touch, even without intersection.
+        /// If <paramref name="includeBorders"/> is <see langword="true"/>,
+        /// they will also be considered overlapping if their borders touch,
+        /// even without intersection.
         /// </summary>
-        /// <param name="b">The other rect to check for intersections with.</param>
+        /// <param name="b">The other <see cref="Rect2"/> to check for intersections with.</param>
         /// <param name="includeBorders">Whether or not to consider borders.</param>
-        /// <returns>A bool for whether or not they are intersecting.</returns>
+        /// <returns>A <see langword="bool"/> for whether or not they are intersecting.</returns>
         public bool Intersects(Rect2 b, bool includeBorders = false)
         {
             if (includeBorders)
@@ -294,10 +316,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a larger Rect2 that contains this Rect2 and `b`.
+        /// Returns a larger <see cref="Rect2"/> that contains this <see cref="Rect2"/> and <paramref name="b"/>.
         /// </summary>
-        /// <param name="b">The other rect.</param>
-        /// <returns>The merged rect.</returns>
+        /// <param name="b">The other <see cref="Rect2"/>.</param>
+        /// <returns>The merged <see cref="Rect2"/>.</returns>
         public Rect2 Merge(Rect2 b)
         {
             Rect2 newRect;
@@ -314,7 +336,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a Rect2 from a position and size.
+        /// Constructs a <see cref="Rect2"/> from a position and size.
         /// </summary>
         /// <param name="position">The position.</param>
         /// <param name="size">The size.</param>
@@ -325,7 +347,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a Rect2 from a position, width, and height.
+        /// Constructs a <see cref="Rect2"/> from a position, width, and height.
         /// </summary>
         /// <param name="position">The position.</param>
         /// <param name="width">The width.</param>
@@ -337,7 +359,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a Rect2 from x, y, and size.
+        /// Constructs a <see cref="Rect2"/> from x, y, and size.
         /// </summary>
         /// <param name="x">The position's X coordinate.</param>
         /// <param name="y">The position's Y coordinate.</param>
@@ -349,7 +371,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a Rect2 from x, y, width, and height.
+        /// Constructs a <see cref="Rect2"/> from x, y, width, and height.
         /// </summary>
         /// <param name="x">The position's X coordinate.</param>
         /// <param name="y">The position's Y coordinate.</param>
@@ -371,6 +393,11 @@ namespace Godot
             return !left.Equals(right);
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this rect and <paramref name="obj"/> are equal.
+        /// </summary>
+        /// <param name="obj">The other object to compare.</param>
+        /// <returns>Whether or not the rect and the other object are equal.</returns>
         public override bool Equals(object obj)
         {
             if (obj is Rect2)
@@ -381,14 +408,19 @@ namespace Godot
             return false;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this rect and <paramref name="other"/> are equal.
+        /// </summary>
+        /// <param name="other">The other rect to compare.</param>
+        /// <returns>Whether or not the rects are equal.</returns>
         public bool Equals(Rect2 other)
         {
             return _position.Equals(other._position) && _size.Equals(other._size);
         }
 
         /// <summary>
-        /// Returns true if this rect and `other` are approximately equal, by running
-        /// <see cref="Vector2.IsEqualApprox(Vector2)"/> on each component.
+        /// Returns <see langword="true"/> if this rect and <paramref name="other"/> are approximately equal,
+        /// by running <see cref="Vector2.IsEqualApprox(Vector2)"/> on each component.
         /// </summary>
         /// <param name="other">The other rect to compare.</param>
         /// <returns>Whether or not the rects are approximately equal.</returns>
@@ -397,11 +429,19 @@ namespace Godot
             return _position.IsEqualApprox(other._position) && _size.IsEqualApprox(other.Size);
         }
 
+        /// <summary>
+        /// Serves as the hash function for <see cref="Rect2"/>.
+        /// </summary>
+        /// <returns>A hash code for this rect.</returns>
         public override int GetHashCode()
         {
             return _position.GetHashCode() ^ _size.GetHashCode();
         }
 
+        /// <summary>
+        /// Converts this <see cref="Rect2"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this rect.</returns>
         public override string ToString()
         {
             return String.Format("({0}, {1})", new object[]
@@ -411,6 +451,10 @@ namespace Godot
             });
         }
 
+        /// <summary>
+        /// Converts this <see cref="Rect2"/> to a string with the given <paramref name="format"/>.
+        /// </summary>
+        /// <returns>A string representation of this rect.</returns>
         public string ToString(string format)
         {
             return String.Format("({0}, {1})", new object[]
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/StringExtensions.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/StringExtensions.cs
index dcb51267be4..5f8db9a5c3d 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/StringExtensions.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/StringExtensions.cs
@@ -8,6 +8,9 @@ using System.Text.RegularExpressions;
 
 namespace Godot
 {
+    /// <summary>
+    /// Extension methods to manipulate strings.
+    /// </summary>
     public static class StringExtensions
     {
         private static int GetSliceCount(this string instance, string splitter)
@@ -64,6 +67,11 @@ namespace Godot
         /// <summary>
         /// If the string is a path to a file, return the path to the file without the extension.
         /// </summary>
+        /// <seealso cref="Extension(string)"/>
+        /// <seealso cref="GetBaseDir(string)"/>
+        /// <seealso cref="GetFile(string)"/>
+        /// <param name="instance">The path to a file.</param>
+        /// <returns>The path to the file without the extension.</returns>
         public static string BaseName(this string instance)
         {
             int index = instance.LastIndexOf('.');
@@ -75,16 +83,22 @@ namespace Godot
         }
 
         /// <summary>
-        /// Return <see langword="true"/> if the strings begins with the given string.
+        /// Returns <see langword="true"/> if the strings begins
+        /// with the given string <paramref name="text"/>.
         /// </summary>
+        /// <param name="instance">The string to check.</param>
+        /// <param name="text">The beginning string.</param>
+        /// <returns>If the string begins with the given string.</returns>
         public static bool BeginsWith(this string instance, string text)
         {
             return instance.StartsWith(text);
         }
 
         /// <summary>
-        /// Return the bigrams (pairs of consecutive letters) of this string.
+        /// Returns the bigrams (pairs of consecutive letters) of this string.
         /// </summary>
+        /// <param name="instance">The string that will be used.</param>
+        /// <returns>The bigrams of this string.</returns>
         public static string[] Bigrams(this string instance)
         {
             var b = new string[instance.Length - 1];
@@ -99,8 +113,8 @@ namespace Godot
 
         /// <summary>
         /// Converts a string containing a binary number into an integer.
-        /// Binary strings can either be prefixed with `0b` or not,
-        /// and they can also start with a `-` before the optional prefix.
+        /// Binary strings can either be prefixed with <c>0b</c> or not,
+        /// and they can also start with a <c>-</c> before the optional prefix.
         /// </summary>
         /// <param name="instance">The string to convert.</param>
         /// <returns>The converted string.</returns>
@@ -128,8 +142,14 @@ namespace Godot
         }
 
         /// <summary>
-        /// Return the amount of substrings in string.
+        /// Returns the amount of substrings <paramref name="what"/> in the string.
         /// </summary>
+        /// <param name="instance">The string where the substring will be searched.</param>
+        /// <param name="what">The substring that will be counted.</param>
+        /// <param name="caseSensitive">If the search is case sensitive.</param>
+        /// <param name="from">Index to start searching from.</param>
+        /// <param name="to">Index to stop searching at.</param>
+        /// <returns>Amount of substrings in the string.</returns>
         public static int Count(this string instance, string what, bool caseSensitive = true, int from = 0, int to = 0)
         {
             if (what.Length == 0)
@@ -188,8 +208,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Return a copy of the string with special characters escaped using the C language standard.
+        /// Returns a copy of the string with special characters escaped using the C language standard.
         /// </summary>
+        /// <param name="instance">The string to escape.</param>
+        /// <returns>The escaped string.</returns>
         public static string CEscape(this string instance)
         {
             var sb = new StringBuilder(string.Copy(instance));
@@ -210,9 +232,11 @@ namespace Godot
         }
 
         /// <summary>
-        /// Return a copy of the string with escaped characters replaced by their meanings
+        /// Returns a copy of the string with escaped characters replaced by their meanings
         /// according to the C language standard.
         /// </summary>
+        /// <param name="instance">The string to unescape.</param>
+        /// <returns>The unescaped string.</returns>
         public static string CUnescape(this string instance)
         {
             var sb = new StringBuilder(string.Copy(instance));
@@ -233,11 +257,13 @@ namespace Godot
         }
 
         /// <summary>
-        /// Change the case of some letters. Replace underscores with spaces, convert all letters
+        /// Changes the case of some letters. Replace underscores with spaces, convert all letters
         /// to lowercase then capitalize first and every letter following the space character.
         /// For <c>capitalize camelCase mixed_with_underscores</c> it will return
         /// <c>Capitalize Camelcase Mixed With Underscores</c>.
         /// </summary>
+        /// <param name="instance">The string to capitalize.</param>
+        /// <returns>The capitalized string.</returns>
         public static string Capitalize(this string instance)
         {
             string aux = instance.Replace("_", " ").ToLower();
@@ -259,16 +285,27 @@ namespace Godot
         }
 
         /// <summary>
-        /// Perform a case-sensitive comparison to another string, return -1 if less, 0 if equal and +1 if greater.
+        /// Performs a case-sensitive comparison to another string, return -1 if less, 0 if equal and +1 if greater.
         /// </summary>
+        /// <seealso cref="NocasecmpTo(string, string)"/>
+        /// <seealso cref="CompareTo(string, string, bool)"/>
+        /// <param name="instance">The string to compare.</param>
+        /// <param name="to">The other string to compare.</param>
+        /// <returns>-1 if less, 0 if equal and +1 if greater.</returns>
         public static int CasecmpTo(this string instance, string to)
         {
             return instance.CompareTo(to, caseSensitive: true);
         }
 
         /// <summary>
-        /// Perform a comparison to another string, return -1 if less, 0 if equal and +1 if greater.
+        /// Performs a comparison to another string, return -1 if less, 0 if equal and +1 if greater.
         /// </summary>
+        /// <param name="instance">The string to compare.</param>
+        /// <param name="to">The other string to compare.</param>
+        /// <param name="caseSensitive">
+        /// If <see langword="true"/>, the comparison will be case sensitive.
+        /// </param>
+        /// <returns>-1 if less, 0 if equal and +1 if greater.</returns>
         public static int CompareTo(this string instance, string to, bool caseSensitive = true)
         {
             if (instance.Empty())
@@ -321,7 +358,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Return <see langword="true"/> if the string is empty.
+        /// Returns <see langword="true"/> if the string is empty.
         /// </summary>
         public static bool Empty(this string instance)
         {
@@ -329,8 +366,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Return <see langword="true"/> if the strings ends with the given string.
+        /// Returns <see langword="true"/> if the strings ends
+        /// with the given string <paramref name="text"/>.
         /// </summary>
+        /// <param name="instance">The string to check.</param>
+        /// <param name="text">The ending string.</param>
+        /// <returns>If the string ends with the given string.</returns>
         public static bool EndsWith(this string instance, string text)
         {
             return instance.EndsWith(text);
@@ -339,14 +380,36 @@ namespace Godot
         /// <summary>
         /// Erase <paramref name="chars"/> characters from the string starting from <paramref name="pos"/>.
         /// </summary>
+        /// <param name="instance">The string to modify.</param>
+        /// <param name="pos">Starting position from which to erase.</param>
+        /// <param name="chars">Amount of characters to erase.</param>
         public static void Erase(this StringBuilder instance, int pos, int chars)
         {
             instance.Remove(pos, chars);
         }
 
         /// <summary>
-        /// If the string is a path to a file, return the extension.
+        /// Returns the extension without the leading period character (<c>.</c>)
+        /// if the string is a valid file name or path. If the string does not contain
+        /// an extension, returns an empty string instead.
         /// </summary>
+        /// <example>
+        /// <code>
+        /// GD.Print("/path/to/file.txt".GetExtension())  // "txt"
+        /// GD.Print("file.txt".GetExtension())  // "txt"
+        /// GD.Print("file.sample.txt".GetExtension())  // "txt"
+        /// GD.Print(".txt".GetExtension())  // "txt"
+        /// GD.Print("file.txt.".GetExtension())  // "" (empty string)
+        /// GD.Print("file.txt..".GetExtension())  // "" (empty string)
+        /// GD.Print("txt".GetExtension())  // "" (empty string)
+        /// GD.Print("".GetExtension())  // "" (empty string)
+        /// </code>
+        /// </example>
+        /// <seealso cref="BaseName(string)"/>
+        /// <seealso cref="GetBaseDir(string)"/>
+        /// <seealso cref="GetFile(string)"/>
+        /// <param name="instance">The path to a file.</param>
+        /// <returns>The extension of the file or an empty string.</returns>
         public static string Extension(this string instance)
         {
             int pos = instance.FindLast(".");
@@ -360,6 +423,10 @@ namespace Godot
         /// <summary>
         /// Find the first occurrence of a substring. Optionally, the search starting position can be passed.
         /// </summary>
+        /// <param name="instance">The string that will be searched.</param>
+        /// <param name="what">The substring to find.</param>
+        /// <param name="from">The search starting position.</param>
+        /// <param name="caseSensitive">If <see langword="true"/>, the search is case sensitive.</param>
         /// <returns>The starting position of the substring, or -1 if not found.</returns>
         public static int Find(this string instance, string what, int from = 0, bool caseSensitive = true)
         {
@@ -369,6 +436,14 @@ namespace Godot
         /// <summary>
         /// Find the first occurrence of a char. Optionally, the search starting position can be passed.
         /// </summary>
+        /// <seealso cref="Find(string, string, int, bool)"/>
+        /// <seealso cref="FindLast(string, string, bool)"/>
+        /// <seealso cref="FindLast(string, string, int, bool)"/>
+        /// <seealso cref="FindN(string, string, int)"/>
+        /// <param name="instance">The string that will be searched.</param>
+        /// <param name="what">The substring to find.</param>
+        /// <param name="from">The search starting position.</param>
+        /// <param name="caseSensitive">If <see langword="true"/>, the search is case sensitive.</param>
         /// <returns>The first instance of the char, or -1 if not found.</returns>
         public static int Find(this string instance, char what, int from = 0, bool caseSensitive = true)
         {
@@ -378,6 +453,13 @@ namespace Godot
         }
 
         /// <summary>Find the last occurrence of a substring.</summary>
+        /// <seealso cref="Find(string, string, int, bool)"/>
+        /// <seealso cref="Find(string, char, int, bool)"/>
+        /// <seealso cref="FindLast(string, string, int, bool)"/>
+        /// <seealso cref="FindN(string, string, int)"/>
+        /// <param name="instance">The string that will be searched.</param>
+        /// <param name="what">The substring to find.</param>
+        /// <param name="caseSensitive">If <see langword="true"/>, the search is case sensitive.</param>
         /// <returns>The starting position of the substring, or -1 if not found.</returns>
         public static int FindLast(this string instance, string what, bool caseSensitive = true)
         {
@@ -385,6 +467,14 @@ namespace Godot
         }
 
         /// <summary>Find the last occurrence of a substring specifying the search starting position.</summary>
+        /// <seealso cref="Find(string, string, int, bool)"/>
+        /// <seealso cref="Find(string, char, int, bool)"/>
+        /// <seealso cref="FindLast(string, string, bool)"/>
+        /// <seealso cref="FindN(string, string, int)"/>
+        /// <param name="instance">The string that will be searched.</param>
+        /// <param name="what">The substring to find.</param>
+        /// <param name="from">The search starting position.</param>
+        /// <param name="caseSensitive">If <see langword="true"/>, the search is case sensitive.</param>
         /// <returns>The starting position of the substring, or -1 if not found.</returns>
         public static int FindLast(this string instance, string what, int from, bool caseSensitive = true)
         {
@@ -395,6 +485,13 @@ namespace Godot
         /// Find the first occurrence of a substring but search as case-insensitive.
         /// Optionally, the search starting position can be passed.
         /// </summary>
+        /// <seealso cref="Find(string, string, int, bool)"/>
+        /// <seealso cref="Find(string, char, int, bool)"/>
+        /// <seealso cref="FindLast(string, string, bool)"/>
+        /// <seealso cref="FindLast(string, string, int, bool)"/>
+        /// <param name="instance">The string that will be searched.</param>
+        /// <param name="what">The substring to find.</param>
+        /// <param name="from">The search starting position.</param>
         /// <returns>The starting position of the substring, or -1 if not found.</returns>
         public static int FindN(this string instance, string what, int from = 0)
         {
@@ -404,6 +501,11 @@ namespace Godot
         /// <summary>
         /// If the string is a path to a file, return the base directory.
         /// </summary>
+        /// <seealso cref="BaseName(string)"/>
+        /// <seealso cref="Extension(string)"/>
+        /// <seealso cref="GetFile(string)"/>
+        /// <param name="instance">The path to a file.</param>
+        /// <returns>The base directory.</returns>
         public static string GetBaseDir(this string instance)
         {
             int basepos = instance.Find("://");
@@ -441,6 +543,11 @@ namespace Godot
         /// <summary>
         /// If the string is a path to a file, return the file and ignore the base directory.
         /// </summary>
+        /// <seealso cref="BaseName(string)"/>
+        /// <seealso cref="Extension(string)"/>
+        /// <seealso cref="GetBaseDir(string)"/>
+        /// <param name="instance">The path to a file.</param>
+        /// <returns>The file name.</returns>
         public static string GetFile(this string instance)
         {
             int sep = Mathf.Max(instance.FindLast("/"), instance.FindLast("\\"));
@@ -483,6 +590,8 @@ namespace Godot
         /// <summary>
         /// Hash the string and return a 32 bits unsigned integer.
         /// </summary>
+        /// <param name="instance">The string to hash.</param>
+        /// <returns>The calculated hash of the string.</returns>
         public static uint Hash(this string instance)
         {
             uint hash = 5381;
@@ -544,8 +653,8 @@ namespace Godot
 
         /// <summary>
         /// Converts a string containing a hexadecimal number into an integer.
-        /// Hexadecimal strings can either be prefixed with `0x` or not,
-        /// and they can also start with a `-` before the optional prefix.
+        /// Hexadecimal strings can either be prefixed with <c>0x</c> or not,
+        /// and they can also start with a <c>-</c> before the optional prefix.
         /// </summary>
         /// <param name="instance">The string to convert.</param>
         /// <returns>The converted string.</returns>
@@ -573,16 +682,28 @@ namespace Godot
         }
 
         /// <summary>
-        /// Insert a substring at a given position.
+        /// Inserts a substring at a given position.
         /// </summary>
+        /// <param name="instance">The string to modify.</param>
+        /// <param name="pos">Position at which to insert the substring.</param>
+        /// <param name="what">Substring to insert.</param>
+        /// <returns>
+        /// The string with <paramref name="what"/> inserted at the given
+        /// position <paramref name="pos"/>.
+        /// </returns>
         public static string Insert(this string instance, int pos, string what)
         {
             return instance.Insert(pos, what);
         }
 
         /// <summary>
-        /// If the string is a path to a file or directory, return <see langword="true"/> if the path is absolute.
+        /// Returns <see langword="true"/> if the string is a path to a file or
+        /// directory and its startign point is explicitly defined. This includes
+        /// <c>res://</c>, <c>user://</c>, <c>C:\</c>, <c>/</c>, etc.
         /// </summary>
+        /// <seealso cref="IsRelPath(string)"/>
+        /// <param name="instance">The string to check.</param>
+        /// <returns>If the string is an absolute path.</returns>
         public static bool IsAbsPath(this string instance)
         {
             if (string.IsNullOrEmpty(instance))
@@ -594,8 +715,14 @@ namespace Godot
         }
 
         /// <summary>
-        /// If the string is a path to a file or directory, return <see langword="true"/> if the path is relative.
+        /// Returns <see langword="true"/> if the string is a path to a file or
+        /// directory and its starting point is implicitly defined within the
+        /// context it is being used. The starting point may refer to the current
+        /// directory (<c>./</c>), or the current <see cref="Node"/>.
         /// </summary>
+        /// <seealso cref="IsAbsPath(string)"/>
+        /// <param name="instance">The string to check.</param>
+        /// <returns>If the string is a relative path.</returns>
         public static bool IsRelPath(this string instance)
         {
             return !IsAbsPath(instance);
@@ -604,6 +731,11 @@ namespace Godot
         /// <summary>
         /// Check whether this string is a subsequence of the given string.
         /// </summary>
+        /// <seealso cref="IsSubsequenceOfI(string, string)"/>
+        /// <param name="instance">The subsequence to search.</param>
+        /// <param name="text">The string that contains the subsequence.</param>
+        /// <param name="caseSensitive">If <see langword="true"/>, the check is case sensitive.</param>
+        /// <returns>If the string is a subsequence of the given string.</returns>
         public static bool IsSubsequenceOf(this string instance, string text, bool caseSensitive = true)
         {
             int len = instance.Length;
@@ -647,6 +779,10 @@ namespace Godot
         /// <summary>
         /// Check whether this string is a subsequence of the given string, ignoring case differences.
         /// </summary>
+        /// <seealso cref="IsSubsequenceOf(string, string, bool)"/>
+        /// <param name="instance">The subsequence to search.</param>
+        /// <param name="text">The string that contains the subsequence.</param>
+        /// <returns>If the string is a subsequence of the given string.</returns>
         public static bool IsSubsequenceOfI(this string instance, string text)
         {
             return instance.IsSubsequenceOf(text, caseSensitive: false);
@@ -655,6 +791,8 @@ namespace Godot
         /// <summary>
         /// Check whether the string contains a valid <see langword="float"/>.
         /// </summary>
+        /// <param name="instance">The string to check.</param>
+        /// <returns>If the string contains a valid floating point number.</returns>
         public static bool IsValidFloat(this string instance)
         {
             float f;
@@ -664,6 +802,8 @@ namespace Godot
         /// <summary>
         /// Check whether the string contains a valid color in HTML notation.
         /// </summary>
+        /// <param name="instance">The string to check.</param>
+        /// <returns>If the string contains a valid HTML color.</returns>
         public static bool IsValidHtmlColor(this string instance)
         {
             return Color.HtmlIsValid(instance);
@@ -674,6 +814,8 @@ namespace Godot
         /// programming languages, a valid identifier may contain only letters,
         /// digits and underscores (_) and the first character may not be a digit.
         /// </summary>
+        /// <param name="instance">The string to check.</param>
+        /// <returns>If the string contains a valid identifier.</returns>
         public static bool IsValidIdentifier(this string instance)
         {
             int len = instance.Length;
@@ -704,6 +846,8 @@ namespace Godot
         /// <summary>
         /// Check whether the string contains a valid integer.
         /// </summary>
+        /// <param name="instance">The string to check.</param>
+        /// <returns>If the string contains a valid integer.</returns>
         public static bool IsValidInteger(this string instance)
         {
             int f;
@@ -713,6 +857,8 @@ namespace Godot
         /// <summary>
         /// Check whether the string contains a valid IP address.
         /// </summary>
+        /// <param name="instance">The string to check.</param>
+        /// <returns>If the string contains a valid IP address.</returns>
         public static bool IsValidIPAddress(this string instance)
         {
             // TODO: Support IPv6 addresses
@@ -736,8 +882,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Return a copy of the string with special characters escaped using the JSON standard.
+        /// Returns a copy of the string with special characters escaped using the JSON standard.
         /// </summary>
+        /// <param name="instance">The string to escape.</param>
+        /// <returns>The escaped string.</returns>
         public static string JSONEscape(this string instance)
         {
             var sb = new StringBuilder(string.Copy(instance));
@@ -755,8 +903,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Return an amount of characters from the left of the string.
+        /// Returns an amount of characters from the left of the string.
         /// </summary>
+        /// <seealso cref="Right(string, int)"/>
+        /// <param name="instance">The original string.</param>
+        /// <param name="pos">The position in the string where the left side ends.</param>
+        /// <returns>The left side of the string from the given position.</returns>
         public static string Left(this string instance, int pos)
         {
             if (pos <= 0)
@@ -769,8 +921,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Return the length of the string in characters.
+        /// Returns the length of the string in characters.
         /// </summary>
+        /// <param name="instance">The string to check.</param>
+        /// <returns>The length of the string.</returns>
         public static int Length(this string instance)
         {
             return instance.Length;
@@ -779,6 +933,7 @@ namespace Godot
         /// <summary>
         /// Returns a copy of the string with characters removed from the left.
         /// </summary>
+        /// <seealso cref="RStrip(string, string)"/>
         /// <param name="instance">The string to remove characters from.</param>
         /// <param name="chars">The characters to be removed.</param>
         /// <returns>A copy of the string with characters removed from the left.</returns>
@@ -807,6 +962,12 @@ namespace Godot
         /// Do a simple expression match, where '*' matches zero or more
         /// arbitrary characters and '?' matches any single character except '.'.
         /// </summary>
+        /// <param name="instance">The string to check.</param>
+        /// <param name="expr">Expression to check.</param>
+        /// <param name="caseSensitive">
+        /// If <see langword="true"/>, the check will be case sensitive.
+        /// </param>
+        /// <returns>If the expression has any matches.</returns>
         private static bool ExprMatch(this string instance, string expr, bool caseSensitive)
         {
             // case '\0':
@@ -832,6 +993,13 @@ namespace Godot
         /// Do a simple case sensitive expression match, using ? and * wildcards
         /// (see <see cref="ExprMatch(string, string, bool)"/>).
         /// </summary>
+        /// <seealso cref="MatchN(string, string)"/>
+        /// <param name="instance">The string to check.</param>
+        /// <param name="expr">Expression to check.</param>
+        /// <param name="caseSensitive">
+        /// If <see langword="true"/>, the check will be case sensitive.
+        /// </param>
+        /// <returns>If the expression has any matches.</returns>
         public static bool Match(this string instance, string expr, bool caseSensitive = true)
         {
             if (instance.Length == 0 || expr.Length == 0)
@@ -844,6 +1012,10 @@ namespace Godot
         /// Do a simple case insensitive expression match, using ? and * wildcards
         /// (see <see cref="ExprMatch(string, string, bool)"/>).
         /// </summary>
+        /// <seealso cref="Match(string, string, bool)"/>
+        /// <param name="instance">The string to check.</param>
+        /// <param name="expr">Expression to check.</param>
+        /// <returns>If the expression has any matches.</returns>
         public static bool MatchN(this string instance, string expr)
         {
             if (instance.Length == 0 || expr.Length == 0)
@@ -853,8 +1025,11 @@ namespace Godot
         }
 
         /// <summary>
-        /// Return the MD5 hash of the string as an array of bytes.
+        /// Returns the MD5 hash of the string as an array of bytes.
         /// </summary>
+        /// <seealso cref="MD5Text(string)"/>
+        /// <param name="instance">The string to hash.</param>
+        /// <returns>The MD5 hash of the string.</returns>
         public static byte[] MD5Buffer(this string instance)
         {
             return godot_icall_String_md5_buffer(instance);
@@ -864,8 +1039,11 @@ namespace Godot
         internal extern static byte[] godot_icall_String_md5_buffer(string str);
 
         /// <summary>
-        /// Return the MD5 hash of the string as a string.
+        /// Returns the MD5 hash of the string as a string.
         /// </summary>
+        /// <seealso cref="MD5Buffer(string)"/>
+        /// <param name="instance">The string to hash.</param>
+        /// <returns>The MD5 hash of the string.</returns>
         public static string MD5Text(this string instance)
         {
             return godot_icall_String_md5_text(instance);
@@ -877,22 +1055,35 @@ namespace Godot
         /// <summary>
         /// Perform a case-insensitive comparison to another string, return -1 if less, 0 if equal and +1 if greater.
         /// </summary>
+        /// <seealso cref="CasecmpTo(string, string)"/>
+        /// <seealso cref="CompareTo(string, string, bool)"/>
+        /// <param name="instance">The string to compare.</param>
+        /// <param name="to">The other string to compare.</param>
+        /// <returns>-1 if less, 0 if equal and +1 if greater.</returns>
         public static int NocasecmpTo(this string instance, string to)
         {
             return instance.CompareTo(to, caseSensitive: false);
         }
 
         /// <summary>
-        /// Return the character code at position <paramref name="at"/>.
+        /// Returns the character code at position <paramref name="at"/>.
         /// </summary>
+        /// <param name="instance">The string to check.</param>
+        /// <param name="at">The position int the string for the character to check.</param>
+        /// <returns>The character code.</returns>
         public static int OrdAt(this string instance, int at)
         {
             return instance[at];
         }
 
         /// <summary>
-        /// Format a number to have an exact number of <paramref name="digits"/> after the decimal point.
+        /// Format a number to have an exact number of <paramref name="digits"/>
+        /// after the decimal point.
         /// </summary>
+        /// <seealso cref="PadZeros(string, int)"/>
+        /// <param name="instance">The string to pad.</param>
+        /// <param name="digits">Amount of digits after the decimal point.</param>
+        /// <returns>The string padded with zeroes.</returns>
         public static string PadDecimals(this string instance, int digits)
         {
             int c = instance.Find(".");
@@ -927,8 +1118,13 @@ namespace Godot
         }
 
         /// <summary>
-        /// Format a number to have an exact number of <paramref name="digits"/> before the decimal point.
+        /// Format a number to have an exact number of <paramref name="digits"/>
+        /// before the decimal point.
         /// </summary>
+        /// <seealso cref="PadDecimals(string, int)"/>
+        /// <param name="instance">The string to pad.</param>
+        /// <param name="digits">Amount of digits before the decimal point.</param>
+        /// <returns>The string padded with zeroes.</returns>
         public static string PadZeros(this string instance, int digits)
         {
             string s = instance;
@@ -968,17 +1164,23 @@ namespace Godot
         }
 
         /// <summary>
-        /// Percent-encode a string. This is meant to encode parameters in a URL when sending a HTTP GET request and bodies of form-urlencoded POST request.
+        /// Percent-encode a string. This is meant to encode parameters in a URL
+        /// when sending a HTTP GET request and bodies of form-urlencoded POST request.
         /// </summary>
+        /// <seealso cref="PercentDecode(string)"/>
         public static string PercentEncode(this string instance)
         {
             return Uri.EscapeDataString(instance);
         }
 
         /// <summary>
-        /// If the string is a path, this concatenates <paramref name="file"/> at the end of the string as a subpath.
+        /// If the string is a path, this concatenates <paramref name="file"/>
+        /// at the end of the string as a subpath.
         /// E.g. <c>"this/is".PlusFile("path") == "this/is/path"</c>.
         /// </summary>
+        /// <param name="instance">The path that will be concatenated.</param>
+        /// <param name="file">File name to concatenate with the path.</param>
+        /// <returns>The concatenated path with the given file name.</returns>
         public static string PlusFile(this string instance, string file)
         {
             if (instance.Length > 0 && instance[instance.Length - 1] == '/')
@@ -989,6 +1191,11 @@ namespace Godot
         /// <summary>
         /// Replace occurrences of a substring for different ones inside the string.
         /// </summary>
+        /// <seealso cref="ReplaceN(string, string, string)"/>
+        /// <param name="instance">The string to modify.</param>
+        /// <param name="what">The substring to be replaced in the string.</param>
+        /// <param name="forwhat">The substring that replaces <paramref name="what"/>.</param>
+        /// <returns>The string with the substring occurrences replaced.</returns>
         public static string Replace(this string instance, string what, string forwhat)
         {
             return instance.Replace(what, forwhat);
@@ -997,6 +1204,11 @@ namespace Godot
         /// <summary>
         /// Replace occurrences of a substring for different ones inside the string, but search case-insensitive.
         /// </summary>
+        /// <seealso cref="Replace(string, string, string)"/>
+        /// <param name="instance">The string to modify.</param>
+        /// <param name="what">The substring to be replaced in the string.</param>
+        /// <param name="forwhat">The substring that replaces <paramref name="what"/>.</param>
+        /// <returns>The string with the substring occurrences replaced.</returns>
         public static string ReplaceN(this string instance, string what, string forwhat)
         {
             return Regex.Replace(instance, what, forwhat, RegexOptions.IgnoreCase);
@@ -1005,6 +1217,11 @@ namespace Godot
         /// <summary>
         /// Perform a search for a substring, but start from the end of the string instead of the beginning.
         /// </summary>
+        /// <seealso cref="RFindN(string, string, int)"/>
+        /// <param name="instance">The string that will be searched.</param>
+        /// <param name="what">The substring to search in the string.</param>
+        /// <param name="from">The position at which to start searching.</param>
+        /// <returns>The position at which the substring was found, or -1 if not found.</returns>
         public static int RFind(this string instance, string what, int from = -1)
         {
             return godot_icall_String_rfind(instance, what, from);
@@ -1017,6 +1234,11 @@ namespace Godot
         /// Perform a search for a substring, but start from the end of the string instead of the beginning.
         /// Also search case-insensitive.
         /// </summary>
+        /// <seealso cref="RFind(string, string, int)"/>
+        /// <param name="instance">The string that will be searched.</param>
+        /// <param name="what">The substring to search in the string.</param>
+        /// <param name="from">The position at which to start searching.</param>
+        /// <returns>The position at which the substring was found, or -1 if not found.</returns>
         public static int RFindN(this string instance, string what, int from = -1)
         {
             return godot_icall_String_rfindn(instance, what, from);
@@ -1026,8 +1248,12 @@ namespace Godot
         internal extern static int godot_icall_String_rfindn(string str, string what, int from);
 
         /// <summary>
-        /// Return the right side of the string from a given position.
+        /// Returns the right side of the string from a given position.
         /// </summary>
+        /// <seealso cref="Left(string, int)"/>
+        /// <param name="instance">The original string.</param>
+        /// <param name="pos">The position in the string from which the right side starts.</param>
+        /// <returns>The right side of the string from the given position.</returns>
         public static string Right(this string instance, int pos)
         {
             if (pos >= instance.Length)
@@ -1042,6 +1268,7 @@ namespace Godot
         /// <summary>
         /// Returns a copy of the string with characters removed from the right.
         /// </summary>
+        /// <seealso cref="LStrip(string, string)"/>
         /// <param name="instance">The string to remove characters from.</param>
         /// <param name="chars">The characters to be removed.</param>
         /// <returns>A copy of the string with characters removed from the right.</returns>
@@ -1066,6 +1293,12 @@ namespace Godot
             return instance.Substr(0, end + 1);
         }
 
+        /// <summary>
+        /// Returns the SHA-256 hash of the string as an array of bytes.
+        /// </summary>
+        /// <seealso cref="SHA256Text(string)"/>
+        /// <param name="instance">The string to hash.</param>
+        /// <returns>The SHA-256 hash of the string.</returns>
         public static byte[] SHA256Buffer(this string instance)
         {
             return godot_icall_String_sha256_buffer(instance);
@@ -1075,8 +1308,11 @@ namespace Godot
         internal extern static byte[] godot_icall_String_sha256_buffer(string str);
 
         /// <summary>
-        /// Return the SHA-256 hash of the string as a string.
+        /// Returns the SHA-256 hash of the string as a string.
         /// </summary>
+        /// <seealso cref="SHA256Buffer(string)"/>
+        /// <param name="instance">The string to hash.</param>
+        /// <returns>The SHA-256 hash of the string.</returns>
         public static string SHA256Text(this string instance)
         {
             return godot_icall_String_sha256_text(instance);
@@ -1086,9 +1322,12 @@ namespace Godot
         internal extern static string godot_icall_String_sha256_text(string str);
 
         /// <summary>
-        /// Return the similarity index of the text compared to this string.
+        /// Returns the similarity index of the text compared to this string.
         /// 1 means totally similar and 0 means totally dissimilar.
         /// </summary>
+        /// <param name="instance">The string to compare.</param>
+        /// <param name="text">The other string to compare.</param>
+        /// <returns>The similarity index.</returns>
         public static float Similarity(this string instance, string text)
         {
             if (instance == text)
@@ -1141,6 +1380,13 @@ namespace Godot
         /// Split the string by a divisor string, return an array of the substrings.
         /// Example "One,Two,Three" will return ["One","Two","Three"] if split by ",".
         /// </summary>
+        /// <seealso cref="SplitFloats(string, string, bool)"/>
+        /// <param name="instance">The string to split.</param>
+        /// <param name="divisor">The divisor string that splits the string.</param>
+        /// <param name="allowEmpty">
+        /// If <see langword="true"/>, the array may include empty strings.
+        /// </param>
+        /// <returns>The array of strings split from the string.</returns>
         public static string[] Split(this string instance, string divisor, bool allowEmpty = true)
         {
             return instance.Split(new[] { divisor }, allowEmpty ? StringSplitOptions.None : StringSplitOptions.RemoveEmptyEntries);
@@ -1150,6 +1396,13 @@ namespace Godot
         /// Split the string in floats by using a divisor string, return an array of the substrings.
         /// Example "1,2.5,3" will return [1,2.5,3] if split by ",".
         /// </summary>
+        /// <seealso cref="Split(string, string, bool)"/>
+        /// <param name="instance">The string to split.</param>
+        /// <param name="divisor">The divisor string that splits the string.</param>
+        /// <param name="allowEmpty">
+        /// If <see langword="true"/>, the array may include empty floats.
+        /// </param>
+        /// <returns>The array of floats split from the string.</returns>
         public static float[] SplitFloats(this string instance, string divisor, bool allowEmpty = true)
         {
             var ret = new List<float>();
@@ -1182,9 +1435,13 @@ namespace Godot
         };
 
         /// <summary>
-        /// Return a copy of the string stripped of any non-printable character at the beginning and the end.
+        /// Returns a copy of the string stripped of any non-printable character at the beginning and the end.
         /// The optional arguments are used to toggle stripping on the left and right edges respectively.
         /// </summary>
+        /// <param name="instance">The string to strip.</param>
+        /// <param name="left">If the left side should be stripped.</param>
+        /// <param name="right">If the right side should be stripped.</param>
+        /// <returns>The string stripped of any non-printable characters.</returns>
         public static string StripEdges(this string instance, bool left = true, bool right = true)
         {
             if (left)
@@ -1198,8 +1455,14 @@ namespace Godot
         }
 
         /// <summary>
-        /// Return part of the string from the position <paramref name="from"/>, with length <paramref name="len"/>.
+        /// Returns part of the string from the position <paramref name="from"/>, with length <paramref name="len"/>.
         /// </summary>
+        /// <param name="instance">The string to slice.</param>
+        /// <param name="from">The position in the string that the part starts from.</param>
+        /// <param name="len">The length of the returned part.</param>
+        /// <returns>
+        /// Part of the string from the position <paramref name="from"/>, with length <paramref name="len"/>.
+        /// </returns>
         public static string Substr(this string instance, int from, int len)
         {
             int max = instance.Length - from;
@@ -1207,69 +1470,93 @@ namespace Godot
         }
 
         /// <summary>
-        /// Convert the String (which is a character array) to PoolByteArray (which is an array of bytes).
+        /// Converts the String (which is a character array) to PoolByteArray (which is an array of bytes).
         /// The conversion is speeded up in comparison to <see cref="ToUTF8(string)"/> with the assumption
         /// that all the characters the String contains are only ASCII characters.
         /// </summary>
+        /// <seealso cref="ToUTF8(string)"/>
+        /// <param name="instance">The string to convert.</param>
+        /// <returns>The string as ASCII encoded bytes.</returns>
         public static byte[] ToAscii(this string instance)
         {
             return Encoding.ASCII.GetBytes(instance);
         }
 
         /// <summary>
-        /// Convert a string, containing a decimal number, into a <see langword="float" />.
+        /// Converts a string, containing a decimal number, into a <see langword="float" />.
         /// </summary>
+        /// <seealso cref="ToInt(string)"/>
+        /// <param name="instance">The string to convert.</param>
+        /// <returns>The number representation of the string.</returns>
         public static float ToFloat(this string instance)
         {
             return float.Parse(instance);
         }
 
         /// <summary>
-        /// Convert a string, containing an integer number, into an <see langword="int" />.
+        /// Converts a string, containing an integer number, into an <see langword="int" />.
         /// </summary>
+        /// <seealso cref="ToFloat(string)"/>
+        /// <param name="instance">The string to convert.</param>
+        /// <returns>The number representation of the string.</returns>
         public static int ToInt(this string instance)
         {
             return int.Parse(instance);
         }
 
         /// <summary>
-        /// Return the string converted to lowercase.
+        /// Returns the string converted to lowercase.
         /// </summary>
+        /// <seealso cref="ToUpper(string)"/>
+        /// <param name="instance">The string to convert.</param>
+        /// <returns>The string converted to lowercase.</returns>
         public static string ToLower(this string instance)
         {
             return instance.ToLower();
         }
 
         /// <summary>
-        /// Return the string converted to uppercase.
+        /// Returns the string converted to uppercase.
         /// </summary>
+        /// <seealso cref="ToLower(string)"/>
+        /// <param name="instance">The string to convert.</param>
+        /// <returns>The string converted to uppercase.</returns>
         public static string ToUpper(this string instance)
         {
             return instance.ToUpper();
         }
 
         /// <summary>
-        /// Convert the String (which is an array of characters) to PoolByteArray (which is an array of bytes).
+        /// Converts the String (which is an array of characters) to PoolByteArray (which is an array of bytes).
         /// The conversion is a bit slower than <see cref="ToAscii(string)"/>, but supports all UTF-8 characters.
         /// Therefore, you should prefer this function over <see cref="ToAscii(string)"/>.
         /// </summary>
+        /// <seealso cref="ToAscii(string)"/>
+        /// <param name="instance">The string to convert.</param>
+        /// <returns>The string as UTF-8 encoded bytes.</returns>
         public static byte[] ToUTF8(this string instance)
         {
             return Encoding.UTF8.GetBytes(instance);
         }
 
         /// <summary>
-        /// Return a copy of the string with special characters escaped using the XML standard.
+        /// Returns a copy of the string with special characters escaped using the XML standard.
         /// </summary>
+        /// <seealso cref="XMLUnescape(string)"/>
+        /// <param name="instance">The string to escape.</param>
+        /// <returns>The escaped string.</returns>
         public static string XMLEscape(this string instance)
         {
             return SecurityElement.Escape(instance);
         }
 
         /// <summary>
-        /// Return a copy of the string with escaped characters replaced by their meanings
+        /// Returns a copy of the string with escaped characters replaced by their meanings
         /// according to the XML standard.
         /// </summary>
+        /// <seealso cref="XMLEscape(string)"/>
+        /// <param name="instance">The string to unescape.</param>
+        /// <returns>The unescaped string.</returns>
         public static string XMLUnescape(this string instance)
         {
             return SecurityElement.FromString(instance).Text;
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform.cs
index e8eef0f9ac5..974353054de 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform.cs
@@ -28,12 +28,13 @@ namespace Godot
         public Basis basis;
 
         /// <summary>
-        /// The origin vector (column 3, the fourth column). Equivalent to array index `[3]`.
+        /// The origin vector (column 3, the fourth column). Equivalent to array index <c>[3]</c>.
         /// </summary>
         public Vector3 origin;
 
         /// <summary>
-        /// Access whole columns in the form of Vector3. The fourth column is the origin vector.
+        /// Access whole columns in the form of <see cref="Vector3"/>.
+        /// The fourth column is the <see cref="origin"/> vector.
         /// </summary>
         /// <param name="column">Which column vector.</param>
         public Vector3 this[int column]
@@ -77,7 +78,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Access matrix elements in column-major order. The fourth column is the origin vector.
+        /// Access matrix elements in column-major order.
+        /// The fourth column is the <see cref="origin"/> vector.
         /// </summary>
         /// <param name="column">Which column, the matrix horizontal position.</param>
         /// <param name="row">Which row, the matrix vertical position.</param>
@@ -106,6 +108,7 @@ namespace Godot
         /// Returns the inverse of the transform, under the assumption that
         /// the transformation is composed of rotation, scaling, and translation.
         /// </summary>
+        /// <seealso cref="Inverse"/>
         /// <returns>The inverse transformation matrix.</returns>
         public Transform AffineInverse()
         {
@@ -114,7 +117,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Interpolates this transform to the other `transform` by `weight`.
+        /// Interpolates this transform to the other <paramref name="transform"/> by <paramref name="weight"/>.
         /// </summary>
         /// <param name="transform">The other transform.</param>
         /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
@@ -152,11 +155,11 @@ namespace Godot
 
         /// <summary>
         /// Returns a copy of the transform rotated such that its
-        /// -Z axis (forward) points towards the target position.
+        /// -Z axis (forward) points towards the <paramref name="target"/> position.
         ///
-        /// The transform will first be rotated around the given up vector,
-        /// and then fully aligned to the target by a further rotation around
-        /// an axis perpendicular to both the target and up vectors.
+        /// The transform will first be rotated around the given <paramref name="up"/> vector,
+        /// and then fully aligned to the <paramref name="target"/> by a further rotation around
+        /// an axis perpendicular to both the <paramref name="target"/> and <paramref name="up"/> vectors.
         ///
         /// Operations take place in global space.
         /// </summary>
@@ -181,7 +184,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Rotates the transform around the given `axis` by `phi` (in radians),
+        /// Rotates the transform around the given <paramref name="axis"/> by <paramref name="phi"/> (in radians),
         /// using matrix multiplication. The axis must be a normalized vector.
         /// </summary>
         /// <param name="axis">The axis to rotate around. Must be normalized.</param>
@@ -226,7 +229,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Translates the transform by the given `offset`,
+        /// Translates the transform by the given <paramref name="offset"/>,
         /// relative to the transform's basis vectors.
         ///
         /// Unlike <see cref="Rotated"/> and <see cref="Scaled"/>,
@@ -247,6 +250,7 @@ namespace Godot
         /// <summary>
         /// Returns a vector transformed (multiplied) by this transformation matrix.
         /// </summary>
+        /// <seealso cref="XformInv(Vector3)"/>
         /// <param name="v">A vector to transform.</param>
         /// <returns>The transformed vector.</returns>
         public Vector3 Xform(Vector3 v)
@@ -265,6 +269,7 @@ namespace Godot
         /// Note: This results in a multiplication by the inverse of the
         /// transformation matrix only if it represents a rotation-reflection.
         /// </summary>
+        /// <seealso cref="Xform(Vector3)"/>
         /// <param name="v">A vector to inversely transform.</param>
         /// <returns>The inversely transformed vector.</returns>
         public Vector3 XformInv(Vector3 v)
@@ -287,25 +292,25 @@ namespace Godot
 
         /// <summary>
         /// The identity transform, with no translation, rotation, or scaling applied.
-        /// This is used as a replacement for `Transform()` in GDScript.
-        /// Do not use `new Transform()` with no arguments in C#, because it sets all values to zero.
+        /// This is used as a replacement for <c>Transform()</c> in GDScript.
+        /// Do not use <c>new Transform()</c> with no arguments in C#, because it sets all values to zero.
         /// </summary>
-        /// <value>Equivalent to `new Transform(Vector3.Right, Vector3.Up, Vector3.Back, Vector3.Zero)`.</value>
+        /// <value>Equivalent to <c>new Transform(Vector3.Right, Vector3.Up, Vector3.Back, Vector3.Zero)</c>.</value>
         public static Transform Identity { get { return _identity; } }
         /// <summary>
         /// The transform that will flip something along the X axis.
         /// </summary>
-        /// <value>Equivalent to `new Transform(Vector3.Left, Vector3.Up, Vector3.Back, Vector3.Zero)`.</value>
+        /// <value>Equivalent to <c>new Transform(Vector3.Left, Vector3.Up, Vector3.Back, Vector3.Zero)</c>.</value>
         public static Transform FlipX { get { return _flipX; } }
         /// <summary>
         /// The transform that will flip something along the Y axis.
         /// </summary>
-        /// <value>Equivalent to `new Transform(Vector3.Right, Vector3.Down, Vector3.Back, Vector3.Zero)`.</value>
+        /// <value>Equivalent to <c>new Transform(Vector3.Right, Vector3.Down, Vector3.Back, Vector3.Zero)</c>.</value>
         public static Transform FlipY { get { return _flipY; } }
         /// <summary>
         /// The transform that will flip something along the Z axis.
         /// </summary>
-        /// <value>Equivalent to `new Transform(Vector3.Right, Vector3.Up, Vector3.Forward, Vector3.Zero)`.</value>
+        /// <value>Equivalent to <c>new Transform(Vector3.Right, Vector3.Up, Vector3.Forward, Vector3.Zero)</c>.</value>
         public static Transform FlipZ { get { return _flipZ; } }
 
         /// <summary>
@@ -322,9 +327,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a transformation matrix from the given quaternion and origin vector.
+        /// Constructs a transformation matrix from the given <paramref name="quat"/>
+        /// and <paramref name="origin"/> vector.
         /// </summary>
-        /// <param name="quat">The <see cref="Godot.Quat"/> to create the basis from.</param>
+        /// <param name="quat">The <see cref="Quat"/> to create the basis from.</param>
         /// <param name="origin">The origin vector, or column index 3.</param>
         public Transform(Quat quat, Vector3 origin)
         {
@@ -333,9 +339,10 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a transformation matrix from the given basis and origin vector.
+        /// Constructs a transformation matrix from the given <paramref name="basis"/> and
+        /// <paramref name="origin"/> vector.
         /// </summary>
-        /// <param name="basis">The <see cref="Godot.Basis"/> to create the basis from.</param>
+        /// <param name="basis">The <see cref="Basis"/> to create the basis from.</param>
         /// <param name="origin">The origin vector, or column index 3.</param>
         public Transform(Basis basis, Vector3 origin)
         {
@@ -360,6 +367,11 @@ namespace Godot
             return !left.Equals(right);
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this transform and <paramref name="obj"/> are equal.
+        /// </summary>
+        /// <param name="obj">The other object to compare.</param>
+        /// <returns>Whether or not the transform and the other object are equal.</returns>
         public override bool Equals(object obj)
         {
             if (obj is Transform)
@@ -370,14 +382,19 @@ namespace Godot
             return false;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this transform and <paramref name="other"/> are equal.
+        /// </summary>
+        /// <param name="other">The other transform to compare.</param>
+        /// <returns>Whether or not the matrices are equal.</returns>
         public bool Equals(Transform other)
         {
             return basis.Equals(other.basis) && origin.Equals(other.origin);
         }
 
         /// <summary>
-        /// Returns true if this transform and `other` are approximately equal, by running
-        /// <see cref="Vector3.IsEqualApprox(Vector3)"/> on each component.
+        /// Returns <see langword="true"/> if this transform and <paramref name="other"/> are approximately equal,
+        /// by running <see cref="Vector3.IsEqualApprox(Vector3)"/> on each component.
         /// </summary>
         /// <param name="other">The other transform to compare.</param>
         /// <returns>Whether or not the matrices are approximately equal.</returns>
@@ -386,11 +403,19 @@ namespace Godot
             return basis.IsEqualApprox(other.basis) && origin.IsEqualApprox(other.origin);
         }
 
+        /// <summary>
+        /// Serves as the hash function for <see cref="Transform"/>.
+        /// </summary>
+        /// <returns>A hash code for this transform.</returns>
         public override int GetHashCode()
         {
             return basis.GetHashCode() ^ origin.GetHashCode();
         }
 
+        /// <summary>
+        /// Converts this <see cref="Transform"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this transform.</returns>
         public override string ToString()
         {
             return String.Format("{0} - {1}", new object[]
@@ -400,6 +425,10 @@ namespace Godot
             });
         }
 
+        /// <summary>
+        /// Converts this <see cref="Transform"/> to a string with the given <paramref name="format"/>.
+        /// </summary>
+        /// <returns>A string representation of this transform.</returns>
         public string ToString(string format)
         {
             return String.Format("{0} - {1}", new object[]
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform2D.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform2D.cs
index c850ec39b21..f3f71beb86f 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform2D.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform2D.cs
@@ -21,18 +21,18 @@ namespace Godot
     public struct Transform2D : IEquatable<Transform2D>
     {
         /// <summary>
-        /// The basis matrix's X vector (column 0). Equivalent to array index `[0]`.
+        /// The basis matrix's X vector (column 0). Equivalent to array index <c>[0]</c>.
         /// </summary>
         /// <value></value>
         public Vector2 x;
 
         /// <summary>
-        /// The basis matrix's Y vector (column 1). Equivalent to array index `[1]`.
+        /// The basis matrix's Y vector (column 1). Equivalent to array index <c>[1]</c>.
         /// </summary>
         public Vector2 y;
 
         /// <summary>
-        /// The origin vector (column 2, the third column). Equivalent to array index `[2]`.
+        /// The origin vector (column 2, the third column). Equivalent to array index <c>[2]</c>.
         /// The origin vector represents translation.
         /// </summary>
         public Vector2 origin;
@@ -77,7 +77,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Access whole columns in the form of Vector2. The third column is the origin vector.
+        /// Access whole columns in the form of <see cref="Vector2"/>.
+        /// The third column is the <see cref="origin"/> vector.
         /// </summary>
         /// <param name="column">Which column vector.</param>
         public Vector2 this[int column]
@@ -116,7 +117,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Access matrix elements in column-major order. The third column is the origin vector.
+        /// Access matrix elements in column-major order.
+        /// The third column is the <see cref="origin"/> vector.
         /// </summary>
         /// <param name="column">Which column, the matrix horizontal position.</param>
         /// <param name="row">Which row, the matrix vertical position.</param>
@@ -138,6 +140,7 @@ namespace Godot
         /// Returns the inverse of the transform, under the assumption that
         /// the transformation is composed of rotation, scaling, and translation.
         /// </summary>
+        /// <seealso cref="Inverse"/>
         /// <returns>The inverse transformation matrix.</returns>
         public Transform2D AffineInverse()
         {
@@ -178,8 +181,9 @@ namespace Godot
 
         /// <summary>
         /// Returns a vector transformed (multiplied) by the basis matrix.
-        /// This method does not account for translation (the origin vector).
+        /// This method does not account for translation (the <see cref="origin"/> vector).
         /// </summary>
+        /// <seealso cref="BasisXformInv(Vector2)"/>
         /// <param name="v">A vector to transform.</param>
         /// <returns>The transformed vector.</returns>
         public Vector2 BasisXform(Vector2 v)
@@ -189,11 +193,12 @@ namespace Godot
 
         /// <summary>
         /// Returns a vector transformed (multiplied) by the inverse basis matrix.
-        /// This method does not account for translation (the origin vector).
+        /// This method does not account for translation (the <see cref="origin"/> vector).
         ///
         /// Note: This results in a multiplication by the inverse of the
         /// basis matrix only if it represents a rotation-reflection.
         /// </summary>
+        /// <seealso cref="BasisXform(Vector2)"/>
         /// <param name="v">A vector to inversely transform.</param>
         /// <returns>The inversely transformed vector.</returns>
         public Vector2 BasisXformInv(Vector2 v)
@@ -202,7 +207,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Interpolates this transform to the other `transform` by `weight`.
+        /// Interpolates this transform to the other <paramref name="transform"/> by <paramref name="weight"/>.
         /// </summary>
         /// <param name="transform">The other transform.</param>
         /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
@@ -293,7 +298,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Rotates the transform by `phi` (in radians), using matrix multiplication.
+        /// Rotates the transform by <paramref name="phi"/> (in radians), using matrix multiplication.
         /// </summary>
         /// <param name="phi">The angle to rotate, in radians.</param>
         /// <returns>The rotated transformation matrix.</returns>
@@ -335,7 +340,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Translates the transform by the given `offset`,
+        /// Translates the transform by the given <paramref name="offset"/>,
         /// relative to the transform's basis vectors.
         ///
         /// Unlike <see cref="Rotated"/> and <see cref="Scaled"/>,
@@ -353,6 +358,7 @@ namespace Godot
         /// <summary>
         /// Returns a vector transformed (multiplied) by this transformation matrix.
         /// </summary>
+        /// <seealso cref="XformInv(Vector2)"/>
         /// <param name="v">A vector to transform.</param>
         /// <returns>The transformed vector.</returns>
         public Vector2 Xform(Vector2 v)
@@ -363,6 +369,7 @@ namespace Godot
         /// <summary>
         /// Returns a vector transformed (multiplied) by the inverse transformation matrix.
         /// </summary>
+        /// <seealso cref="Xform(Vector2)"/>
         /// <param name="v">A vector to inversely transform.</param>
         /// <returns>The inversely transformed vector.</returns>
         public Vector2 XformInv(Vector2 v)
@@ -378,20 +385,20 @@ namespace Godot
 
         /// <summary>
         /// The identity transform, with no translation, rotation, or scaling applied.
-        /// This is used as a replacement for `Transform2D()` in GDScript.
-        /// Do not use `new Transform2D()` with no arguments in C#, because it sets all values to zero.
+        /// This is used as a replacement for <c>Transform2D()</c> in GDScript.
+        /// Do not use <c>new Transform2D()</c> with no arguments in C#, because it sets all values to zero.
         /// </summary>
-        /// <value>Equivalent to `new Transform2D(Vector2.Right, Vector2.Down, Vector2.Zero)`.</value>
+        /// <value>Equivalent to <c>new Transform2D(Vector2.Right, Vector2.Down, Vector2.Zero)</c>.</value>
         public static Transform2D Identity { get { return _identity; } }
         /// <summary>
         /// The transform that will flip something along the X axis.
         /// </summary>
-        /// <value>Equivalent to `new Transform2D(Vector2.Left, Vector2.Down, Vector2.Zero)`.</value>
+        /// <value>Equivalent to <c>new Transform2D(Vector2.Left, Vector2.Down, Vector2.Zero)</c>.</value>
         public static Transform2D FlipX { get { return _flipX; } }
         /// <summary>
         /// The transform that will flip something along the Y axis.
         /// </summary>
-        /// <value>Equivalent to `new Transform2D(Vector2.Right, Vector2.Up, Vector2.Zero)`.</value>
+        /// <value>Equivalent to <c>new Transform2D(Vector2.Right, Vector2.Up, Vector2.Zero)</c>.</value>
         public static Transform2D FlipY { get { return _flipY; } }
 
         /// <summary>
@@ -411,12 +418,12 @@ namespace Godot
         /// Constructs a transformation matrix from the given components.
         /// Arguments are named such that xy is equal to calling x.y
         /// </summary>
-        /// <param name="xx">The X component of the X column vector, accessed via `t.x.x` or `[0][0]`</param>
-        /// <param name="xy">The Y component of the X column vector, accessed via `t.x.y` or `[0][1]`</param>
-        /// <param name="yx">The X component of the Y column vector, accessed via `t.y.x` or `[1][0]`</param>
-        /// <param name="yy">The Y component of the Y column vector, accessed via `t.y.y` or `[1][1]`</param>
-        /// <param name="ox">The X component of the origin vector, accessed via `t.origin.x` or `[2][0]`</param>
-        /// <param name="oy">The Y component of the origin vector, accessed via `t.origin.y` or `[2][1]`</param>
+        /// <param name="xx">The X component of the X column vector, accessed via <c>t.x.x</c> or <c>[0][0]</c></param>
+        /// <param name="xy">The Y component of the X column vector, accessed via <c>t.x.y</c> or <c>[0][1]</c></param>
+        /// <param name="yx">The X component of the Y column vector, accessed via <c>t.y.x</c> or <c>[1][0]</c></param>
+        /// <param name="yy">The Y component of the Y column vector, accessed via <c>t.y.y</c> or <c>[1][1]</c></param>
+        /// <param name="ox">The X component of the origin vector, accessed via <c>t.origin.x</c> or <c>[2][0]</c></param>
+        /// <param name="oy">The Y component of the origin vector, accessed via <c>t.origin.y</c> or <c>[2][1]</c></param>
         public Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy)
         {
             x = new Vector2(xx, xy);
@@ -425,16 +432,17 @@ namespace Godot
         }
 
         /// <summary>
-        /// Constructs a transformation matrix from a rotation value and origin vector.
+        /// Constructs a transformation matrix from a <paramref name="rotation"/> value and
+        /// <paramref name="origin"/> vector.
         /// </summary>
-        /// <param name="rot">The rotation of the new transform, in radians.</param>
-        /// <param name="pos">The origin vector, or column index 2.</param>
-        public Transform2D(real_t rot, Vector2 pos)
+        /// <param name="rotation">The rotation of the new transform, in radians.</param>
+        /// <param name="origin">The origin vector, or column index 2.</param>
+        public Transform2D(real_t rotation, Vector2 origin)
         {
-            x.x = y.y = Mathf.Cos(rot);
-            x.y = y.x = Mathf.Sin(rot);
+            x.x = y.y = Mathf.Cos(rotation);
+            x.y = y.x = Mathf.Sin(rotation);
             y.x *= -1;
-            origin = pos;
+            this.origin = origin;
         }
 
         public static Transform2D operator *(Transform2D left, Transform2D right)
@@ -464,19 +472,29 @@ namespace Godot
             return !left.Equals(right);
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this transform and <paramref name="obj"/> are equal.
+        /// </summary>
+        /// <param name="obj">The other object to compare.</param>
+        /// <returns>Whether or not the transform and the other object are equal.</returns>
         public override bool Equals(object obj)
         {
             return obj is Transform2D transform2D && Equals(transform2D);
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this transform and <paramref name="other"/> are equal.
+        /// </summary>
+        /// <param name="other">The other transform to compare.</param>
+        /// <returns>Whether or not the matrices are equal.</returns>
         public bool Equals(Transform2D other)
         {
             return x.Equals(other.x) && y.Equals(other.y) && origin.Equals(other.origin);
         }
 
         /// <summary>
-        /// Returns true if this transform and `other` are approximately equal, by running
-        /// <see cref="Vector2.IsEqualApprox(Vector2)"/> on each component.
+        /// Returns <see langword="true"/> if this transform and <paramref name="other"/> are approximately equal,
+        /// by running <see cref="Vector2.IsEqualApprox(Vector2)"/> on each component.
         /// </summary>
         /// <param name="other">The other transform to compare.</param>
         /// <returns>Whether or not the matrices are approximately equal.</returns>
@@ -485,11 +503,19 @@ namespace Godot
             return x.IsEqualApprox(other.x) && y.IsEqualApprox(other.y) && origin.IsEqualApprox(other.origin);
         }
 
+        /// <summary>
+        /// Serves as the hash function for <see cref="Transform2D"/>.
+        /// </summary>
+        /// <returns>A hash code for this transform.</returns>
         public override int GetHashCode()
         {
             return x.GetHashCode() ^ y.GetHashCode() ^ origin.GetHashCode();
         }
 
+        /// <summary>
+        /// Converts this <see cref="Transform2D"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this transform.</returns>
         public override string ToString()
         {
             return String.Format("({0}, {1}, {2})", new object[]
@@ -500,6 +526,10 @@ namespace Godot
             });
         }
 
+        /// <summary>
+        /// Converts this <see cref="Transform2D"/> to a string with the given <paramref name="format"/>.
+        /// </summary>
+        /// <returns>A string representation of this transform.</returns>
         public string ToString(string format)
         {
             return String.Format("({0}, {1}, {2})", new object[]
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/UnhandledExceptionArgs.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/UnhandledExceptionArgs.cs
index be016745689..eae8927ceb9 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/UnhandledExceptionArgs.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/UnhandledExceptionArgs.cs
@@ -8,7 +8,7 @@ namespace Godot
     public class UnhandledExceptionArgs
     {
         /// <summary>
-        /// Exception object
+        /// Exception object.
         /// </summary>
         public Exception Exception { get; private set; }
 
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Vector2.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Vector2.cs
index cb326484dac..1ed946b98d8 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Vector2.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Vector2.cs
@@ -21,23 +21,35 @@ namespace Godot
         /// </summary>
         public enum Axis
         {
+            /// <summary>
+            /// The vector's X axis.
+            /// </summary>
             X = 0,
+            /// <summary>
+            /// The vector's Y axis.
+            /// </summary>
             Y
         }
 
         /// <summary>
-        /// The vector's X component. Also accessible by using the index position `[0]`.
+        /// The vector's X component. Also accessible by using the index position <c>[0]</c>.
         /// </summary>
         public real_t x;
         /// <summary>
-        /// The vector's Y component. Also accessible by using the index position `[1]`.
+        /// The vector's Y component. Also accessible by using the index position <c>[1]</c>.
         /// </summary>
         public real_t y;
 
         /// <summary>
         /// Access vector components using their index.
         /// </summary>
-        /// <value>`[0]` is equivalent to `.x`, `[1]` is equivalent to `.y`.</value>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when the given the <paramref name="index"/> is not 0 or 1.
+        /// </exception>
+        /// <value>
+        /// <c>[0]</c> is equivalent to <see cref="x"/>,
+        /// <c>[1]</c> is equivalent to <see cref="y"/>.
+        /// </value>
         public real_t this[int index]
         {
             get
@@ -97,7 +109,7 @@ namespace Godot
         /// Returns this vector's angle with respect to the X axis, or (1, 0) vector, in radians.
         ///
         /// Equivalent to the result of <see cref="Mathf.Atan2(real_t, real_t)"/> when
-        /// called with the vector's `y` and `x` as parameters: `Mathf.Atan2(v.y, v.x)`.
+        /// called with the vector's <see cref="y"/> and <see cref="x"/> as parameters: <c>Mathf.Atan2(v.y, v.x)</c>.
         /// </summary>
         /// <returns>The angle of this vector, in radians.</returns>
         public real_t Angle()
@@ -126,9 +138,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the aspect ratio of this vector, the ratio of `x` to `y`.
+        /// Returns the aspect ratio of this vector, the ratio of <see cref="x"/> to <see cref="y"/>.
         /// </summary>
-        /// <returns>The `x` component divided by the `y` component.</returns>
+        /// <returns>The <see cref="x"/> component divided by the <see cref="y"/> component.</returns>
         public real_t Aspect()
         {
             return x / y;
@@ -154,7 +166,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the vector with a maximum length by limiting its length to `length`.
+        /// Returns the vector with a maximum length by limiting its length to <paramref name="length"/>.
         /// </summary>
         /// <param name="length">The length to limit to.</param>
         /// <returns>The vector with its length limited.</returns>
@@ -173,7 +185,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the cross product of this vector and `b`.
+        /// Returns the cross product of this vector and <paramref name="b"/>.
         /// </summary>
         /// <param name="b">The other vector.</param>
         /// <returns>The cross product value.</returns>
@@ -183,11 +195,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Performs a cubic interpolation between vectors `preA`, this vector, `b`, and `postB`, by the given amount `t`.
+        /// Performs a cubic interpolation between vectors <paramref name="preA"/>, this vector,
+        /// <paramref name="b"/>, and <paramref name="postB"/>, by the given amount <paramref name="weight"/>.
         /// </summary>
         /// <param name="b">The destination vector.</param>
         /// <param name="preA">A vector before this vector.</param>
-        /// <param name="postB">A vector after `b`.</param>
+        /// <param name="postB">A vector after <paramref name="b"/>.</param>
         /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
         /// <returns>The interpolated vector.</returns>
         public Vector2 CubicInterpolate(Vector2 b, Vector2 preA, Vector2 postB, real_t weight)
@@ -208,17 +221,17 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the normalized vector pointing from this vector to `b`.
+        /// Returns the normalized vector pointing from this vector to <paramref name="b"/>.
         /// </summary>
         /// <param name="b">The other vector to point towards.</param>
-        /// <returns>The direction from this vector to `b`.</returns>
+        /// <returns>The direction from this vector to <paramref name="b"/>.</returns>
         public Vector2 DirectionTo(Vector2 b)
         {
             return new Vector2(b.x - x, b.y - y).Normalized();
         }
 
         /// <summary>
-        /// Returns the squared distance between this vector and `to`.
+        /// Returns the squared distance between this vector and <paramref name="to"/>.
         /// This method runs faster than <see cref="DistanceTo"/>, so prefer it if
         /// you need to compare vectors or need the squared distance for some formula.
         /// </summary>
@@ -230,7 +243,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the distance between this vector and `to`.
+        /// Returns the distance between this vector and <paramref name="to"/>.
         /// </summary>
         /// <param name="to">The other vector to use.</param>
         /// <returns>The distance between the two vectors.</returns>
@@ -240,7 +253,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the dot product of this vector and `with`.
+        /// Returns the dot product of this vector and <paramref name="with"/>.
         /// </summary>
         /// <param name="with">The other vector to use.</param>
         /// <returns>The dot product of the two vectors.</returns>
@@ -259,7 +272,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the inverse of this vector. This is the same as `new Vector2(1 / v.x, 1 / v.y)`.
+        /// Returns the inverse of this vector. This is the same as <c>new Vector2(1 / v.x, 1 / v.y)</c>.
         /// </summary>
         /// <returns>The inverse of this vector.</returns>
         public Vector2 Inverse()
@@ -268,9 +281,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if the vector is normalized, and false otherwise.
+        /// Returns <see langword="true"/> if the vector is normalized, and <see langword="false"/> otherwise.
         /// </summary>
-        /// <returns>A bool indicating whether or not the vector is normalized.</returns>
+        /// <returns>A <see langword="bool"/> indicating whether or not the vector is normalized.</returns>
         public bool IsNormalized()
         {
             return Mathf.Abs(LengthSquared() - 1.0f) < Mathf.Epsilon;
@@ -279,6 +292,7 @@ namespace Godot
         /// <summary>
         /// Returns the length (magnitude) of this vector.
         /// </summary>
+        /// <seealso cref="LengthSquared"/>
         /// <returns>The length of this vector.</returns>
         public real_t Length()
         {
@@ -298,7 +312,7 @@ namespace Godot
 
         /// <summary>
         /// Returns the result of the linear interpolation between
-        /// this vector and `to` by amount `weight`.
+        /// this vector and <paramref name="to"/> by amount <paramref name="weight"/>.
         /// </summary>
         /// <param name="to">The destination vector for interpolation.</param>
         /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
@@ -314,10 +328,12 @@ namespace Godot
 
         /// <summary>
         /// Returns the result of the linear interpolation between
-        /// this vector and `to` by the vector amount `weight`.
+        /// this vector and <paramref name="to"/> by the vector amount <paramref name="weight"/>.
         /// </summary>
         /// <param name="to">The destination vector for interpolation.</param>
-        /// <param name="weight">A vector with components on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
+        /// <param name="weight">
+        /// A vector with components on the range of 0.0 to 1.0, representing the amount of interpolation.
+        /// </param>
         /// <returns>The resulting vector of the interpolation.</returns>
         public Vector2 LinearInterpolate(Vector2 to, Vector2 weight)
         {
@@ -349,7 +365,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Moves this vector toward `to` by the fixed `delta` amount.
+        /// Moves this vector toward <paramref name="to"/> by the fixed <paramref name="delta"/> amount.
         /// </summary>
         /// <param name="to">The vector to move towards.</param>
         /// <param name="delta">The amount to move towards by.</param>
@@ -363,7 +379,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the vector scaled to unit length. Equivalent to `v / v.Length()`.
+        /// Returns the vector scaled to unit length. Equivalent to <c>v / v.Length()</c>.
         /// </summary>
         /// <returns>A normalized version of the vector.</returns>
         public Vector2 Normalized()
@@ -384,10 +400,13 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a vector composed of the <see cref="Mathf.PosMod(real_t, real_t)"/> of this vector's components and `mod`.
+        /// Returns a vector composed of the <see cref="Mathf.PosMod(real_t, real_t)"/> of this vector's components
+        /// and <paramref name="mod"/>.
         /// </summary>
         /// <param name="mod">A value representing the divisor of the operation.</param>
-        /// <returns>A vector with each component <see cref="Mathf.PosMod(real_t, real_t)"/> by `mod`.</returns>
+        /// <returns>
+        /// A vector with each component <see cref="Mathf.PosMod(real_t, real_t)"/> by <paramref name="mod"/>.
+        /// </returns>
         public Vector2 PosMod(real_t mod)
         {
             Vector2 v;
@@ -397,10 +416,13 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a vector composed of the <see cref="Mathf.PosMod(real_t, real_t)"/> of this vector's components and `modv`'s components.
+        /// Returns a vector composed of the <see cref="Mathf.PosMod(real_t, real_t)"/> of this vector's components
+        /// and <paramref name="modv"/>'s components.
         /// </summary>
         /// <param name="modv">A vector representing the divisors of the operation.</param>
-        /// <returns>A vector with each component <see cref="Mathf.PosMod(real_t, real_t)"/> by `modv`'s components.</returns>
+        /// <returns>
+        /// A vector with each component <see cref="Mathf.PosMod(real_t, real_t)"/> by <paramref name="modv"/>'s components.
+        /// </returns>
         public Vector2 PosMod(Vector2 modv)
         {
             Vector2 v;
@@ -410,7 +432,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns this vector projected onto another vector.
+        /// Returns this vector projected onto another vector <paramref name="onNormal"/>.
         /// </summary>
         /// <param name="onNormal">The vector to project onto.</param>
         /// <returns>The projected vector.</returns>
@@ -420,7 +442,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns this vector reflected from a plane defined by the given `normal`.
+        /// Returns this vector reflected from a plane defined by the given <paramref name="normal"/>.
         /// </summary>
         /// <param name="normal">The normal vector defining the plane to reflect from. Must be normalized.</param>
         /// <returns>The reflected vector.</returns>
@@ -436,7 +458,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Rotates this vector by `phi` radians.
+        /// Rotates this vector by <paramref name="phi"/> radians.
         /// </summary>
         /// <param name="phi">The angle to rotate by, in radians.</param>
         /// <returns>The rotated vector.</returns>
@@ -474,7 +496,7 @@ namespace Godot
         /// on the signs of this vector's components, or zero if the component is zero,
         /// by calling <see cref="Mathf.Sign(real_t)"/> on each component.
         /// </summary>
-        /// <returns>A vector with all components as either `1`, `-1`, or `0`.</returns>
+        /// <returns>A vector with all components as either <c>1</c>, <c>-1</c>, or <c>0</c>.</returns>
         public Vector2 Sign()
         {
             Vector2 v;
@@ -485,7 +507,7 @@ namespace Godot
 
         /// <summary>
         /// Returns the result of the spherical linear interpolation between
-        /// this vector and `to` by amount `weight`.
+        /// this vector and <paramref name="to"/> by amount <paramref name="weight"/>.
         ///
         /// Note: Both vectors must be normalized.
         /// </summary>
@@ -501,14 +523,14 @@ namespace Godot
             }
             if (!to.IsNormalized())
             {
-                throw new InvalidOperationException("Vector2.Slerp: `to` is not normalized.");
+                throw new InvalidOperationException($"Vector2.Slerp: `{nameof(to)}` is not normalized.");
             }
 #endif
             return Rotated(AngleTo(to) * weight);
         }
 
         /// <summary>
-        /// Returns this vector slid along a plane defined by the given normal.
+        /// Returns this vector slid along a plane defined by the given <paramref name="normal"/>.
         /// </summary>
         /// <param name="normal">The normal vector defining the plane to slide on.</param>
         /// <returns>The slid vector.</returns>
@@ -518,7 +540,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns this vector with each component snapped to the nearest multiple of `step`.
+        /// Returns this vector with each component snapped to the nearest multiple of <paramref name="step"/>.
         /// This can also be used to round to an arbitrary number of decimals.
         /// </summary>
         /// <param name="step">A vector value representing the step size to snap to.</param>
@@ -551,45 +573,46 @@ namespace Godot
         private static readonly Vector2 _left = new Vector2(-1, 0);
 
         /// <summary>
-        /// Zero vector, a vector with all components set to `0`.
+        /// Zero vector, a vector with all components set to <c>0</c>.
         /// </summary>
-        /// <value>Equivalent to `new Vector2(0, 0)`</value>
+        /// <value>Equivalent to <c>new Vector2(0, 0)</c>.</value>
         public static Vector2 Zero { get { return _zero; } }
         /// <summary>
         /// Deprecated, please use a negative sign with <see cref="One"/> instead.
         /// </summary>
-        /// <value>Equivalent to `new Vector2(-1, -1)`</value>
+        /// <value>Equivalent to <c>new Vector2(-1, -1)</c>.</value>
+        [Obsolete("Use a negative sign with Vector2.One instead.")]
         public static Vector2 NegOne { get { return _negOne; } }
         /// <summary>
-        /// One vector, a vector with all components set to `1`.
+        /// One vector, a vector with all components set to <c>1</c>.
         /// </summary>
-        /// <value>Equivalent to `new Vector2(1, 1)`</value>
+        /// <value>Equivalent to <c>new Vector2(1, 1)</c>.</value>
         public static Vector2 One { get { return _one; } }
         /// <summary>
-        /// Infinity vector, a vector with all components set to `Mathf.Inf`.
+        /// Infinity vector, a vector with all components set to <see cref="Mathf.Inf"/>.
         /// </summary>
-        /// <value>Equivalent to `new Vector2(Mathf.Inf, Mathf.Inf)`</value>
+        /// <value>Equivalent to <c>new Vector2(Mathf.Inf, Mathf.Inf)</c>.</value>
         public static Vector2 Inf { get { return _inf; } }
 
         /// <summary>
         /// Up unit vector. Y is down in 2D, so this vector points -Y.
         /// </summary>
-        /// <value>Equivalent to `new Vector2(0, -1)`</value>
+        /// <value>Equivalent to <c>new Vector2(0, -1)</c>.</value>
         public static Vector2 Up { get { return _up; } }
         /// <summary>
         /// Down unit vector. Y is down in 2D, so this vector points +Y.
         /// </summary>
-        /// <value>Equivalent to `new Vector2(0, 1)`</value>
+        /// <value>Equivalent to <c>new Vector2(0, 1)</c>.</value>
         public static Vector2 Down { get { return _down; } }
         /// <summary>
         /// Right unit vector. Represents the direction of right.
         /// </summary>
-        /// <value>Equivalent to `new Vector2(1, 0)`</value>
+        /// <value>Equivalent to <c>new Vector2(1, 0)</c>.</value>
         public static Vector2 Right { get { return _right; } }
         /// <summary>
         /// Left unit vector. Represents the direction of left.
         /// </summary>
-        /// <value>Equivalent to `new Vector2(-1, 0)`</value>
+        /// <value>Equivalent to <c>new Vector2(-1, 0)</c>.</value>
         public static Vector2 Left { get { return _left; } }
 
         /// <summary>
@@ -729,6 +752,11 @@ namespace Godot
             return left.x >= right.x;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this vector and <paramref name="obj"/> are equal.
+        /// </summary>
+        /// <param name="obj">The other object to compare.</param>
+        /// <returns>Whether or not the vector and the other object are equal.</returns>
         public override bool Equals(object obj)
         {
             if (obj is Vector2)
@@ -738,14 +766,19 @@ namespace Godot
             return false;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this vector and <paramref name="other"/> are equal.
+        /// </summary>
+        /// <param name="other">The other vector to compare.</param>
+        /// <returns>Whether or not the vectors are equal.</returns>
         public bool Equals(Vector2 other)
         {
             return x == other.x && y == other.y;
         }
 
         /// <summary>
-        /// Returns true if this vector and `other` are approximately equal, by running
-        /// <see cref="Mathf.IsEqualApprox(real_t, real_t)"/> on each component.
+        /// Returns <see langword="true"/> if this vector and <paramref name="other"/> are approximately equal,
+        /// by running <see cref="Mathf.IsEqualApprox(real_t, real_t)"/> on each component.
         /// </summary>
         /// <param name="other">The other vector to compare.</param>
         /// <returns>Whether or not the vectors are approximately equal.</returns>
@@ -754,11 +787,19 @@ namespace Godot
             return Mathf.IsEqualApprox(x, other.x) && Mathf.IsEqualApprox(y, other.y);
         }
 
+        /// <summary>
+        /// Serves as the hash function for <see cref="Vector2"/>.
+        /// </summary>
+        /// <returns>A hash code for this vector.</returns>
         public override int GetHashCode()
         {
             return y.GetHashCode() ^ x.GetHashCode();
         }
 
+        /// <summary>
+        /// Converts this <see cref="Vector2"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this vector.</returns>
         public override string ToString()
         {
             return String.Format("({0}, {1})", new object[]
@@ -768,6 +809,10 @@ namespace Godot
             });
         }
 
+        /// <summary>
+        /// Converts this <see cref="Vector2"/> to a string with the given <paramref name="format"/>.
+        /// </summary>
+        /// <returns>A string representation of this vector.</returns>
         public string ToString(string format)
         {
             return String.Format("({0}, {1})", new object[]
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Vector3.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Vector3.cs
index 1d2b41a8b29..3a5dd3a7812 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Vector3.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Vector3.cs
@@ -21,28 +21,44 @@ namespace Godot
         /// </summary>
         public enum Axis
         {
+            /// <summary>
+            /// The vector's X axis.
+            /// </summary>
             X = 0,
+            /// <summary>
+            /// The vector's Y axis.
+            /// </summary>
             Y,
+            /// <summary>
+            /// The vector's Z axis.
+            /// </summary>
             Z
         }
 
         /// <summary>
-        /// The vector's X component. Also accessible by using the index position `[0]`.
+        /// The vector's X component. Also accessible by using the index position <c>[0]</c>.
         /// </summary>
         public real_t x;
         /// <summary>
-        /// The vector's Y component. Also accessible by using the index position `[1]`.
+        /// The vector's Y component. Also accessible by using the index position <c>[1]</c>.
         /// </summary>
         public real_t y;
         /// <summary>
-        /// The vector's Z component. Also accessible by using the index position `[2]`.
+        /// The vector's Z component. Also accessible by using the index position <c>[2]</c>.
         /// </summary>
         public real_t z;
 
         /// <summary>
         /// Access vector components using their index.
         /// </summary>
-        /// <value>`[0]` is equivalent to `.x`, `[1]` is equivalent to `.y`, `[2]` is equivalent to `.z`.</value>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when the given the <paramref name="index"/> is not 0, 1 or 2.
+        /// </exception>
+        /// <value>
+        /// <c>[0]</c> is equivalent to <see cref="x"/>,
+        /// <c>[1]</c> is equivalent to <see cref="y"/>,
+        /// <c>[2]</c> is equivalent to <see cref="z"/>.
+        /// </value>
         public real_t this[int index]
         {
             get
@@ -134,7 +150,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the cross product of this vector and `b`.
+        /// Returns the cross product of this vector and <paramref name="b"/>.
         /// </summary>
         /// <param name="b">The other vector.</param>
         /// <returns>The cross product vector.</returns>
@@ -149,12 +165,12 @@ namespace Godot
         }
 
         /// <summary>
-        /// Performs a cubic interpolation between vectors `preA`, this vector,
-        /// `b`, and `postB`, by the given amount `t`.
+        /// Performs a cubic interpolation between vectors <paramref name="preA"/>, this vector,
+        /// <paramref name="b"/>, and <paramref name="postB"/>, by the given amount <paramref name="weight"/>.
         /// </summary>
         /// <param name="b">The destination vector.</param>
         /// <param name="preA">A vector before this vector.</param>
-        /// <param name="postB">A vector after `b`.</param>
+        /// <param name="postB">A vector after <paramref name="b"/>.</param>
         /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
         /// <returns>The interpolated vector.</returns>
         public Vector3 CubicInterpolate(Vector3 b, Vector3 preA, Vector3 postB, real_t weight)
@@ -176,17 +192,17 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the normalized vector pointing from this vector to `b`.
+        /// Returns the normalized vector pointing from this vector to <paramref name="b"/>.
         /// </summary>
         /// <param name="b">The other vector to point towards.</param>
-        /// <returns>The direction from this vector to `b`.</returns>
+        /// <returns>The direction from this vector to <paramref name="b"/>.</returns>
         public Vector3 DirectionTo(Vector3 b)
         {
             return new Vector3(b.x - x, b.y - y, b.z - z).Normalized();
         }
 
         /// <summary>
-        /// Returns the squared distance between this vector and `b`.
+        /// Returns the squared distance between this vector and <paramref name="b"/>.
         /// This method runs faster than <see cref="DistanceTo"/>, so prefer it if
         /// you need to compare vectors or need the squared distance for some formula.
         /// </summary>
@@ -198,8 +214,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the distance between this vector and `b`.
+        /// Returns the distance between this vector and <paramref name="b"/>.
         /// </summary>
+        /// <seealso cref="DistanceSquaredTo(Vector3)"/>
         /// <param name="b">The other vector to use.</param>
         /// <returns>The distance between the two vectors.</returns>
         public real_t DistanceTo(Vector3 b)
@@ -208,7 +225,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the dot product of this vector and `b`.
+        /// Returns the dot product of this vector and <paramref name="b"/>.
         /// </summary>
         /// <param name="b">The other vector to use.</param>
         /// <returns>The dot product of the two vectors.</returns>
@@ -227,7 +244,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the inverse of this vector. This is the same as `new Vector3(1 / v.x, 1 / v.y, 1 / v.z)`.
+        /// Returns the inverse of this vector. This is the same as <c>new Vector3(1 / v.x, 1 / v.y, 1 / v.z)</c>.
         /// </summary>
         /// <returns>The inverse of this vector.</returns>
         public Vector3 Inverse()
@@ -236,9 +253,9 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns true if the vector is normalized, and false otherwise.
+        /// Returns <see langword="true"/> if the vector is normalized, and <see langword="false"/> otherwise.
         /// </summary>
-        /// <returns>A bool indicating whether or not the vector is normalized.</returns>
+        /// <returns>A <see langword="bool"/> indicating whether or not the vector is normalized.</returns>
         public bool IsNormalized()
         {
             return Mathf.Abs(LengthSquared() - 1.0f) < Mathf.Epsilon;
@@ -247,6 +264,7 @@ namespace Godot
         /// <summary>
         /// Returns the length (magnitude) of this vector.
         /// </summary>
+        /// <seealso cref="LengthSquared"/>
         /// <returns>The length of this vector.</returns>
         public real_t Length()
         {
@@ -274,7 +292,7 @@ namespace Godot
 
         /// <summary>
         /// Returns the result of the linear interpolation between
-        /// this vector and `to` by amount `weight`.
+        /// this vector and <paramref name="to"/> by amount <paramref name="weight"/>.
         /// </summary>
         /// <param name="to">The destination vector for interpolation.</param>
         /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
@@ -291,7 +309,7 @@ namespace Godot
 
         /// <summary>
         /// Returns the result of the linear interpolation between
-        /// this vector and `to` by the vector amount `weight`.
+        /// this vector and <paramref name="to"/> by the vector amount <paramref name="weight"/>.
         /// </summary>
         /// <param name="to">The destination vector for interpolation.</param>
         /// <param name="weight">A vector with components on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
@@ -327,7 +345,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Moves this vector toward `to` by the fixed `delta` amount.
+        /// Moves this vector toward <paramref name="to"/> by the fixed <paramref name="delta"/> amount.
         /// </summary>
         /// <param name="to">The vector to move towards.</param>
         /// <param name="delta">The amount to move towards by.</param>
@@ -341,7 +359,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the vector scaled to unit length. Equivalent to `v / v.Length()`.
+        /// Returns the vector scaled to unit length. Equivalent to <c>v / v.Length()</c>.
         /// </summary>
         /// <returns>A normalized version of the vector.</returns>
         public Vector3 Normalized()
@@ -352,7 +370,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns the outer product with `b`.
+        /// Returns the outer product with <paramref name="b"/>.
         /// </summary>
         /// <param name="b">The other vector.</param>
         /// <returns>A <see cref="Basis"/> representing the outer product matrix.</returns>
@@ -366,10 +384,13 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a vector composed of the <see cref="Mathf.PosMod(real_t, real_t)"/> of this vector's components and `mod`.
+        /// Returns a vector composed of the <see cref="Mathf.PosMod(real_t, real_t)"/> of this vector's components
+        /// and <paramref name="mod"/>.
         /// </summary>
         /// <param name="mod">A value representing the divisor of the operation.</param>
-        /// <returns>A vector with each component <see cref="Mathf.PosMod(real_t, real_t)"/> by `mod`.</returns>
+        /// <returns>
+        /// A vector with each component <see cref="Mathf.PosMod(real_t, real_t)"/> by <paramref name="mod"/>.
+        /// </returns>
         public Vector3 PosMod(real_t mod)
         {
             Vector3 v;
@@ -380,10 +401,13 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns a vector composed of the <see cref="Mathf.PosMod(real_t, real_t)"/> of this vector's components and `modv`'s components.
+        /// Returns a vector composed of the <see cref="Mathf.PosMod(real_t, real_t)"/> of this vector's components
+        /// and <paramref name="modv"/>'s components.
         /// </summary>
         /// <param name="modv">A vector representing the divisors of the operation.</param>
-        /// <returns>A vector with each component <see cref="Mathf.PosMod(real_t, real_t)"/> by `modv`'s components.</returns>
+        /// <returns>
+        /// A vector with each component <see cref="Mathf.PosMod(real_t, real_t)"/> by <paramref name="modv"/>'s components.
+        /// </returns>
         public Vector3 PosMod(Vector3 modv)
         {
             Vector3 v;
@@ -394,7 +418,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns this vector projected onto another vector `b`.
+        /// Returns this vector projected onto another vector <paramref name="onNormal"/>.
         /// </summary>
         /// <param name="onNormal">The vector to project onto.</param>
         /// <returns>The projected vector.</returns>
@@ -404,7 +428,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns this vector reflected from a plane defined by the given `normal`.
+        /// Returns this vector reflected from a plane defined by the given <paramref name="normal"/>.
         /// </summary>
         /// <param name="normal">The normal vector defining the plane to reflect from. Must be normalized.</param>
         /// <returns>The reflected vector.</returns>
@@ -420,8 +444,8 @@ namespace Godot
         }
 
         /// <summary>
-        /// Rotates this vector around a given `axis` vector by `phi` radians.
-        /// The `axis` vector must be a normalized vector.
+        /// Rotates this vector around a given <paramref name="axis"/> vector by <paramref name="phi"/> radians.
+        /// The <paramref name="axis"/> vector must be a normalized vector.
         /// </summary>
         /// <param name="axis">The vector to rotate around. Must be normalized.</param>
         /// <param name="phi">The angle to rotate by, in radians.</param>
@@ -467,7 +491,7 @@ namespace Godot
         /// on the signs of this vector's components, or zero if the component is zero,
         /// by calling <see cref="Mathf.Sign(real_t)"/> on each component.
         /// </summary>
-        /// <returns>A vector with all components as either `1`, `-1`, or `0`.</returns>
+        /// <returns>A vector with all components as either <c>1</c>, <c>-1</c>, or <c>0</c>.</returns>
         public Vector3 Sign()
         {
             Vector3 v;
@@ -481,7 +505,7 @@ namespace Godot
         /// Returns the signed angle to the given vector, in radians.
         /// The sign of the angle is positive in a counter-clockwise
         /// direction and negative in a clockwise direction when viewed
-        /// from the side specified by the `axis`.
+        /// from the side specified by the <paramref name="axis"/>.
         /// </summary>
         /// <param name="to">The other vector to compare this vector to.</param>
         /// <param name="axis">The reference axis to use for the angle sign.</param>
@@ -496,7 +520,7 @@ namespace Godot
 
         /// <summary>
         /// Returns the result of the spherical linear interpolation between
-        /// this vector and `to` by amount `weight`.
+        /// this vector and <paramref name="to"/> by amount <paramref name="weight"/>.
         ///
         /// Note: Both vectors must be normalized.
         /// </summary>
@@ -512,7 +536,7 @@ namespace Godot
             }
             if (!to.IsNormalized())
             {
-                throw new InvalidOperationException("Vector3.Slerp: `to` is not normalized.");
+                throw new InvalidOperationException($"Vector3.Slerp: `{nameof(to)}` is not normalized.");
             }
 #endif
             real_t theta = AngleTo(to);
@@ -520,7 +544,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns this vector slid along a plane defined by the given normal.
+        /// Returns this vector slid along a plane defined by the given <paramref name="normal"/>.
         /// </summary>
         /// <param name="normal">The normal vector defining the plane to slide on.</param>
         /// <returns>The slid vector.</returns>
@@ -530,7 +554,7 @@ namespace Godot
         }
 
         /// <summary>
-        /// Returns this vector with each component snapped to the nearest multiple of `step`.
+        /// Returns this vector with each component snapped to the nearest multiple of <paramref name="step"/>.
         /// This can also be used to round to an arbitrary number of decimals.
         /// </summary>
         /// <param name="step">A vector value representing the step size to snap to.</param>
@@ -548,10 +572,10 @@ namespace Godot
         /// <summary>
         /// Returns a diagonal matrix with the vector as main diagonal.
         ///
-        /// This is equivalent to a Basis with no rotation or shearing and
+        /// This is equivalent to a <see cref="Basis"/> with no rotation or shearing and
         /// this vector's components set as the scale.
         /// </summary>
-        /// <returns>A Basis with the vector as its main diagonal.</returns>
+        /// <returns>A <see cref="Basis"/> with the vector as its main diagonal.</returns>
         public Basis ToDiagonalMatrix()
         {
             return new Basis(
@@ -575,59 +599,60 @@ namespace Godot
         private static readonly Vector3 _back = new Vector3(0, 0, 1);
 
         /// <summary>
-        /// Zero vector, a vector with all components set to `0`.
+        /// Zero vector, a vector with all components set to <c>0</c>.
         /// </summary>
-        /// <value>Equivalent to `new Vector3(0, 0, 0)`</value>
+        /// <value>Equivalent to <c>new Vector3(0, 0, 0)</c>.</value>
         public static Vector3 Zero { get { return _zero; } }
         /// <summary>
-        /// One vector, a vector with all components set to `1`.
+        /// One vector, a vector with all components set to <c>1</c>.
         /// </summary>
-        /// <value>Equivalent to `new Vector3(1, 1, 1)`</value>
+        /// <value>Equivalent to <c>new Vector3(1, 1, 1)</c>.</value>
         public static Vector3 One { get { return _one; } }
         /// <summary>
         /// Deprecated, please use a negative sign with <see cref="One"/> instead.
         /// </summary>
-        /// <value>Equivalent to `new Vector3(-1, -1, -1)`</value>
+        /// <value>Equivalent to <c>new Vector3(-1, -1, -1)</c>.</value>
+        [Obsolete("Use a negative sign with Vector3.One instead.")]
         public static Vector3 NegOne { get { return _negOne; } }
         /// <summary>
-        /// Infinity vector, a vector with all components set to `Mathf.Inf`.
+        /// Infinity vector, a vector with all components set to <see cref="Mathf.Inf"/>.
         /// </summary>
-        /// <value>Equivalent to `new Vector3(Mathf.Inf, Mathf.Inf, Mathf.Inf)`</value>
+        /// <value>Equivalent to <c>new Vector3(Mathf.Inf, Mathf.Inf, Mathf.Inf)</c>.</value>
         public static Vector3 Inf { get { return _inf; } }
 
         /// <summary>
         /// Up unit vector.
         /// </summary>
-        /// <value>Equivalent to `new Vector3(0, 1, 0)`</value>
+        /// <value>Equivalent to <c>new Vector3(0, 1, 0)</c>.</value>
         public static Vector3 Up { get { return _up; } }
         /// <summary>
         /// Down unit vector.
         /// </summary>
-        /// <value>Equivalent to `new Vector3(0, -1, 0)`</value>
+        /// <value>Equivalent to <c>new Vector3(0, -1, 0)</c>.</value>
         public static Vector3 Down { get { return _down; } }
         /// <summary>
         /// Right unit vector. Represents the local direction of right,
         /// and the global direction of east.
         /// </summary>
-        /// <value>Equivalent to `new Vector3(1, 0, 0)`</value>
+        /// <value>Equivalent to <c>new Vector3(1, 0, 0)</c>.</value>
         public static Vector3 Right { get { return _right; } }
         /// <summary>
         /// Left unit vector. Represents the local direction of left,
         /// and the global direction of west.
         /// </summary>
-        /// <value>Equivalent to `new Vector3(-1, 0, 0)`</value>
+        /// <value>Equivalent to <c>new Vector3(-1, 0, 0)</c>.</value>
         public static Vector3 Left { get { return _left; } }
         /// <summary>
         /// Forward unit vector. Represents the local direction of forward,
         /// and the global direction of north.
         /// </summary>
-        /// <value>Equivalent to `new Vector3(0, 0, -1)`</value>
+        /// <value>Equivalent to <c>new Vector3(0, 0, -1)</c>.</value>
         public static Vector3 Forward { get { return _forward; } }
         /// <summary>
         /// Back unit vector. Represents the local direction of back,
         /// and the global direction of south.
         /// </summary>
-        /// <value>Equivalent to `new Vector3(0, 0, 1)`</value>
+        /// <value>Equivalent to <c>new Vector3(0, 0, 1)</c>.</value>
         public static Vector3 Back { get { return _back; } }
 
         /// <summary>
@@ -796,6 +821,11 @@ namespace Godot
             return left.x > right.x;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this vector and <paramref name="obj"/> are equal.
+        /// </summary>
+        /// <param name="obj">The other object to compare.</param>
+        /// <returns>Whether or not the vector and the other object are equal.</returns>
         public override bool Equals(object obj)
         {
             if (obj is Vector3)
@@ -806,14 +836,19 @@ namespace Godot
             return false;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this vector and <paramref name="other"/> are equal
+        /// </summary>
+        /// <param name="other">The other vector to compare.</param>
+        /// <returns>Whether or not the vectors are equal.</returns>
         public bool Equals(Vector3 other)
         {
             return x == other.x && y == other.y && z == other.z;
         }
 
         /// <summary>
-        /// Returns true if this vector and `other` are approximately equal, by running
-        /// <see cref="Mathf.IsEqualApprox(real_t, real_t)"/> on each component.
+        /// Returns <see langword="true"/> if this vector and <paramref name="other"/> are approximately equal,
+        /// by running <see cref="Mathf.IsEqualApprox(real_t, real_t)"/> on each component.
         /// </summary>
         /// <param name="other">The other vector to compare.</param>
         /// <returns>Whether or not the vectors are approximately equal.</returns>
@@ -822,11 +857,19 @@ namespace Godot
             return Mathf.IsEqualApprox(x, other.x) && Mathf.IsEqualApprox(y, other.y) && Mathf.IsEqualApprox(z, other.z);
         }
 
+        /// <summary>
+        /// Serves as the hash function for <see cref="Vector3"/>.
+        /// </summary>
+        /// <returns>A hash code for this vector.</returns>
         public override int GetHashCode()
         {
             return y.GetHashCode() ^ x.GetHashCode() ^ z.GetHashCode();
         }
 
+        /// <summary>
+        /// Converts this <see cref="Vector3"/> to a string.
+        /// </summary>
+        /// <returns>A string representation of this vector.</returns>
         public override string ToString()
         {
             return String.Format("({0}, {1}, {2})", new object[]
@@ -837,6 +880,10 @@ namespace Godot
             });
         }
 
+        /// <summary>
+        /// Converts this <see cref="Vector3"/> to a string with the given <paramref name="format"/>.
+        /// </summary>
+        /// <returns>A string representation of this vector.</returns>
         public string ToString(string format)
         {
             return String.Format("({0}, {1}, {2})", new object[]