Various grammar and spelling fixes

contributing/development/best_practices_for_engine_contributors.rst

@@ -60,7 +60,7 @@ order to achieve greater productivity. In this case, *a solution is needed*.
 
 Believing that problems may arise in the future and that the software needs to
 be ready to solve them by the time they appear is called *"Future proofing"* and
-its characterized by lines of thought such as:
+it's characterized by lines of thought such as:
 
 - I think it would be useful for users to...
 - I think users will eventually need to...

contributing/development/compiling/compiling_for_macos.rst

@@ -72,7 +72,7 @@ If all goes well, the resulting binary executable will be placed in the
 runs without any dependencies. Executing it will bring up the Project
 Manager.
 
-.. note:: Using a standalone editor executable is not recommended, it should be always packaged into an
+.. note:: Using a standalone editor executable is not recommended, it should be always packaged into a
           ``.app`` bundle to avoid UI activation issues.
 
 .. note:: If you want to use separate editor settings for your own Godot builds
@@ -83,7 +83,7 @@ Manager.
 Automatic ``.app`` bundle creation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-To automatically create an ``.app`` bundle like in the official builds, use the ``generate_bundle=yes`` option on the *last*
+To automatically create a ``.app`` bundle like in the official builds, use the ``generate_bundle=yes`` option on the *last*
 SCons command used to build editor:
 
 ::
@@ -101,7 +101,7 @@ run the above two commands and then use ``lipo`` to bundle them together:
 
     lipo -create bin/godot.macos.editor.x86_64 bin/godot.macos.editor.arm64 -output bin/godot.macos.editor.universal
 
-To create an ``.app`` bundle, you need to use the template located in ``misc/dist/macos_tools.app``. Typically, for an optimized
+To create a ``.app`` bundle, you need to use the template located in ``misc/dist/macos_tools.app``. Typically, for an optimized
 editor binary built with ``dev_build=yes``::
 
     cp -r misc/dist/macos_tools.app ./bin/Godot.app
@@ -169,11 +169,11 @@ x86_64 architectures.
     scons platform=macos target=template_debug arch=arm64
     scons platform=macos target=template_release arch=arm64 generate_bundle=yes
 
-To create an ``.app`` bundle like in the official builds, you need to use the
+To create a ``.app`` bundle like in the official builds, you need to use the
 template located in ``misc/dist/macos_template.app``. This process can be automated by using
 the ``generate_bundle=yes`` option on the *last* SCons command used to build export templates
 (so that all binaries can be included). This option also takes care of calling ``lipo`` to create
-an *Universal 2* binary from two separate ARM64 and x86_64 binaries (if both were compiled beforehand).
+a *Universal 2* binary from two separate ARM64 and x86_64 binaries (if both were compiled beforehand).
 
 .. note::
 

contributing/development/compiling/index.rst

@@ -7,7 +7,7 @@ Building from source
 
 .. highlight:: shell
 
-Godot prides itself on being very easy to build, by C++ projects' standards.
+Godot prides itself on being very easy to build, by C++ project standards.
 :ref:`Godot uses the SCons build system <doc_faq_why_scons>`, and after the initial
 setup compiling the engine for your current platform should be as easy as running:
 

contributing/development/core_and_modules/2d_coordinate_systems.rst

@@ -10,7 +10,7 @@ This is a detailed overview of the available 2D coordinate systems and 2D transf
 built in. The basic concepts are covered in :ref:`doc_viewport_and_canvas_transforms`.
 
 :ref:`Transform2D <class_Transform2D>` are matrices that convert coordinates from one coordinate
-system to an other. In order to use them, it is beneficial to know which coordinate systems are
+system to another. In order to use them, it is beneficial to know which coordinate systems are
 available in Godot. For a deeper understanding, the :ref:`doc_matrices_and_transforms` tutorial
 offers insights to the underlying functionality.
 
@@ -122,7 +122,7 @@ effects of each of them.
     viewport. This transform is used for :ref:`Windows <class_Window>` as described in
     :ref:`doc_multiple_resolutions`, but can also be manually set on *SubViewports* by means of
     :ref:`size <class_SubViewport_property_size>` and
-    :ref:`size_2d_override <class_SubViewport_property_size_2d_override>`. It's
+    :ref:`size_2d_override <class_SubViewport_property_size_2d_override>`. Its
     :ref:`translation <class_Transform2D_method_get_origin>`,
     :ref:`rotation <class_Transform2D_method_get_rotation>` and
     :ref:`skew <class_Transform2D_method_get_skew>` are the default values and it can only have

contributing/development/core_and_modules/binding_to_external_libraries.rst

@@ -167,7 +167,7 @@ environment's paths:
 
     # This is an absolute path where your .a libraries reside.
     # If using a relative path, you must convert it to a
-    # full path using an utility function, such as `Dir('...').abspath`.
+    # full path using a utility function, such as `Dir('...').abspath`.
     env.Append(LIBPATH=[Dir('libpath').abspath])
 
     # Check with the documentation of the external library to see which library

contributing/development/handling_compatibility_breakages.rst

@@ -44,7 +44,7 @@ the code, usually placed next to ``_bind_methods()``:
         static void _bind_compatibility_methods();
     #endif
 
-They should start with a ``_`` to indicate that they are internal, and end with ``_bind_compat_`` followed by the PR number
+They should start with an ``_`` to indicate that they are internal, and end with ``_bind_compat_`` followed by the PR number
 that introduced the change (``88047`` in this example). These compatibility methods need to be implemented in a dedicated file,
 like ``core/math/a_star_grid_2d.compat.inc`` in this case:
 

contributing/documentation/docs_image_guidelines.rst

@@ -25,7 +25,7 @@ On macOS, pressing :kbd:`Shift + Command + 3` does the same.
 To take a picture of the entire screen press :kbd:`Shift + Command + 4`.
 All screenshots taken will be saved to the desktop.
 
-Each Linux desktop environment has it's own screenshot tool. For example,
+Each Linux desktop environment has its own screenshot tool. For example,
 on KDE Plasma the program Spectacle is used for taking screenshots. If your
 distribution doesn't come with one by default try searching its package
 repository, or Flathub if that's supported.

contributing/documentation/updating_the_class_reference.rst

@@ -72,7 +72,7 @@ If you decide to document a class, but don't know what a particular method does,
 worry. Leave it for now, and list the methods you skipped when you open a pull request
 with your changes. Another writer will take care of it.
 
-You can still look at the methods' implementation in Godot's source code on GitHub.
+You can still look at the method's implementation in Godot's source code on GitHub.
 If you have doubts, feel free to ask on the `Godot Forum <https://forum.godotengine.org/>`_
 and `Godot Contributors Chat <https://chat.godotengine.org/>`_.
 

getting_started/step_by_step/scripting_player_input.rst

@@ -212,7 +212,7 @@ with the engine. These include ``_process()``, to apply changes to the node
 every frame, and ``_unhandled_input()``, to receive input events like key and
 button presses from the users. There are quite a few more.
 
-The ``Input`` singleton allows you to react to the players' input anywhere in
+The ``Input`` singleton allows you to react to the player's input anywhere in
 your code. In particular, you'll get to use it in the ``_process()`` loop.
 
 In the next lesson, :ref:`doc_signals`, we'll build upon the relationship between

tutorials/3d/lights_and_shadows.rst

@@ -189,7 +189,7 @@ Every face whose front-side is hit by the light rays is lit, while the others
 stay dark. Unlike most other light types, directional lights don't have specific
 parameters.
 
-The directional light also offers a **Angular Distance** property, which
+The directional light also offers an **Angular Distance** property, which
 determines the light's angular size in degrees. Increasing this above ``0.0``
 will make shadows softer at greater distances from the caster, while also
 affecting the sun's appearance in procedural sky materials. This is called a

tutorials/animation/animation_tree.rst

@@ -24,7 +24,7 @@ and then use an ``AnimationTree`` to control the playback.
 
 ``AnimationPlayer`` and ``AnimationTree`` can be used in both 2D and 3D scenes. When importing 3D scenes and their animations, you can use
 `name suffixes <https://docs.godotengine.org/en/stable/tutorials/assets_pipeline/importing_3d_scenes/node_type_customization.html#animation-loop-loop-cycle>`_
-to simplify the process and import with the correct properties. At the end, the imported Godot scene will contain the animations in a ``AnimationPlayer`` node.
+to simplify the process and import with the correct properties. At the end, the imported Godot scene will contain the animations in an ``AnimationPlayer`` node.
 Since you rarely use imported scenes directly in Godot (they are either instantiated or inherited from), you can place the ``AnimationTree`` node in your
 new scene which contains the imported one. Afterwards, point the ``AnimationTree`` node to the ``AnimationPlayer`` that was created in the imported scene.
 

tutorials/animation/creating_movies.rst

@@ -169,7 +169,7 @@ to another format for viewing on the web or by Godot with the VideoStreamPlayer
 node. MJPEG does not support transparency. AVI output is currently limited to a
 file of 4 GB in size at most.
 
-To use AVI, specify a path to an ``.avi`` file to be created in the
+To use AVI, specify a path to a ``.avi`` file to be created in the
 **Editor > Movie Writer > Movie File** project setting.
 
 PNG

tutorials/animation/playing_videos.rst

@@ -22,7 +22,7 @@ as it was too buggy and difficult to maintain.
 
 .. note::
 
-    You may find videos with an ``.ogg`` or ``.ogx`` extensions, which are generic
+    You may find videos with a ``.ogg`` or ``.ogx`` extensions, which are generic
     extensions for data within an Ogg container.
 
     Renaming these file extensions to ``.ogv`` *may* allow the videos to be
@@ -34,7 +34,7 @@ Setting up VideoStreamPlayer
 
 1. Create a VideoStreamPlayer node using the Create New Node dialog.
 2. Select the VideoStreamPlayer node in the scene tree dock, go to the inspector
-   and load an ``.ogv`` file in the Stream property.
+   and load a ``.ogv`` file in the Stream property.
 
    - If you don't have your video in Ogg Theora format yet, jump to
      :ref:`doc_playing_videos_recommended_theora_encoding_settings`.
@@ -183,7 +183,7 @@ maximize the quality of the output Ogg Theora video, but this can require a lot
 of disk space.
 
 `FFmpeg <https://ffmpeg.org/>`__ (CLI) is a popular open source tool
-for this purpose. FFmpeg has a steep learning curve, but it's powerful tool.
+for this purpose. FFmpeg has a steep learning curve, but it's a powerful tool.
 
 Here are example FFmpeg commands to convert an MP4 video to Ogg Theora. Since
 FFmpeg supports a lot of input formats, you should be able to use the commands

tutorials/best_practices/data_preferences.rst

@@ -105,7 +105,7 @@ Contiguous memory stores imply the following operation performance:
       though. Done by re-sorting the Array after every edit and writing an
       ordered-aware search algorithm.
 
-Godot implements Dictionary as an ``HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>``. The engine
+Godot implements Dictionary as a ``HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>``. The engine
 stores a small array (initialized to 2^3 or 8 records) of key-value pairs. When
 one attempts to access a value, they provide it a key. It then *hashes* the
 key, i.e. converts it into a number. The "hash" is used to calculate the index

tutorials/best_practices/scenes_versus_scripts.rst

@@ -10,7 +10,7 @@ declarative code.
 Each system's capabilities are different as a result.
 Scenes can define how an extended class initializes, but not what its
 behavior actually is. Scenes are often used in conjunction with a script,
-the scene declaring a composition of nodes, and the script adding behaviour with imperative code.
+the scene declaring a composition of nodes, and the script adding behavior with imperative code.
 
 Anonymous types
 ---------------

tutorials/editor/command_line_tutorial.rst

@@ -16,7 +16,7 @@ suitable for this workflow.
     On Windows and Linux, you can run a Godot binary in a terminal by specifying
     its relative or absolute path.
 
-    On macOS, the process is different due to Godot being contained within an
+    On macOS, the process is different due to Godot being contained within a
     ``.app`` bundle (which is a *folder*, not a file). To run a Godot binary
     from a terminal on macOS, you have to ``cd`` to the folder where the Godot
     application bundle is located, then run ``Godot.app/Contents/MacOS/Godot``

tutorials/editor/customizing_editor.rst

@@ -110,7 +110,7 @@ After making changes, open the **Editor** menu at the top of the editor then
 choose **Editor Layouts**. In the dropdown list, you will see a list of saved
 editor layouts, plus **Default** which is a hardcoded editor layout that can't
 be removed. The default layout matches a fresh Godot installation with no
-changes made to the docks' position and size, and no floating docks.
+changes made to the docks' positions and sizes, and no floating docks.
 
 You can remove a layout using the **Delete** option in the **Editor Layouts**
 dropdown.

tutorials/editor/index.rst

@@ -13,7 +13,7 @@ Editor's interface
 ------------------
 
 The following pages explain how to use the various windows, workspaces, and
-docks that make up the Godot editor. We cover some specific editors' interface
+docks that make up the Godot editor. We cover some specific editors' interfaces
 in other sections where appropriate. For example, the :ref:`animation editor
 <doc_introduction_animation>`.
 

tutorials/i18n/localization_using_gettext.rst

@@ -216,7 +216,7 @@ You can generate an MO file with the command below:
 
     msgfmt fr.po --no-hash -o fr.mo
 
-If the PO file is valid, this command will create a ``fr.mo`` file besides
+If the PO file is valid, this command will create an ``fr.mo`` file besides
 the PO file. This MO file can then be loaded in Godot as described above.
 
 The original PO file should be kept in version control so you can update

tutorials/io/data_paths.rst

@@ -126,7 +126,7 @@ File logging can also be disabled completely using the
 ``debug/file_logging/enable_file_logging`` project setting.
 
 When the project crashes, crash logs are written to the same file as the log
-file. The crash log will only contain an usable backtrace if the binary that was
+file. The crash log will only contain a usable backtrace if the binary that was
 run contains debugging symbols, or if it can find a debug symbols file that
 matches the binary. Official binaries don't provide debugging symbols, so this
 requires a custom build to work. See

tutorials/io/runtime_file_loading_and_saving.rst

@@ -169,7 +169,7 @@ Audio/video files
 -----------------
 
 Godot supports loading Ogg Vorbis, MP3, and WAV audio at runtime. Note that not *all*
-files with an ``.ogg`` extension are Ogg Vorbis files. Some may be Ogg Theora
+files with a ``.ogg`` extension are Ogg Vorbis files. Some may be Ogg Theora
 videos, or contain Opus audio within an Ogg container. These files will **not**
 load correctly as audio files in Godot.
 
@@ -191,7 +191,7 @@ Example of loading an Ogg Theora video file in a :ref:`class_VideoStreamPlayer`
 
     var video_stream_theora = VideoStreamTheora.new()
     # File extension is ignored, so it is possible to load Ogg Theora videos
-    # that have an `.ogg` extension this way.
+    # that have a `.ogg` extension this way.
     video_stream_theora.file = "/path/to/file.ogv"
     $VideoStreamPlayer.stream = video_stream_theora
 
@@ -203,7 +203,7 @@ Example of loading an Ogg Theora video file in a :ref:`class_VideoStreamPlayer`
 
     var videoStreamTheora = new VideoStreamTheora();
     // File extension is ignored, so it is possible to load Ogg Theora videos
-    // that have an `.ogg` extension this way.
+    // that have a `.ogg` extension this way.
     videoStreamTheora.File = "/Path/To/File.ogv";
     GetNode<VideoStreamPlayer>("VideoStreamPlayer").Stream = videoStreamTheora;
 

tutorials/performance/gpu_optimization.rst

@@ -65,7 +65,7 @@ other). This can be done by artists, or programmatically within Godot using an a
 There is also a cost to batching together objects in 3D. Several objects
 rendered as one cannot be individually culled. An entire city that is off-screen
 will still be rendered if it is joined to a single blade of grass that is on
-screen. Thus, you should always take objects' location and culling into account
+screen. Thus, you should always take objects' locations and culling into account
 when attempting to batch 3D objects together. Despite this, the benefits of
 joining static objects often outweigh other considerations, especially for large
 numbers of distant or low-poly objects.

tutorials/performance/pipeline_compilations.rst

@@ -134,7 +134,7 @@ the project or the environment. The pipeline precompilation system will keep
 track of these features as they're encountered for the first time and enable
 precompilation of them for any meshes or surfaces that are created afterwards.
 
-If your game makes use of these features, **make sure to have an scene that uses
+If your game makes use of these features, **make sure to have a scene that uses
 them as early as possible** before loading the majority of the assets. This
 scene can be very simple and will do the job as long as it uses the features the
 game plans to use. It can even be rendered off-screen for at least one frame if

tutorials/physics/interpolation/2d_and_3d_physics_interpolation.rst

@@ -34,7 +34,7 @@ This has some implications:
   Controlling the on / off behavior of 2D nodes therefore requires a little more
   thought and planning.
 - On the positive side, pivot behavior in the scene tree is perfectly preserved
-  during interpolation in 2D, which gives super smooth behaviour.
+  during interpolation in 2D, which gives super smooth behavior.
 
 Resetting physics interpolation
 -------------------------------

tutorials/physics/interpolation/physics_interpolation_introduction.rst

@@ -60,7 +60,7 @@ Adapt the tick rate?
 ~~~~~~~~~~~~~~~~~~~~
 
 Instead of designing the game at a fixed physics tick rate, we could allow the tick
-rate to scale according to the end users hardware. We could for example use a fixed
+rate to scale according to the end user's hardware. We could for example use a fixed
 tick rate that works for that hardware, or even vary the duration of each physics
 tick to match a particular frame duration.
 
@@ -70,7 +70,7 @@ run in the ``_physics_process``) work best and most consistently when run at a
 that has been designed for 60 TPS (ticks per second) at e.g. 10 TPS, the physics
 will behave completely differently. Controls may be less responsive, collisions /
 trajectories can be completely different. You may test your game thoroughly at 60
-TPS, then find it breaks on end users machines when it runs at a different tick
+TPS, then find it breaks on end users' machines when it runs at a different tick
 rate.
 
 This can make quality assurance difficult with hard to reproduce bugs, especially

tutorials/physics/using_jolt_physics.rst

@@ -8,7 +8,7 @@ Introduction
 
 The Jolt physics engine was added as an alternative to the existing Godot Physics
 physics engine in 4.4. Jolt is developed by Jorrit Rouwe with a focus on games and
-VR applications. Previously it was available as a extension but is now built into
+VR applications. Previously it was available as an extension but is now built into
 Godot.
 
 It is important to note that the built-in Jolt Physics module is considered

tutorials/platform/android/android_plugin.rst

@@ -138,7 +138,7 @@ Use the following steps if you have a v1 Android plugin you want to migrate to v
 
 3. After updating the Godot Android library dependency, sync or build the plugin and resolve any compile errors:
 
-    - The ``Godot`` instance provided by ``GodotPlugin::getGodot()`` no longer has access to a ``android.content.Context`` reference. Use ``GodotPlugin::getActivity()`` instead.
+    - The ``Godot`` instance provided by ``GodotPlugin::getGodot()`` no longer has access to an ``android.content.Context`` reference. Use ``GodotPlugin::getActivity()`` instead.
 
 4. Delete the ``gdap`` configuration file(s) and follow the instructions in the `Packaging a v2 Android plugin`_ section to set up the plugin configuration.
 

tutorials/plugins/editor/import_plugins.rst

@@ -241,7 +241,7 @@ you do this you have to be careful when you add more presets.
 This is the method which defines the available options.
 :ref:`_get_import_options() <class_EditorImportPlugin_private_method__get_import_options>` returns
 an array of dictionaries, and each dictionary contains a few keys that are
-checked to customize the option as its shown to the user. The following table
+checked to customize the option as it's shown to the user. The following table
 shows the possible keys:
 
 +-------------------+------------+----------------------------------------------------------------------------------------------------------+