Update codespell to include many more checks

.pre-commit-config.yaml

@@ -3,7 +3,7 @@ default_language_version:
 
 repos:
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.3.0
+    rev: v2.4.3
     hooks:
       - id: codespell
         additional_dependencies: [tomli]

_tools/codespell-dict.txt

@@ -1 +1,2 @@
 anti-aliasing->antialiasing
+sub-surface->subsurface

about/complying_with_licenses.rst

@@ -26,8 +26,8 @@ with the original one.
 .. note::
 
     This section covers compliance with licenses from a user perspective.
-    If you are interested in licence compliance as a contributor, you can find
-    guidelines `here <https://contributing.godotengine.org/en/latest/engine/guidelines/best_practices.html#don-t-use-complex-canned-solutions-for-simple-problems>`__.
+    If you are interested in license compliance as a contributor, you can find
+    guidelines in the `Best practices <https://contributing.godotengine.org/en/latest/engine/guidelines/best_practices.html#don-t-use-complex-canned-solutions-for-simple-problems>`__ page.
 
 .. tip::
 

about/list_of_features.rst

@@ -246,7 +246,7 @@ Godot 4 includes three renderers:
 - Normal mapping.
 - Parallax/relief mapping with automatic level of detail based on distance.
 - Detail mapping for the albedo and normal maps.
-- Sub-surface scattering and transmittance.
+- Subsurface scattering and transmittance.
 - Screen-space refraction with support for material roughness (resulting in blurry refraction).
 - Proximity fade (soft particles) and distance fade.
 - Distance fade can use alpha blending or dithering to avoid going through

getting_started/first_3d_game/01.game_setup.rst

@@ -101,8 +101,8 @@ resource and set its *Size* to ``60``, ``2``, and ``60``.
 
 .. image:: img/01.game_setup/12.cube_resized.webp
 
-You should see a wide grey slab that covers the grid and blue and red axes in
-the viewport.
+You should see a wide gray slab that covers the grid,
+as well as blue and red axes in the viewport.
 
 We're going to move the ground down so we can see the floor grid. To do this, the grid snapping feature can be used.
 Grid snapping can be activated 2 ways in the 3D editor.
@@ -137,7 +137,7 @@ Ultimately, ``Ground``'s Y position should be ``-1``.
 
 .. image:: img/01.game_setup/ground_down1meter.webp
 
-Let's add a directional light so our scene isn't all grey. Select the ``Main``
+Let's add a directional light so our scene isn't all gray. Select the ``Main``
 node and add a child node :ref:`DirectionalLight3D <class_DirectionalLight3D>`.
 
 .. image:: img/01.game_setup/create_directional_light3d.webp

getting_started/first_3d_game/05.spawning_mobs.rst

@@ -120,7 +120,7 @@ the background, like a bright orange.
 |image14|
 
 We can now use the cylinders as guides. Fold them in the *Scene* dock by
-clicking the grey arrow next to them. Moving forward, you can also toggle their
+clicking the gray arrow next to them. Moving forward, you can also toggle their
 visibility by clicking the eye icon next to *Cylinders*.
 
 |image15|

getting_started/step_by_step/instancing.rst

@@ -155,7 +155,7 @@ Select one of the instanced Ball nodes and, in the :ui:`Inspector`, set its
 
 .. image:: img/instancing_property_gravity_scale.webp
 
-A grey "revert" button appears next to the adjusted property.
+A gray "revert" button appears next to the adjusted property.
 
 .. image:: img/instancing_property_revert_icon.webp
 

pyproject.toml

@@ -2,8 +2,12 @@
 line-length = 120
 
 [tool.codespell]
+enable-colors = true
+write-changes = true
+check-hidden = true
+quiet-level = 3
 dictionary = ["_tools/codespell-dict.txt", "-"]
-ignore-words = "_tools/codespell-ignore.txt"
+builtin = ["clear", "rare", "en-GB_to_en-US"]
 skip = [
     "_build/*",
     "_static/*",
@@ -14,3 +18,17 @@ skip = [
     "AUTHORS.md",
     "LICENSE.txt",
 ]
+ignore-words-list = [
+    "dialogue",     # Common even in US spelling.
+    "doubleclick",
+    "findn",        # Our case-insensitive `find` function.
+    "implementors",
+    "inout",        # Shader attribute.
+    "lod",          # "Level of Detail".
+    "marshalled",   # Common spelling in IT.
+    "marshalling",  # Common spelling in IT.
+    "thirdparty",   # Prefer as one word.
+    "uint",         # "Unsigned integer".
+    "writeable",    # Part of a Python error message.
+]
+ignore-multiline-regex = "codespell:ignore-begin.*?codespell:ignore-end"

tutorials/2d/custom_drawing_in_2d.rst

@@ -515,16 +515,16 @@ its radius, and the third is its color:
     func _draw():
         var white : Color = Color.WHITE
         var godot_blue : Color = Color("478cbf")
-        var grey : Color = Color("414042")
+        var gray : Color = Color("414042")
 
         draw_polygon(head, [ godot_blue ])
         draw_polyline(mouth, white, _mouth_width)
 
-        # Four circles for the 2 eyes: 2 white, 2 grey.
+        # Four circles for the 2 eyes: 2 white, 2 gray.
         draw_circle(Vector2(42.479, 65.4825), 9.3905, white)
         draw_circle(Vector2(85.524, 65.4825), 9.3905, white)
-        draw_circle(Vector2(43.423, 65.92), 6.246, grey)
-        draw_circle(Vector2(84.626, 66.008), 6.246, grey)
+        draw_circle(Vector2(43.423, 65.92), 6.246, gray)
+        draw_circle(Vector2(84.626, 66.008), 6.246, gray)
 
  .. code-tab:: csharp
 
@@ -533,16 +533,16 @@ its radius, and the third is its color:
     {
         Color white = Colors.White;
         Color godotBlue = new Color("478cbf");
-        Color grey = new Color("414042");
+        Color gray = new Color("414042");
 
         DrawPolygon(_head, [godotBlue]);
         DrawPolyline(_mouth, white, _mouthWidth);
 
-        // Four circles for the 2 eyes: 2 white, 2 grey.
+        // Four circles for the 2 eyes: 2 white, 2 gray.
         DrawCircle(new Vector2(42.479f, 65.4825f), 9.3905f, white);
         DrawCircle(new Vector2(85.524f, 65.4825f), 9.3905f, white);
-        DrawCircle(new Vector2(43.423f, 65.92f), 6.246f, grey);
-        DrawCircle(new Vector2(84.626f, 66.008f), 6.246f, grey);
+        DrawCircle(new Vector2(43.423f, 65.92f), 6.246f, gray);
+        DrawCircle(new Vector2(84.626f, 66.008f), 6.246f, gray);
     }
 
 When executing it, you should have something like this:
@@ -569,14 +569,14 @@ like this:
     func _draw():
         var white : Color = Color.WHITE
         var godot_blue : Color = Color("478cbf")
-        var grey : Color = Color("414042")
+        var gray : Color = Color("414042")
 
         draw_polygon(head, [ godot_blue ])
         draw_polyline(mouth, white, _mouth_width)
         draw_circle(Vector2(42.479, 65.4825), 9.3905, white)
         draw_circle(Vector2(85.524, 65.4825), 9.3905, white)
-        draw_circle(Vector2(43.423, 65.92), 6.246, grey)
-        draw_circle(Vector2(84.626, 66.008), 6.246, grey)
+        draw_circle(Vector2(43.423, 65.92), 6.246, gray)
+        draw_circle(Vector2(84.626, 66.008), 6.246, gray)
 
         # Draw a short but thick white vertical line for the nose.
         draw_line(Vector2(64.273, 60.564), Vector2(64.273, 74.349), white, 5.8)
@@ -587,14 +587,14 @@ like this:
     {
         Color white = Colors.White;
         Color godotBlue = new Color("478cbf");
-        Color grey = new Color("414042");
+        Color gray = new Color("414042");
 
         DrawPolygon(_head, [godotBlue]);
         DrawPolyline(_mouth, white, _mouthWidth);
         DrawCircle(new Vector2(42.479f, 65.4825f), 9.3905f, white);
         DrawCircle(new Vector2(85.524f, 65.4825f), 9.3905f, white);
-        DrawCircle(new Vector2(43.423f, 65.92f), 6.246f, grey);
-        DrawCircle(new Vector2(84.626f, 66.008f), 6.246f, grey);
+        DrawCircle(new Vector2(43.423f, 65.92f), 6.246f, gray);
+        DrawCircle(new Vector2(84.626f, 66.008f), 6.246f, gray);
 
         // Draw a short but thick white vertical line for the nose.
         DrawLine(new Vector2(64.273f, 60.564f), new Vector2(64.273f, 74.349f),
@@ -628,14 +628,14 @@ to do it, like this:
     func _draw():
         var white : Color = Color.WHITE
         var godot_blue : Color = Color("478cbf")
-        var grey : Color = Color("414042")
+        var gray : Color = Color("414042")
 
         draw_polygon(head, [ godot_blue ])
         draw_polyline(mouth, white, _mouth_width)
         draw_circle(Vector2(42.479, 65.4825), 9.3905, white)
         draw_circle(Vector2(85.524, 65.4825), 9.3905, white)
-        draw_circle(Vector2(43.423, 65.92), 6.246, grey)
-        draw_circle(Vector2(84.626, 66.008), 6.246, grey)
+        draw_circle(Vector2(43.423, 65.92), 6.246, gray)
+        draw_circle(Vector2(84.626, 66.008), 6.246, gray)
         draw_line(Vector2(64.273, 60.564), Vector2(64.273, 74.349), white, 5.8)
 
         # Draw GODOT text below the logo with the default font, size 22.
@@ -650,14 +650,14 @@ to do it, like this:
     {
         Color white = Colors.White;
         Color godotBlue = new Color("478cbf");
-        Color grey = new Color("414042");
+        Color gray = new Color("414042");
 
         DrawPolygon(_head, [godotBlue]);
         DrawPolyline(_mouth, white, _mouthWidth);
         DrawCircle(new Vector2(42.479f, 65.4825f), 9.3905f, white);
         DrawCircle(new Vector2(85.524f, 65.4825f), 9.3905f, white);
-        DrawCircle(new Vector2(43.423f, 65.92f), 6.246f, grey);
-        DrawCircle(new Vector2(84.626f, 66.008f), 6.246f, grey);
+        DrawCircle(new Vector2(43.423f, 65.92f), 6.246f, gray);
+        DrawCircle(new Vector2(84.626f, 66.008f), 6.246f, gray);
         DrawLine(new Vector2(64.273f, 60.564f), new Vector2(64.273f, 74.349f),
                  white, 5.8f);
 

tutorials/3d/physical_light_and_camera_units.rst

@@ -185,9 +185,9 @@ A candle is about 13 lumens, while a streetlight can be approximately 60000 lume
 
 **DirectionalLight3D intensity**
 
-Lux is a measure pf luminous flux per unit area, it is equal to one lumen per
-square metre. Lux is the measure of how much light hits a surface at a given
-time.
+Lux is a measure pf luminous flux per unit area
+and it is the measure of how much light hits a surface at a given time.
+It is equal to one lumen per square meter.
 
 With DirectionalLight3D, on a clear sunny day, a surface in direct sunlight may
 receive approximately 100000 lux. A typical room in a home may receive

tutorials/i18n/internationalizing_games.rst

@@ -100,10 +100,14 @@ information.
 Why locales exist can be illustrated through the USA and Great Britain.
 Both speak the same language (English), yet differ in many aspects:
 
+.. codespell:ignore-begin grey metres
+
 - Spelling: e.g. gray (USA), grey (GB)
 - Use of words: e.g. eggplant (USA), aubergine (GB)
 - Units or currencies: e.g. feet/inches (USA), metres/cm (GB)
 
+.. codespell:ignore-end
+
 It can get more complex however. Imagine you offer different content in Europe
 and in China (e.g. in an MMO). You will need to translate each of those content
 variations into many languages and store and load them accordingly.

tutorials/migrating/upgrading_to_godot_4.5.rst

@@ -258,14 +258,14 @@ Navigation
 
 .. note::
 
-    By default, the regions in a NavigationServer map now update asynchronously using threads to improve performance.
-    This can cause additional delay in the update due to thread synchronisation.
+    By default, the regions in a NavigationServer map update asynchronously using threads to improve performance.
+    This can cause additional delay in the update due to thread synchronization.
     The asynchronous region update can be toggled with the ``navigation/world/region_use_async_iterations`` project setting.
 
 .. note::
     The merging of navmeshes in the NavigationServer has changed processing order. Regions now merge and cache
     internal navmeshes first, then the remaining free edges are merged by the navigation map.
-    If a project had navigation map synchronisation errors before, it might now have shifted
+    If a project had navigation map synchronization errors before, it might now have shifted
     affected edges, making already existing errors in a layout more noticeable in the pathfinding.
     The ``navigation/2d_or_3d/merge_rasterizer_cell_scale`` project setting can be set to a lower value
     to increase the detail of the rasterization grid (with `0.01` being the smallest cell size possible).

tutorials/navigation/navigation_using_navigationagents.rst

@@ -79,7 +79,7 @@ Pathfollowing common problems
 There are some common user problems and important caveats to consider when writing agent movement scripts.
 
 - The path is returned empty
-    If an agent queries a path before the navigation map synchronisation, e.g. in a ``_ready()`` function, the path might return empty. In this case the ``get_next_path_position()`` function will return the same position as the agent parent node and the agent will consider the path end reached. This is fixed by making a deferred call or using a callback e.g. waiting for the navigation map changed signal.
+    If an agent queries a path before the navigation map synchronization, e.g. in a ``_ready()`` function, the path might return empty. In this case the ``get_next_path_position()`` function will return the same position as the agent parent node and the agent will consider the path end reached. This is fixed by making a deferred call or using a callback e.g. waiting for the navigation map changed signal.
 
 - The agent is stuck dancing between two positions
     This is usually caused by very frequent path updates every single frame, either deliberate or by accident (e.g. max path distance set too short). The pathfinding needs to find the closest position that are valid on navigation mesh. If a new path is requested every single frame the first path positions might end up switching constantly in front and behind the agent's current position, causing it to dance between the two positions.

tutorials/networking/http_request_class.rst

@@ -145,7 +145,8 @@ For example, to set a custom user agent (the HTTP ``User-Agent`` header) you cou
 
 .. danger::
 
-    Be aware that someone might analyse and decompile your released application and
-    thus may gain access to any embedded authorization information like tokens, usernames or passwords.
+    Be aware that someone might analyze and decompile your released application and
+    thus may gain access to any embedded authorization information like tokens, usernames, or passwords.
     That means it is usually not a good idea to embed things such as database
-    access credentials inside your game. Avoid providing information useful to an attacker whenever possible.
+    access credentials inside your game.
+    Avoid providing information useful to an attacker whenever possible.

tutorials/performance/cpu_optimization.rst

@@ -147,9 +147,9 @@ Understanding caching is also crucial to CPU optimization. If you have an
 algorithm (routine) that loads small bits of data from randomly spread out areas
 of main memory, this can result in a lot of cache misses, a lot of the time, the
 CPU will be waiting around for data instead of doing any work. Instead, if you
-can make your data accesses localised, or even better, access memory in a linear
-fashion (like a continuous list), then the cache will work optimally and the CPU
-will be able to work as fast as possible.
+can make your data accesses localized, or even better, access memory in a linear
+fashion (like a continuous list), then the cache, and therefore the CPU,
+will be able to work as efficiently as possible.
 
 Godot usually takes care of such low-level details for you. For example, the
 Server APIs make sure data is optimized for caching already for things like

tutorials/performance/optimizing_3d_performance.rst

@@ -175,9 +175,9 @@ Large worlds may need to be built in tiles that can be loaded on demand as you
 move around the world. This can prevent memory use from getting out of hand, and
 also limit the processing needed to the local area.
 
-There may also be rendering and physics glitches due to floating point error in
+There may also be rendering and physics bugs due to floating-point errors in
 large worlds. This can be resolved using :ref:`doc_large_world_coordinates`.
-If using large world coordinates is not an option, you may be able to use techniques
-such as orienting the world around the player (rather than the other way
-around), or shifting the origin periodically to keep things centred around
+If using large world coordinates is not an option, other common techniques include
+orienting the world around the player (rather than the other way
+around), or shifting the origin periodically to keep things centered around
 ``Vector3(0, 0, 0)``.

tutorials/performance/pipeline_compilations.rst

@@ -165,8 +165,8 @@ the changes are applied.
   a time to perform precompilation.
 - **Reflection Probes**: Enabled when a ReflectionProbe node is placed on the
   scene.
-- **Separate Specular**: Enabled when using effects like sub-surface scattering
-  or a compositor effect that relies on sampling the specularity directly off
+- **Separate Specular**: Enabled when using effects like subsurface scattering
+  or a compositor effect that relies on sampling the specularity directly from
   the screen.
 - **Motion Vectors**: Enabled when using effects such as TAA, FSR2 or a
   compositor effect that requires motion vectors (such as motion blur).

tutorials/physics/interpolation/physics_interpolation_introduction.rst

@@ -113,10 +113,11 @@ Let us consider only the position, and a situation where we know that the previo
 physics tick X coordinate was 10 units, and the current physics tick X coordinate
 is 30 units.
 
-.. note:: Although the maths is explained here, you do not have to worry about the
-          details, as this step will be performed for you. Under the hood, Godot
-          may use more complex forms of interpolation, but linear interpolation is
-          the easiest in terms of explanation.
+.. note::
+
+    Do not worry too much about the math, as the engine can mostly take care of it.
+    Although linear interpolation is described here for simplicity,
+    Godot itself may use different, more complex forms of interpolation.
 
 The physics interpolation fraction
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -200,7 +201,7 @@ Why look into the past? Why not predict the future?
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 There is an alternative to this scheme, which is: instead of interpolating between
-the previous and current tick, we use maths to *extrapolate* into the future. We
+the previous and current tick, we use math to *extrapolate* into the future. We
 try to predict where the object *will be*, rather than show it where it was. This
 can be done and may be offered as an option in future, but there are some
 significant downsides:

tutorials/physics/interpolation/using_physics_interpolation.rst

@@ -87,7 +87,7 @@ As a rough guide:
 
     "Better CPU performance","Good physics behavior in complex scenes","Good with fast physics"
     "Add some delay to input","Good for first person games","Good for racing games"
-    "Simple physics behaviour"
+    "Simple physics behavior"
 
 .. note:: You can always change the tick rate as you develop, it is as simple as
           changing the project setting.

tutorials/rendering/renderers.rst

@@ -319,7 +319,7 @@ See :ref:`doc_standard_material_3d` for more information.
 +-------------------------+--------------------------+--------------------------+--------------------------+
 | Feature                 | Compatibility            | Mobile                   | Forward+                 |
 +=========================+==========================+==========================+==========================+
-| Sub-surface scattering  | ❌ Not supported.        | ❌ Not supported.        | ✔️ Supported.            |
+| Subsurface scattering   | ❌ Not supported.        | ❌ Not supported.        | ✔️ Supported.            |
 |                         |                          |                          |                          |
 +-------------------------+--------------------------+--------------------------+--------------------------+
 

tutorials/scripting/gdscript/gdscript_basics.rst

@@ -2844,7 +2844,7 @@ In this case, the ``wait_confirmation`` becomes a coroutine, which means that th
         if confirmed:
             print("User confirmed")
         else:
-            print("User cancelled")
+            print("User canceled")
 
 Note that requesting a coroutine's return value without ``await`` will trigger an error:
 

tutorials/shaders/using_viewport_as_texture.rst

@@ -186,7 +186,9 @@ to make the planet. We will be using this noise function directly from a `Shader
                          dot(hash(i + vec3(1.0, 1.0, 1.0)), f - vec3(1.0, 1.0, 1.0)), u.x), u.y), u.z );
     }
 
-.. note:: All credit goes to the author, Inigo Quilez. It is published under the ``MIT`` licence.
+.. note::
+
+    All credit goes to the author, Inigo Quilez. It is published under the ``MIT`` license.
 
 Now to use ``noise``, add the following to the    ``fragment`` function: