Merge pull request #10346 from mhilbrunner/4.3-cherrypicks

4.3 cherrypicks

.github/workflows/build_offline_docs.yml

@@ -8,6 +8,9 @@ on:
 
 jobs:
   build:
+    # Don't run scheduled runs on forks unless the CI_OFFLINE_DOCS_CRON variable is set to 'true'.
+    # Manual runs can still be triggered as normal.
+    if: ${{ github.repository_owner == 'godotengine' || github.event_name != 'schedule' || vars.CI_OFFLINE_DOCS_CRON == 'true' }}
     runs-on: ubuntu-22.04
     strategy:
       matrix:

.github/workflows/ci.yml

@@ -10,7 +10,7 @@ concurrency:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -26,7 +26,8 @@ jobs:
       - name: Linter checks
         run: |
           bash _tools/format.sh
-          codespell -I _tools/codespell-ignore.txt -x _tools/codespell-ignore-lines.txt -S tutorials/i18n/locales.rst {about,community,contributing,getting_started,tutorials}/**/*.rst
+
+          codespell -D- -D _tools/codespell-dict.txt -I _tools/codespell-ignore.txt -x _tools/codespell-ignore-lines.txt -S tutorials/i18n/locales.rst {about,community,contributing,getting_started,tutorials}/{*.rst,**/*.rst,**/**/*.rst,**/**/**/*.rst}
 
       # Use dummy builder to improve performance as we don't need the generated HTML in this workflow.
       - name: Sphinx build

.github/workflows/sync_class_ref.yml

@@ -10,6 +10,9 @@ concurrency:
 
 jobs:
   build:
+    # Don't run scheduled runs on forks unless the CI_SYNC_CLASS_REF_CRON variable is set to 'true'.
+    # Manual runs can still be triggered as normal.
+    if: ${{ github.repository_owner == 'godotengine' || github.event_name != 'schedule' || vars.CI_SYNC_CLASS_REF_CRON == 'true' }}
     name: Update class reference files based on the engine revision
     runs-on: ubuntu-latest
     env:

_static/css/algolia.css

@@ -1,6 +0,0 @@
-.wy-nav-side { overflow: visible; }
-.wy-side-scroll { overflow-x: inherit; }
-
-.algolia-autocomplete {
-    display: block !important;
-}

_templates/layout.html

@@ -13,16 +13,6 @@
 
 {% block linktags -%}
   <meta name="theme-color" content="#3d8fcc" />
-  {% if godot_inject_language_links -%}
-  {% for alternate_lang in godot_docs_supported_languages -%}
-  {# Convert to ISO 639-1 format, e.g. zh_CN -> zh-cn -#}
-  {% set alternate_lang_href = alternate_lang.lower().replace("_", "-") -%}
-  <link rel="alternate" hreflang="{{ alternate_lang_href }}" href="{{ godot_docs_basepath }}{{ alternate_lang }}/{{ godot_canonical_version }}/{{ pagename }}{{ godot_docs_suffix }}" />
-  {% endfor -%}
-  <link rel="alternate" hreflang="x-default" href="{{ godot_docs_basepath }}{{ godot_default_lang }}/{{ godot_canonical_version }}/{{ pagename }}{{ godot_docs_suffix }}" />
-
-  <link rel="canonical" href="{{ godot_docs_basepath }}{{ lang_attr }}/{{ godot_canonical_version }}/{{ pagename }}{{ godot_docs_suffix }}" />
-  {% endif -%}
   {{ super() }}
 {% endblock -%}
 

_tools/codespell-dict.txt

@@ -0,0 +1 @@
+anti-aliasing->antialiasing

about/docs_changelog.rst

@@ -13,6 +13,52 @@ added since version 3.0.
 .. note:: This document only contains new pages so not all changes are reflected,
           many pages have been substantially updated but are not reflected in this document.
 
+New pages since version 4.2
+---------------------------
+
+About
+^^^^^
+
+- :ref:`doc_system_requirements`
+
+2D
+^^
+
+- :ref:`doc_2d_parallax`
+
+Contributing
+^^^^^^^^^^^^
+
+- :ref:`doc_handling_compatibility_breakages`
+- :ref:`doc_ways_to_contribute`
+
+GDExtension
+^^^^^^^^^^^
+
+- :ref:`doc_gdextension_file`
+- :ref:`doc_gdextension_docs_system`
+
+Migrating
+^^^^^^^^^
+
+- :ref:`doc_upgrading_to_godot_4.3`
+
+Rendering
+^^^^^^^^^
+
+- :ref:`doc_compositor`
+
+XR
+^^
+
+- :ref:`doc_a_better_xr_start_script`
+- :ref:`doc_openxr_passthrough`
+- :ref:`doc_xr_next_steps`
+- :ref:`doc_openxr_settings`
+- :ref:`doc_openxr_composition_layers`
+- :ref:`doc_openxr_body_tracking`
+
+
 New pages since version 4.1
 ---------------------------
 

about/introduction.rst

@@ -29,7 +29,7 @@ is a great starting point.
 
 In case you have trouble with one of the tutorials or your project,
 you can find help on the various `Community channels <https://godotengine.org/community/>`_,
-especially the Godot `Discord <https://discord.gg/bdcfAYM4W9>`_ community and
+especially the Godot `Discord <https://discord.gg/godotengine>`_ community and
 `Forum <https://forum.godotengine.org/>`_.
 
 About Godot Engine

about/list_of_features.rst

@@ -10,8 +10,8 @@ This page aims to list **all** features currently supported by Godot.
 .. note::
 
     This page lists features supported by the current stable version of
-    Godot. Some of these features may not be available in the
-    `LTS release series (3.x) <https://docs.godotengine.org/en/3.5/about/list_of_features.html>`__.
+    Godot. Some of these features are not available in the
+    `3.x release series <https://docs.godotengine.org/en/3.6/about/list_of_features.html>`__.
 
 Platforms
 ---------
@@ -30,8 +30,7 @@ Platforms
      on an old enough base distribution.
    - Official binaries are compiled using the
      `Godot Engine buildroot <https://github.com/godotengine/buildroot>`__,
-     allowing for binaries that work across common Linux distributions
-     (including LTS variants).
+     allowing for binaries that work across common Linux distributions.
 
 - Android (editor support is experimental).
 - :ref:`Web browsers <doc_using_the_web_editor>`. Experimental in 4.0,
@@ -367,7 +366,7 @@ Rendering
 - ETC2 (not supported on macOS).
 - S3TC (not supported on mobile/Web platforms).
 
-**Anti-aliasing:**
+**Antialiasing:**
 
 - Temporal :ref:`antialiasing <doc_3d_antialiasing>` (TAA).
 - AMD FidelityFX Super Resolution 2.2 :ref:`antialiasing <doc_3d_antialiasing>` (FSR2),

about/release_policy.rst

@@ -72,7 +72,7 @@ Whenever a new major version is released, we make the previous stable branch a
 long-term supported release, and do our best to provide fixes for issues
 encountered by users of that branch who cannot port complex projects to the new
 major version. This was the case for the 2.1 branch, and is the case for the
-3.6 branch.
+3.x branch.
 
 In a given minor release series, only the latest patch release receives support.
 If you experience an issue using an older patch release, please upgrade to the
@@ -82,8 +82,11 @@ on GitHub.
 +--------------+----------------------+--------------------------------------------------------------------------+
 | **Version**  | **Release date**     | **Support level**                                                        |
 +--------------+----------------------+--------------------------------------------------------------------------+
-| Godot 4.3    | June 2024            | |unstable| *Development.* Receives new features, usability and           |
-| (`master`)   | (estimate)           | performance improvements, as well as bug fixes, while under development. |
+| Godot 4.4    | Q1 2025 (estimate)   | |unstable| *Development.* Receives new features, usability and           |
+| (`master`)   |                      | performance improvements, as well as bug fixes, while under development. |
++--------------+----------------------+--------------------------------------------------------------------------+
+| Godot 4.3    | August 2024          | |supported| Receives fixes for bugs and security issues, as well as      |
+|              |                      | patches that enable platform support.                                    |
 +--------------+----------------------+--------------------------------------------------------------------------+
 | Godot 4.2    | November 2023        | |supported| Receives fixes for bugs and security issues, as well as      |
 |              |                      | patches that enable platform support.                                    |
@@ -93,8 +96,11 @@ on GitHub.
 +--------------+----------------------+--------------------------------------------------------------------------+
 | Godot 4.0    | March 2023           | |eol| No longer supported (last update: 4.0.4).                          |
 +--------------+----------------------+--------------------------------------------------------------------------+
-| Godot 3.6    | Q1 2024 (estimate)   | |supported| *Beta.* Receives new features, usability and performance     |
-| (`3.x`, LTS) |                      | improvements, as well as bug fixes, while under development.             |
+| Godot 3.7    | No ETA for now       | |supported| *Beta.* Receives new features, usability and performance     |
+| (`3.x`)      |                      | improvements, as well as bug fixes, while under development.             |
++--------------+----------------------+--------------------------------------------------------------------------+
+| Godot 3.6    | September 2024       | |supported| Receives fixes for bugs and security issues, as well as      |
+|              |                      | patches that enable platform support.                                    |
 +--------------+----------------------+--------------------------------------------------------------------------+
 | Godot 3.5    | August 2022          | |supported| Receives fixes for bugs and security issues, as well as      |
 |              |                      | patches that enable platform support.                                    |
@@ -212,11 +218,10 @@ Maintenance (patch) releases are released as needed with potentially very
 short development cycles, to provide users of the current stable branch with
 the latest bug fixes for their production needs.
 
-The 3.6 release is still planned and should be the last stable branch of Godot
-3.x. It will be a Long-Term Support (LTS) release, which we plan to support for
-as long as users still need it (due to missing features in Godot 4.x, or
-having published games which they need to keep updating for platform
-requirements).
+There is currently no planned release date for the next 3.x minor version, 3.7.
+The current stable release, 3.6, may be the last stable branch of Godot 3.x.
+Godot 3.x is supported on a best-effort basis, as long as contributors continue
+to maintain it.
 
 What are the criteria for compatibility across engine versions?
 ---------------------------------------------------------------

community/asset_library/submitting_to_assetlib.rst

@@ -211,12 +211,6 @@ You can check all assets currently pending a review `here <https://godotengine.o
 The approval process is manual and may take up to a few days for your asset to be accepted (or rejected), so please
 be patient!
 
-.. note::
-
-    You may have some luck accelerating the approval process by messaging the
-    moderators and AssetLib reviewers on the `Godot Contributors Chat <https://chat.godotengine.org/>`_,
-    or the official Discord server.
-
 You will be informed when your asset is reviewed. If it was rejected,
 you will be told why that may have been, and you will be able to submit it again
 with the appropriate changes.

conf.py

@@ -9,7 +9,7 @@ import os
 
 # -- General configuration ------------------------------------------------
 
-needs_sphinx = "1.3"
+needs_sphinx = "8.1"
 
 # Sphinx extension module names and templates location
 sys.path.append(os.path.abspath("_extensions"))
@@ -63,6 +63,9 @@ if not on_rtd:
 
 # Specify the site name for the Open Graph extension.
 ogp_site_name = "Godot Engine documentation"
+ogp_social_cards = {
+    "enable": False
+}
 
 if not os.getenv("SPHINX_NO_GDSCRIPT"):
     extensions.append("gdscript")
@@ -158,7 +161,6 @@ highlight_language = "gdscript"
 # -- Options for HTML output ----------------------------------------------
 
 html_theme = "sphinx_rtd_theme"
-html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
 if on_rtd:
     using_rtd_theme = True
 
@@ -168,8 +170,6 @@ html_theme_options = {
     "logo_only": True,
     # Collapse navigation (False makes it tree-like)
     "collapse_navigation": False,
-    # Hide the documentation version name/number under the logo
-    "display_version": False,
 }
 
 html_title = supported_languages[language] % ( "(" + version + ")" )
@@ -181,13 +181,9 @@ html_context = {
     "github_repo": "godot-docs",  # Repo name
     "github_version": "4.3",  # Version
     "conf_py_path": "/",  # Path in the checkout to the docs root
-    "godot_inject_language_links": True,
-    "godot_docs_supported_languages": list(supported_languages.keys()),
     "godot_docs_title": supported_languages[language],
     "godot_docs_basepath": "https://docs.godotengine.org/",
     "godot_docs_suffix": ".html",
-    "godot_default_lang": "en",
-    "godot_canonical_version": "stable",
     # Distinguish local development website from production website.
     # This prevents people from looking for changes on the production website after making local changes :)
     "godot_title_prefix": "" if on_rtd else "(DEV) ",
@@ -211,16 +207,14 @@ html_extra_path = ["robots.txt"]
 # These paths are either relative to html_static_path
 # or fully qualified paths (e.g. https://...)
 html_css_files = [
-    'css/algolia.css',
-    'https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.css',
-    "css/custom.css?10", # Increment the number at the end when the file changes to bust the cache.
+    "css/custom.css",
 ]
 
 if not on_rtd:
     html_css_files.append("css/dev.css")
 
 html_js_files = [
-    "js/custom.js?7", # Increment the number at the end when the file changes to bust the cache.
+    "js/custom.js",
 ]
 
 # Output file base name for HTML help builder

contributing/development/code_style_guidelines.rst

@@ -61,6 +61,8 @@ You need to use **clang-format 17** to be compatible with Godot's format. Later
 be suitable, but previous versions may not support all used options, or format
 some things differently, leading to style issues in pull requests.
 
+.. _doc_code_style_guidelines_pre_commit_hook:
+
 Pre-commit hook
 ^^^^^^^^^^^^^^^
 

contributing/development/compiling/getting_source.rst

@@ -32,8 +32,8 @@ the following in a terminal:
 ::
 
     git clone https://github.com/godotengine/godot.git
-    # You can add the --depth 1 argument to omit the commit history.
-    # Faster, but not all Git operations (like blame) will work.
+    # You can add the --depth 1 argument to omit the commit history (shallow clone).
+    # A shallow clone is faster, but not all Git operations (like blame) will work.
 
 For any stable release, visit the `release page <https://github.com/godotengine/godot/releases>`__
 and click on the link for the release you want.
@@ -42,13 +42,24 @@ You can then download and extract the source from the download link on the page.
 With ``git``, you can also clone a stable release by specifying its branch or tag
 after the ``--branch`` (or just ``-b``) argument::
 
-    # Clone the continuously maintained stable branch (`3.x` as of writing).
-    git clone https://github.com/godotengine/godot.git -b 3.x
+    # Clone the continuously maintained stable branch (`4.3` as of writing).
+    git clone https://github.com/godotengine/godot.git -b 4.3
 
-    # Clone the `3.2.3-stable` tag. This is a fixed revision that will never change.
-    git clone https://github.com/godotengine/godot.git -b 3.2.3-stable
+    # Clone the `4.3-stable` tag. This is a fixed revision that will never change.
+    git clone https://github.com/godotengine/godot.git -b 4.3-stable
 
-There are also generally branches besides ``master`` for each major version.
+    # After cloning, optionally go to a specific commit.
+    # This can be used to access the source code at a specific point in time,
+    # e.g. for development snapshots, betas and release candidates.
+    cd godot
+    git checkout f4af8201bac157b9d47e336203d3e8a8ef729de2
+
+The `maintenance branches <https://github.com/godotengine/godot/branches/all>`__
+are used to release further patches on each minor version.
+
+You can get the source code for each release and pre-release in ``.tar.xz`` format from
+`godotengine/godot-builds on GitHub <https://github.com/godotengine/godot-builds/releases>`__.
+This lacks version control information but has a slightly smaller download size.
 
 After downloading the Godot source code,
 you can :ref:`continue to compiling Godot <doc_introduction_to_the_buildsystem>`.

contributing/development/compiling/index.rst

@@ -19,6 +19,7 @@ The articles below should help you navigate configuration options available, as
 prerequisites required to compile Godot exactly the way you need.
 
 .. rubric:: Basics of building Godot
+   :heading-level: 2
 
 Let's start with basics, and learn how to get Godot's source code, and then which options
 to use to compile it regardless of your target platform.
@@ -31,6 +32,7 @@ to use to compile it regardless of your target platform.
    introduction_to_the_buildsystem
 
 .. rubric:: Building for target platforms
+   :heading-level: 2
 
 Below you can find instructions for compiling the engine for your specific target platform.
 Note that Godot supports cross-compilation, which means you can compile it for a target platform
@@ -50,6 +52,7 @@ will try their best to cover all possible situations.
    compiling_for_web
 
 .. rubric:: Other compilation targets and options
+   :heading-level: 2
 
 Some additional universal compilation options require further setup. Namely, while Godot
 does have C#/.NET support as a part of its main codebase, it does not get compiled by

contributing/development/configuring_an_ide/visual_studio_code.rst

@@ -139,6 +139,22 @@ To run and debug the project you need to create a new configuration in the ``lau
       "preLaunchTask": "build"
     }
 
+  .. code-tab:: js Mac
+
+    {
+      "name": "Launch Project",
+      "type": "lldb",
+      "request": "custom",
+      "targetCreateCommands": [
+        "target create ${workspaceFolder}/bin/godot.macos.editor.dev.x86_64"
+      ],
+      // Change the arguments below for the project you want to test with.
+      // To run the project instead of editing it, remove the "--editor" argument.
+      "processCreateCommands": [
+        "process launch -- --editor --path path-to-your-godot-project-folder"
+      ]
+    }
+
 .. figure:: img/vscode_2_launch.json.png
    :figclass: figure-w480
    :align: center

contributing/development/core_and_modules/custom_platform_ports.rst

@@ -82,7 +82,7 @@ for reference.
     class to get much of the work done automatically.
 
     If the platform is not UNIX-like, you might use the
-    `Windows port <https://github.com/godotengine/godot/blob/master/platform/windows/os_windows.cpp>`
+    `Windows port <https://github.com/godotengine/godot/blob/master/platform/windows/os_windows.cpp>`__
     as a reference.
 
 **detect.py file**
@@ -131,7 +131,8 @@ games.
     platform's screen resolution feature (if relevant). Any attempt to create
     or manipulate other window IDs can be rejected.
 - *If the target platform supports the graphics APIs in question:* Rendering
-  context for `Vulkan <https://github.com/godotengine/godot/blob/master/platform/linuxbsd/x11/vulkan_context_x11.cpp>`__,
+  context for `Vulkan <https://github.com/godotengine/godot/blob/master/platform/linuxbsd/x11/rendering_context_driver_vulkan_x11.cpp>`__,
+  `Direct3D 12 <https://github.com/godotengine/godot/blob/master/drivers/d3d12/rendering_context_driver_d3d12.cpp>`__
   `OpenGL 3.3 or OpenGL ES 3.0 <https://github.com/godotengine/godot/blob/master/platform/linuxbsd/x11/gl_manager_x11.cpp>`__.
 - Input handlers for `keyboard <https://github.com/godotengine/godot/blob/master/platform/linuxbsd/x11/key_mapping_x11.cpp>`__
   and `controller <https://github.com/godotengine/godot/blob/master/platform/linuxbsd/joypad_linux.cpp>`__.
@@ -157,8 +158,8 @@ games.
   is displayed at the top of the editor when one-click deploy is set up for the
   target platform.
 
-If the target platform doesn't support running Vulkan, OpenGL 3.3 or OpenGL ES 3.0,
-you have two options:
+If the target platform doesn't support running Vulkan, Direct3D 12, OpenGL 3.3,
+or OpenGL ES 3.0, you have two options:
 
 - Use a library at run-time to translate Vulkan or OpenGL calls to another graphics API.
   For example, `MoltenVK <https://moltengl.com/moltenvk/>`__ is used on macOS

contributing/development/core_and_modules/index.rst

@@ -7,6 +7,7 @@ The following pages are meant to introduce the global organization of Godot Engi
 source code, and give useful tips for extending and fixing the engine on the C++ side.
 
 .. rubric:: Getting started with Godot's source code
+   :heading-level: 2
 
 This section covers the basics that you will encounter in (almost) every source file.
 
@@ -25,6 +26,7 @@ This section covers the basics that you will encounter in (almost) every source
    scripting_development
 
 .. rubric:: Extending Godot by modifying its source code
+   :heading-level: 2
 
 This section covers what you can do by modifying Godot's C++ source code.
 

contributing/development/core_and_modules/variant_class.rst

@@ -6,22 +6,21 @@ Variant class
 About
 -----
 
-Variant is the most important datatype of Godot, it's the most important
-class in the engine. A Variant takes up only 20 bytes and can store
-almost any engine datatype inside of it. Variants are rarely used to
-hold information for long periods of time, instead they are used mainly
-for communication, editing, serialization and generally moving data
-around.
+Variant is the most important datatype in Godot. A Variant takes up only 24
+bytes on 64-bit platforms (20 bytes on 32-bit platforms) and can store almost
+any engine datatype inside of it. Variants are rarely used to hold information
+for long periods of time, instead they are used mainly for communication,
+editing, serialization and generally moving data around.
 
 A Variant can:
 
--  Store almost any datatype
+-  Store almost any datatype.
 -  Perform operations between many variants (GDScript uses Variant as
    its atomic/native datatype).
--  Be hashed, so it can be compared quickly to other variants
--  Be used to convert safely between datatypes
+-  Be hashed, so it can be compared quickly to other variants.
+-  Be used to convert safely between datatypes.
 -  Be used to abstract calling methods and their arguments (Godot
-   exports all its functions through variants)
+   exports all its functions through variants).
 -  Be used to defer calls or move data between threads.
 -  Be serialized as binary and stored to disk, or transferred via
    network.
@@ -34,27 +33,122 @@ Basically, thanks to the Variant class, writing Godot itself was a much,
 much easier task, as it allows for highly dynamic constructs not common
 of C++ with little effort. Become a friend of Variant today.
 
-References:
-~~~~~~~~~~~
+.. note::
+
+    All types within Variant except Nil and Object **cannot** be ``null`` and
+    must always store a valid value. These types within Variant are therefore
+    called *non-nullable* types.
+
+    One of the Variant types is *Nil* which can only store the value ``null``.
+    Therefore, it is possible for a Variant to contain the value ``null``, even
+    though all Variant types excluding Nil and Object are non-nullable.
+
+References
+~~~~~~~~~~
 
 -  `core/variant/variant.h <https://github.com/godotengine/godot/blob/master/core/variant/variant.h>`__
 
-Containers: Dictionary and Array
+List of variant types
+---------------------
+
+These types are available in Variant:
+
++---------------------------------+---------------------------+
+| Type                            | Notes                     |
++=================================+===========================+
+| Nil (can only store ``null``)   | Nullable type             |
++---------------------------------+---------------------------+
+| :ref:`class_bool`               |                           |
++---------------------------------+---------------------------+
+| :ref:`class_int`                |                           |
++---------------------------------+---------------------------+
+| :ref:`class_float`              |                           |
++---------------------------------+---------------------------+
+| :ref:`class_string`             |                           |
++---------------------------------+---------------------------+
+| :ref:`class_vector2`            |                           |
++---------------------------------+---------------------------+
+| :ref:`class_vector2i`           |                           |
++---------------------------------+---------------------------+
+| :ref:`class_rect2`              | 2D counterpart of AABB    |
++---------------------------------+---------------------------+
+| :ref:`class_rect2i`             |                           |
++---------------------------------+---------------------------+
+| :ref:`class_vector3`            |                           |
++---------------------------------+---------------------------+
+| :ref:`class_vector3i`           |                           |
++---------------------------------+---------------------------+
+| :ref:`class_transform2d`        |                           |
++---------------------------------+---------------------------+
+| :ref:`class_vector4`            |                           |
++---------------------------------+---------------------------+
+| :ref:`class_vector4i`           |                           |
++---------------------------------+---------------------------+
+| :ref:`class_plane`              |                           |
++---------------------------------+---------------------------+
+| :ref:`class_quaternion`         |                           |
++---------------------------------+---------------------------+
+| :ref:`class_aabb`               | 3D counterpart of Rect2   |
++---------------------------------+---------------------------+
+| :ref:`class_basis`              |                           |
++---------------------------------+---------------------------+
+| :ref:`class_transform3d`        |                           |
++---------------------------------+---------------------------+
+| :ref:`class_projection`         |                           |
++---------------------------------+---------------------------+
+| :ref:`class_color`              |                           |
++---------------------------------+---------------------------+
+| :ref:`class_stringname`         |                           |
++---------------------------------+---------------------------+
+| :ref:`class_nodepath`           |                           |
++---------------------------------+---------------------------+
+| :ref:`class_rid`                |                           |
++---------------------------------+---------------------------+
+| :ref:`class_object`             | Nullable type             |
++---------------------------------+---------------------------+
+| :ref:`class_callable`           |                           |
++---------------------------------+---------------------------+
+| :ref:`class_signal`             |                           |
++---------------------------------+---------------------------+
+| :ref:`class_dictionary`         |                           |
++---------------------------------+---------------------------+
+| :ref:`class_array`              |                           |
++---------------------------------+---------------------------+
+| :ref:`class_packedbytearray`    |                           |
++---------------------------------+---------------------------+
+| :ref:`class_packedint32array`   |                           |
++---------------------------------+---------------------------+
+| :ref:`class_packedint64array`   |                           |
++---------------------------------+---------------------------+
+| :ref:`class_packedfloat32array` |                           |
++---------------------------------+---------------------------+
+| :ref:`class_packedfloat64array` |                           |
++---------------------------------+---------------------------+
+| :ref:`class_packedstringarray`  |                           |
++---------------------------------+---------------------------+
+| :ref:`class_packedvector2array` |                           |
++---------------------------------+---------------------------+
+| :ref:`class_packedvector3array` |                           |
++---------------------------------+---------------------------+
+| :ref:`class_packedcolorarray`   |                           |
++---------------------------------+---------------------------+
+| :ref:`class_packedvector4array` |                           |
++---------------------------------+---------------------------+
+
+Containers: Array and Dictionary
 --------------------------------
 
-Both are implemented using variants. A Dictionary can match any datatype
-used as key to any other datatype. An Array just holds an array of
-Variants. Of course, a Variant can also hold a Dictionary and an Array
-inside, making it even more flexible.
+Both :ref:`class_array` and :ref:`class_dictionary` are implemented using
+variants. A Dictionary can match any datatype used as key to any other datatype.
+An Array just holds an array of Variants. Of course, a Variant can also hold a
+Dictionary or an Array inside, making it even more flexible.
 
 Modifications to a container will modify all references to
-it. A Mutex should be created to lock it if multi threaded access is
-desired.
-
-Copy-on-write (COW) mode support for containers was dropped with Godot 3.0.
+it. A Mutex should be created to lock it if
+:ref:`multi-threaded access <doc_using_multiple_threads>` is desired.
 
-References:
-~~~~~~~~~~~
+References
+~~~~~~~~~~
 
 -  `core/variant/dictionary.h <https://github.com/godotengine/godot/blob/master/core/variant/dictionary.h>`__
 -  `core/variant/array.h <https://github.com/godotengine/godot/blob/master/core/variant/array.h>`__

contributing/development/editor/creating_icons.rst

@@ -47,24 +47,9 @@ Icon optimization
 ~~~~~~~~~~~~~~~~~
 
 Because the editor renders SVGs once at load time, they need to be small
-in size so they can be efficiently parsed. Editor icons must be first
-optimized before being added to the engine, to do so:
-
-1. Install `svgcleaner <https://github.com/RazrFalcon/svgcleaner>`__
-   by downloading a binary from its
-   `Releases tab <https://github.com/RazrFalcon/svgcleaner/releases/latest>`__
-   and placing it into a location in your ``PATH`` environment variable.
-
-2. Run the command below, replacing ``svg_source.svg`` with the path to your
-   SVG file (which can be a relative or absolute path):
-
-   .. code-block:: bash
-
-       svgcleaner --multipass svg_source.svg svg_optimized.svg
-
-The ``--multipass`` switch improves compression, so make sure to include it.
-The optimized icon will be saved to ``svg_optimized.svg``. You can also change
-the destination parameter to any relative or absolute path you'd like.
+in size so they can be efficiently parsed. When the
+:ref:`pre-commit hook <doc_code_style_guidelines_pre_commit_hook>` runs, it automatically optimizes
+the SVG using `svgo <https://github.com/svg/svgo>`_.
 
 .. note::
 

contributing/documentation/contributing_to_the_documentation.rst

@@ -49,9 +49,11 @@ contribute, you should also read:
 Contributing changes
 --------------------
 
-**Pull Requests should use the** ``master`` **branch by default.** Only make Pull
-Requests against other branches (e.g. ``2.1`` or ``3.0``) if your changes only
-apply to that specific version of Godot.
+**Pull requests should use the** ``master`` **branch by default.** Only make pull
+requests against other branches (e.g. ``3.6`` or ``4.2``) if your changes only
+apply to that specific version of Godot. After a pull request is merged into
+``master``, it will usually be cherry-picked into the current stable branch by
+documentation maintainers.
 
 Though less convenient to edit than a wiki, this Git repository is where we
 write the documentation. Having direct access to the source files in a revision
@@ -81,20 +83,29 @@ and to log in to use it. Once logged in, you can propose change like so:
 
 1. Click the **Edit on GitHub** button.
 
-2. On the GitHub page you're taken to, click the pencil icon in the top-right
-   corner near the **Raw**, **Blame**, and **Delete** buttons. It has the
-   tooltip "Fork this project and edit the file".
+2. On the GitHub page you're taken to, make sure the current branch is "master".
+   Click the pencil icon in the top-right corner
+   near the **Raw**, **Blame**, and **Delete** buttons.
+   It has the tooltip "Fork this project and edit the file".
 
 3. Edit the text in the text editor.
 
-4. At the bottom of the web page, summarize the changes you made and click the
-   button **Propose file change**. Make sure to replace the placeholder "Update file.rst"
-   by a short but clear one-line description, as this is the commit title.
+4. Click "Commit changes...", summarize the changes you made
+   and make sure to replace the placeholder "Update file.rst" by a short
+   but clear one-line description, as this is the commit title.
+   Click the button **Propose changes**.
 
 5. On the following screens, click the **Create pull request** button until you
    see a message like *Username wants to merge 1 commit into godotengine:master
    from Username:patch-1*.
 
+.. note::
+
+   If there are more commits than your own in the pull request
+   it is likely that your branch was created using the wrong origin,
+   due to "master" not being the current branch in step 2.
+   You will need to rebase your branch to "master" or create a new branch.
+
 Another contributor will review your changes and merge them into the docs if
 they're good. They may also make changes or ask you to do so before merging.
 

contributing/workflow/bug_triage_guidelines.rst

@@ -34,7 +34,8 @@ to both issues and pull requests.
 Labels
 ~~~~~~
 
-The following labels are currently defined in the Godot repository:
+The following `labels <https://github.com/godotengine/godot/labels>`__ are
+currently defined in the Godot repository:
 
 **Categories:**
 
@@ -58,16 +59,19 @@ The following labels are currently defined in the Godot repository:
 -  *Discussion*: the issue is not consensual and needs further
    discussion to define what exactly should be done to address the
    topic.
--  *Documentation*: issue related to the documentation. Mainly to request
-   enhancements in the API documentation. Issues related to the ReadTheDocs
-   documentation should be filed on the
-   `godot-docs <https://github.com/godotengine/godot-docs>`_ repository.
+-  *Documentation*: related to the documentation. PRs with this label improve the
+   class reference. Issues with this label are either for wrong documentation, or
+   are user-reported "bugs" that are actually limitations to be further documented.
+   Often paired with *Discussion*. Issues related to the ReadTheDocs documentation
+   should be filed on the `godot-docs <https://github.com/godotengine/godot-docs>`_ repository.
 -  *Enhancement*: describes a proposed enhancement to an existing
    functionality.
 -  *Feature proposal*: describes a wish for a new feature to be
    implemented. Note that the main Godot repository no longer accepts
    feature requests. Please use
    `godot-proposals <https://github.com/godotengine/godot-proposals>`__ instead.
+   PRs which add new features but do not have a corresponding proposal use this
+   label.
 -  *For PR meeting*: the issue needs to be discussed in a pull request meeting.
    These meetings are public and are held on the `Godot Contributors Chat <https://chat.godotengine.org/>`_.
 -  *Good first issue*: the issue is *assumed* to be an easy one to fix, which makes
@@ -81,6 +85,7 @@ The following labels are currently defined in the Godot repository:
    on different hardware/software configurations or even that the steps to
    reproduce are not certain.
 -  *Needs work*: the pull request needs additional work before it can be merged.
+   Also for issues that are very incomplete, such as missing reproduction steps.
 -  *Performance*: issues that directly impact engine or editor performance.
    Can also be used for pull requests that improve performance or add low-end-friendly options.
    Should not be coupled with *Usability*.
@@ -124,7 +129,7 @@ describe an issue or pull request.
 -  *Input*: relates to the input system.
 -  *Multiplayer*: relates to multiplayer (high-level networking) systems.
 -  *Navigation*: relates to the navigation system (including A* and navmeshes).
--  *Network*: relates to (lot-level) networking.
+-  *Network*: relates to (low-level) networking.
 -  *Particles*: particles, particle systems and their editors.
 -  *Physics*: relates to the physics engine (2D/3D).
 -  *Plugin*: relates to problems encountered while writing plugins.
@@ -153,7 +158,7 @@ Documentation labels
 ~~~~~~~~~~~~~~~~~~~~
 
 In the `documentation repository <https://github.com/godotengine/godot-docs>`__, we
-use the following labels:
+use the following `labels <https://github.com/godotengine/godot-docs/labels>`__:
 
 -  *Archived*: either a duplicate of another issue, or invalid. Such an
    issue would also be closed.

contributing/workflow/pr_workflow.rst

@@ -97,9 +97,6 @@ To clone your fork from GitHub, use the following command:
 
     git clone https://github.com/USERNAME/godot
 
-.. note:: In our examples, the "$" character denotes the command line prompt
-          on typical UNIX shells. It is not part of the command and should
-          not be typed.
 
 After a little while, you should have a ``godot`` directory in your current
 working directory. Move into it using the ``cd`` command:

getting_started/first_2d_game/05.the_main_game_scene.rst

@@ -224,10 +224,6 @@ Note that a new instance must be added to the scene using ``add_child()``.
     // We also specified this function name in PascalCase in the editor's connection window.
     private void OnMobTimerTimeout()
     {
-        // Note: Normally it is best to use explicit types rather than the `var`
-        // keyword. However, var is acceptable to use here because the types are
-        // obviously Mob and PathFollow2D, since they appear later on the line.
-
         // Create a new instance of the Mob scene.
         Mob mob = MobScene.Instantiate<Mob>();
 

getting_started/first_3d_game/02.player_input.rst

@@ -84,6 +84,8 @@ Save the scene as ``player.tscn``
 With the nodes ready, we can almost get coding. But first, we need to define
 some input actions.
 
+.. _doc_first_3d_game_input_actions:
+
 Creating input actions
 ----------------------
 

getting_started/step_by_step/signals.rst

@@ -147,8 +147,8 @@ methods "_on_node_name_signal_name". Here, it'll be "_on_button_pressed".
 
 .. note::
 
-    If you are using an external editor (such as VS Code) this
-    automatic code generation might not work. In this case you need to to connect
+    If you are using an external editor (such as VS Code), this
+    automatic code generation might not work. In this case, you need to connect
     the signal via code as explained in the next section.
 
 Click the Connect button to complete the signal connection and jump to the

requirements.txt

@@ -3,29 +3,22 @@
 # https://github.com/readthedocs/readthedocs.org/blob/master/requirements/docs.txt
 
 # Base dependencies
-pygments==2.15.1
+pygments==2.18.0
 
 # Sphinx base and RTD theme.
-sphinx==4.4.0
-sphinx_rtd_theme==1.1.1
+sphinx==8.1.3
+sphinx_rtd_theme==3.0.1
 
 # Sphinx extensions.
 
 # Code tabs extension to display codeblocks in different languages as tabs.
-sphinx-tabs==3.4.0
+sphinx-tabs==3.4.7
 # Adds a 'copy' button to the right of codeblocks.
-sphinx-copybutton==0.5.1
+sphinx-copybutton==0.5.2
 # Custom 404 error page (more useful than the default).
-sphinx-notfound-page==0.8.3
+sphinx-notfound-page==1.0.4
 # Adds Open Graph tags in the HTML `<head>` tag.
-sphinxext-opengraph==0.7.5
-
-# These get pulled in by Sphinx, we need to pin these as higher versions require Sphinx 5.0+.
-sphinxcontrib-applehelp==1.0.4
-sphinxcontrib-htmlhelp==2.0.1
-sphinxcontrib-qthelp==1.0.3
-sphinxcontrib-serializinghtml==1.1.5
-sphinxcontrib-devhelp==1.0.2
+sphinxext-opengraph==0.9.1
 
 # `.. video::` directive support to embed videos in documentation pages.
-sphinxcontrib-video==0.2.1rc0
+sphinxcontrib-video==0.2.1

tutorials/2d/2d_parallax.rst

@@ -1,4 +1,4 @@
-.. doc_2d_parallax:
+.. _doc_2d_parallax:
 
 2D Parallax
 ===========

tutorials/2d/custom_drawing_in_2d.rst

@@ -487,7 +487,7 @@ You should get the following output:
 Unlike ``draw_polygon()``, polylines can only have a single unique color
 for all its points (the second argument). This method has 2 additional
 arguments: the width of the line (which is as small as possible by default)
-and enabling or disabling the anti-aliasing (it is disabled by default).
+and enabling or disabling the antialiasing (it is disabled by default).
 
 The order of the ``_draw`` calls is important- like with the Node positions on
 the tree hierarchy, the different shapes will be drawn from top to bottom,

tutorials/2d/index.rst

@@ -10,6 +10,8 @@
    canvas_layers
    2d_transforms
 
+.. _doc_2d_rendering:
+
 Rendering
 ---------
 

tutorials/3d/index.rst

@@ -12,6 +12,8 @@
    procedural_geometry/index
    3d_text
 
+.. _doc_3d_rendering:
+
 Rendering
 ---------
 
@@ -54,3 +56,4 @@ Tools
 
    csg_tools
    using_gridmaps
+   spring_arm

tutorials/3d/particles/index.rst

@@ -8,8 +8,8 @@ Particle systems (3D)
 This section of the tutorial covers (3D) GPU-accelerated particle systems. Most of the things
 discussed here apply to CPU particles as well.
 
-Introduction
-------------
+.. rubric:: Introduction
+   :heading-level: 2
 
 You can use particle systems to simulate complex physical effects like fire, sparks,
 smoke, magical effects, and many more. They are very well suited for creating dynamic and organic
@@ -22,8 +22,8 @@ parameters and behaviors.
 
 Every particle system you create in Godot consists of two main parts: particles and emitters.
 
-Particles
-~~~~~~~~~
+.. rubric:: Particles
+   :heading-level: 3
 
 A particle is the visible part of a particle system. It's what you see on the screen when a particle
 system is active: The tiny specks of dust, the flames of a fire, the glowing orbs of a magical
@@ -32,16 +32,16 @@ single system. You can randomize a particle's size, its speed and movement direc
 color over the course of its lifetime. When you think of a fire, you can think of all the little
 embers flying away from it as individual particles.
 
-Emitters
-~~~~~~~~
+.. rubric:: Emitters
+   :heading-level: 3
 
 An emitter is what's creating the particles. Emitters are usually not visible, but they can have
 a shape. That shape controls where and how particles are spawned, for example whether they should fill
 a room like dust or shoot away from a single point like a fountain. Going back to the fire example,
 an emitter would be the heat at the center of the fire that creates the embers and the flames.
 
-Node overview
-~~~~~~~~~~~~~
+.. rubric:: Node overview
+   :heading-level: 3
 
 .. figure:: img/particle_nodes.webp
    :alt: A list of nodes related to 3D particles
@@ -75,8 +75,8 @@ colliders by hand. If you want particles to collide with large outdoor scenes, y
 objects in it and uses that for large-scale particle collisions.
 
 
-Basic usage
------------
+.. rubric:: Basic usage
+   :heading-level: 2
 
 .. toctree::
    :maxdepth: 1
@@ -86,8 +86,8 @@ Basic usage
    properties
    process_material_properties
 
-Advanced topics
----------------
+.. rubric:: Advanced topics
+   :heading-level: 2
 
 .. toctree::
    :maxdepth: 1

tutorials/3d/particles/properties.rst

@@ -98,7 +98,7 @@ property has no effect.
    :alt: Particles running at low FPS
    :align: right
 
-   Interpolation on (left) vs. off (right)
+   Interpolation off (left) vs. on (right)
 
 The ``Fixed FPS`` property limits how often the particle system is processed. This includes
 property updates as well as collision and attractors. This can improve performance a lot,

tutorials/3d/spring_arm.rst

@@ -0,0 +1,125 @@
+:article_outdated: False
+
+.. _doc_spring_arm:
+
+Third-person camera with spring arm
+===================================
+
+Introduction
+------------
+
+3D games will often have a third-person camera that follows and
+rotates around something such as a player character or a vehicle.
+
+In Godot, this can be done by setting a :ref:`Camera3D <class_Camera3D>` as a child of a node.
+However, if you try this without any extra steps you'll notice that the camera clips through geometry and hides the scene.
+
+This is where the :ref:`SpringArm3D <class_SpringArm3D>` node comes in.
+
+What is a spring arm?
+---------------------
+
+A spring arm has two main components that affect its behavior.
+
+The "length" of the spring arm is how far from its global position to check for collisions:
+
+.. image:: img/spring_arm_position_length.webp
+
+The "shape" of the spring arm is what it uses to check for collisions. The spring arm will "sweep" this shape from its origin out towards its length.
+
+.. image:: img/spring_arm_shape.webp
+
+The spring arm tries to keep all of its children at the end of its length. When the shape collides with something, the children are instead placed at or near that collision point:
+
+.. image:: img/spring_arm_children.webp
+
+Spring arm with a camera
+------------------------
+
+When a camera is placed as a child of a spring arm, a pyramid representing the camera will be used as the shape.
+
+This pyramid represents the **near plane** of the camera:
+
+.. image:: img/spring_arm_camera_shape.webp
+
+.. note:: If the spring arm is given a specific shape, then that shape will **always** be used.
+
+    The camera's shape is only used if the camera is a **direct child** of the spring arm.
+
+    If no shape is provided and the camera is not a direct child, the spring arm will fall back to using a ray cast which is inaccurate for camera collisions and not recommended.
+
+Every physics process frame, the spring arm will perform a motion cast to check if anything is collided with:
+
+.. image:: img/spring_arm_camera_motion_cast.webp
+
+When the shape hits something, the camera will be placed at or near the collision point:
+
+.. image:: img/spring_arm_camera_collision.webp
+
+Setting up the spring arm and camera
+------------------------------------
+
+Let's add a spring arm camera setup to the platformer demo.
+
+.. note:: You can download the Platformer 3D demo on `GitHub <https://github.com/godotengine/godot-demo-projects/tree/master/3d/platformer>`_ or using the `Asset Library <https://godotengine.org/asset-library/asset/2748>`_.
+
+In general, for a third-person camera setup, you will have three nodes as children of the node that you're following:
+
+- `Node3D` (the "pivot point" for the camera)
+
+    - `SpringArm3D`
+
+        - `Camera3D`
+
+Open the ``player/player.tscn`` scene. Set these up as children of our player and give them unique names so we can find them in our script. **Make sure to delete the existing camera node!**
+
+.. image:: img/spring_arm_editor_setup.webp
+
+Let's move the pivot point up by ``2`` on the Y-axis so that it's not on the ground:
+
+.. image:: img/spring_arm_pivot_setup.webp
+
+
+Give the spring arm a length of ``3`` so that it is placed behind the character:
+
+.. image:: img/spring_arm_length_setup.webp
+
+.. note:: Leave the **Shape** of the spring arm as ``<empty>``. This way, it will use the camera's pyramid shape.
+
+    If you want, you can also try other shapes - a sphere is a common choice since it slides smoothly along edges.
+
+Update the top of ``player/player.gd`` to grab the camera and the pivot points by their unique names:
+
+.. code-block:: gdscript
+    :caption: player/player.gd
+
+    # Comment out this existing camera line.
+    # @onready var _camera := $Target/Camera3D as Camera3D
+
+    @onready var _camera := %Camera3D as Camera3D
+    @onready var _camera_pivot := %CameraPivot as Node3D
+
+Add an ``_unhandled_input`` function to check for camera movement and then rotate the pivot point accordingly:
+
+.. code-block:: gdscript
+    :caption: player/player.gd
+
+    @export_range(0.0, 1.0) var mouse_sensitivity = 0.01
+    @export var tilt_limit = deg_to_rad(75)
+
+
+    func _unhandled_input(event: InputEvent) -> void:
+        if event is InputEventMouseMotion:
+            _camera_pivot.rotation.x -= event.relative.y * mouse_sensitivity
+            # Prevent the camera from rotating too far up or down.
+            _camera_pivot.rotation.x = clampf(_camera_pivot.rotation.x, -tilt_limit, tilt_limit)
+            _camera_pivot.rotation.y += -event.relative.x * mouse_sensitivity
+
+By rotating the pivot point, the spring arm will also be rotated and it will change where the camera is positioned.
+Run the game and notice that mouse movement now rotates the camera around the character. If the camera moves into a wall, it collides with it.
+
+.. video:: video/spring_arm_camera.webm
+   :alt: Camera attached to a spring arm colliding with walls
+   :autoplay:
+   :loop:
+   :muted:

tutorials/3d/standard_material_3d.rst

@@ -295,13 +295,10 @@ Specifies how the specular blob will be rendered. The specular blob
 represents the shape of a light source reflected in the object.
 
 * **SchlickGGX:** The most common blob used by PBR 3D engines nowadays.
-* **Blinn:** Common in previous-generation engines.
-  Not worth using nowadays, but left here for the sake of compatibility.
-* **Phong:** Same as above.
 * **Toon:** Creates a toon blob, which changes size depending on roughness.
 * **Disabled:** Sometimes the blob gets in the way. Begone!
 
-.. image:: img/spatial_material7.png
+.. image:: img/spatial_material7.webp
 
 Disable Ambient Light
 ~~~~~~~~~~~~~~~~~~~~~
@@ -658,6 +655,12 @@ make it black and unshaded, reverse culling (Cull Front), and add some grow:
 
 .. image:: img/spatial_material11.png
 
+.. note::
+
+    For Grow to work as expected, the mesh must have connected faces with shared
+    vertices, or "smooth shading". If the mesh has disconnected faces with unique
+    vertices, or "flat shading", the mesh will appear to have gaps when using Grow.
+
 Transform
 ---------
 

tutorials/animation/2d_skeletons.rst

@@ -13,8 +13,7 @@ and most 3D modeling applications support it. For 2D, as this function is not
 used as often, it's difficult to find mainstream software aimed for this.
 
 One option is to create animations in third-party software such as Spine or
-Dragonbones. From Godot 3.1 onwards, though, this functionality is supported
-built-in.
+Dragonbones. This functionality is also supported built-in.
 
 Why would you want to do skeletal animations directly in Godot? The answer is
 that there are many advantages to it:

tutorials/animation/animation_tree.rst

@@ -12,9 +12,6 @@ function calling, audio and sub-animation tracks, is pretty much unique.
 
 However, the support for blending those animations via ``AnimationPlayer`` is relatively limited, as only a fixed cross-fade transition time can be set.
 
-:ref:`AnimationTree <class_AnimationTree>` is a new node introduced in Godot 3.1 to deal with advanced transitions.
-It supersedes the ancient ``AnimationTreePlayer``, while adding a huge amount of features and flexibility.
-
 Creating an AnimationTree
 -------------------------
 

tutorials/assets_pipeline/importing_3d_scenes/available_formats.rst

@@ -156,7 +156,9 @@ the built-in Collada support may still work for simple scenes without animation.
 
 For complex scenes or scenes that contain animations, Godot provides a
 `Blender plugin <https://github.com/godotengine/collada-exporter>`_
-that will correctly export COLLADA scenes for use in Godot.
+that will correctly export COLLADA scenes for use in Godot. This plugin is
+not maintained or supported in Godot 4.x, but may still work depending on your
+Godot and Blender versions.
 
 Importing OBJ files in Godot
 ----------------------------

tutorials/audio/audio_buses.rst

@@ -88,6 +88,16 @@ Finally, toggle the **Playing** property to **On** and sound will flow.
 Adding effects
 --------------
 
+.. warning::
+
+    This feature is not supported on the web platform if the AudioStreamPlayer's
+    playback mode is set to **Sample**, which is the default. It will only work if the
+    playback mode is set to **Stream**, at the cost of increased latency if threads
+    are not enabled.
+
+    See :ref:`Audio playback in the Exporting for the Web documentation <doc_exporting_for_web_audio_playback>`
+    for details.
+
 Audio buses can contain all sorts of effects. These effects modify the sound in
 one way or another and are applied in order.
 

tutorials/audio/audio_streams.rst

@@ -80,6 +80,16 @@ Unlike for 2D, the 3D version of AudioStreamPlayer has a few more advanced optio
 Reverb buses
 ~~~~~~~~~~~~
 
+.. warning::
+
+    This feature is not supported on the web platform if the AudioStreamPlayer's
+    playback mode is set to **Sample**, which is the default. It will only work if the
+    playback mode is set to **Stream**, at the cost of increased latency if threads
+    are not enabled.
+
+    See :ref:`Audio playback in the Exporting for the Web documentation <doc_exporting_for_web_audio_playback>`
+    for details.
+
 Godot allows for 3D audio streams that enter a specific Area3D node to send dry
 and wet audio to separate buses. This is useful when you have several reverb
 configurations for different types of rooms. This is done by enabling this type
@@ -102,6 +112,16 @@ that effect.
 Doppler
 ~~~~~~~
 
+.. warning::
+
+    This feature is not supported on the web platform if the AudioStreamPlayer's
+    playback mode is set to **Sample**, which is the default. It will only work if the
+    playback mode is set to **Stream**, at the cost of increased latency if threads
+    are not enabled.
+
+    See :ref:`Audio playback in the Exporting for the Web documentation <doc_exporting_for_web_audio_playback>`
+    for details.
+
 When the relative velocity between an emitter and listener changes, this is
 perceived as an increase or decrease in the pitch of the emitted sound.
 Godot can track velocity changes in the AudioStreamPlayer3D and Camera nodes.

tutorials/audio/sync_with_audio.rst

@@ -23,7 +23,9 @@ The most common way to reduce latency is to shrink the audio buffers (again, by
 
 This is a common tradeoff, so Godot ships with sensible defaults that should not need to be altered.
 
-The problem, in the end, is not this slight delay but synchronizing graphics and audio for games that require it. Beginning with Godot 3.2, some helpers were added to obtain more precise playback timing.
+The problem, in the end, is not this slight delay but synchronizing graphics and
+audio for games that require it. Some helpers are available to obtain more 
+precise playback timing.
 
 Using the system clock to sync
 ------------------------------

tutorials/best_practices/scenes_versus_scripts.rst

@@ -118,8 +118,6 @@ There are two systems for registering types:
    - Engine developers must add support for languages manually (both name exposure and
      runtime accessibility).
 
-   - Godot 3.1+ only.
-
    - The Editor scans project folders and registers any exposed names for all
      scripting languages. Each scripting language must implement its own
      support for exposing this information.

tutorials/editor/default_key_mapping.rst

@@ -7,22 +7,25 @@
 
 Default editor shortcuts
 ========================
-Many of Godot Editor functions can be executed with keyboard shortcuts. This page
+
+Many Godot editor functions can be executed with keyboard shortcuts. This page
 lists functions which have associated shortcuts by default, but many others are
 available for customization in editor settings as well. To change keys associated
-with these and other actions navigate to ``Editor -> Editor Settings -> Shortcuts``.
+with these and other actions navigate to **Editor > Editor Settings > Shortcuts**.
 
 While some actions are universal, a lot of shortcuts are specific to individual
 tools. For this reason it is possible for some key combinations to be assigned
 to more than one function. The correct action will be performed depending on the
 context.
 
-.. note:: While Windows and Linux builds of the editor share most of the default settings,
-          some shortcuts may differ for macOS version. This is done for better integration
-          of the editor into macOS ecosystem. Users fluent with standard shortcuts on that
-          OS should find Godot Editor's default key mapping intuitive.
+.. note::
+
+    While Windows and Linux builds of the editor share most of the default settings,
+    some shortcuts may differ for macOS version. This is done for better integration
+    of the editor into macOS ecosystem. Users fluent with standard shortcuts on that
+    OS should find Godot Editor's default key mapping intuitive.
 
-General Editor Actions
+General editor actions
 ----------------------
 
 +-----------------------+-------------------------------+------------------------------+----------------------------------+
@@ -86,9 +89,35 @@ General Editor Actions
 +-----------------------+-------------------------------+------------------------------+----------------------------------+
 | Expand Bottom Panel   | :kbd:`Shift + F12`            | :kbd:`Shift + F12`           | ``editor/bottom_panel_expand``   |
 +-----------------------+-------------------------------+------------------------------+----------------------------------+
+| Command Palette       | :kbd:`Ctrl + Shift + P`       | :kbd:`Cmd + Shift + P`       | ``editor/command_palette``       |
++-----------------------+-------------------------------+------------------------------+----------------------------------+
 
-2D / Canvas Item Editor
------------------------
+Bottom panels
+-------------
+
+Only bottom panels that are always available have a default shortcut assigned.
+Others must be manually bound in the Editor Settings if desired.
+
++-----------------------------------+-----------------+-----------------+-----------------------------------------------------+
+| Action name                       | Windows, Linux  | macOS           | Editor setting                                      |
++===================================+=================+=================+=====================================================+
+| Toggle Last Opened Panel          | :kbd:`Ctrl + J` | :kbd:`Ctrl + J` | ``editor/toggle_last_opened_bottom_panel``          |
++-----------------------------------+-----------------+-----------------+-----------------------------------------------------+
+| Toggle Animation Bottom Panel     | :kbd:`Alt + N`  | :kbd:`Alt + N`  | ``bottom_panels/toggle_animation_bottom_panel``     |
++-----------------------------------+-----------------+-----------------+-----------------------------------------------------+
+| Toggle Audio Bottom Panel         | :kbd:`Alt + A`  | :kbd:`Alt + A`  | ``bottom_panels/toggle_audio_bottom_panel``         |
++-----------------------------------+-----------------+-----------------+-----------------------------------------------------+
+| Toggle Debugger Bottom Panel      | :kbd:`Alt + D`  | :kbd:`Alt + D`  | ``bottom_panels/toggle_debugger_bottom_panel``      |
++-----------------------------------+-----------------+-----------------+-----------------------------------------------------+
+| Toggle FileSystem Bottom Panel    | :kbd:`Alt + F`  | :kbd:`Alt + F`  | ``bottom_panels/toggle_filesystem_bottom_panel``    |
++-----------------------------------+-----------------+-----------------+-----------------------------------------------------+
+| Toggle Output Bottom Panel        | :kbd:`Alt + O`  | :kbd:`Alt + O`  | ``bottom_panels/toggle_output_bottom_panel``        |
++-----------------------------------+-----------------+-----------------+-----------------------------------------------------+
+| Toggle Shader Editor Bottom Panel | :kbd:`Alt + S`  | :kbd:`Alt + S`  | ``bottom_panels/toggle_shader_editor_bottom_panel`` |
++-----------------------------------+-----------------+-----------------+-----------------------------------------------------+
+
+2D / CanvasItem editor
+----------------------
 
 +------------------------------+-------------------------+------------------------+--------------------------------------------------------+
 | Action name                  | Windows, Linux          | macOS                  | Editor setting                                         |
@@ -142,7 +171,7 @@ General Editor Actions
 
 .. _doc_default_key_mapping_shortcuts_spatial_editor:
 
-3D / Spatial Editor
+3D / Spatial editor
 -------------------
 
 +------------------------------------+-----------------------+----------------------+--------------------------------------------------+
@@ -217,7 +246,7 @@ General Editor Actions
 | 4 Viewports                        | :kbd:`Ctrl + 4`       | :kbd:`Cmd + 4`       | ``spatial_editor/4_viewports``                   |
 +------------------------------------+-----------------------+----------------------+--------------------------------------------------+
 
-Text Editor
+Text editor
 -----------
 
 +---------------------------+---------------------------------+----------------------------------+-------------------------------------------------+
@@ -300,7 +329,7 @@ Text Editor
 | Contextual Help           | :kbd:`Alt + F1`                 | :kbd:`Opt + Shift + Space`       | ``script_text_editor/contextual_help``          |
 +---------------------------+---------------------------------+----------------------------------+-------------------------------------------------+
 
-Script Editor
+Script editor
 -------------
 
 +----------------------+---------------------------------+---------------------------------+----------------------------------------+
@@ -347,7 +376,7 @@ Script Editor
 | Reset Zoom           | :kbd:`Ctrl + 0`                 | :kbd:`Cmd + 0`                  | ``script_editor/reset_zoom``           |
 +----------------------+---------------------------------+---------------------------------+----------------------------------------+
 
-Editor Output
+Editor output
 -------------
 
 +----------------+-------------------------+------------------------+-------------------------+
@@ -371,7 +400,7 @@ Debugger
 | Continue    | :kbd:`F12`     | :kbd:`F12` | ``debugger/continue``  |
 +-------------+----------------+------------+------------------------+
 
-File Dialog
+File dialog
 -----------
 
 +---------------------+--------------------------+--------------------------+-------------------------------------+
@@ -395,14 +424,14 @@ File Dialog
 +---------------------+--------------------------+--------------------------+-------------------------------------+
 | Delete              | :kbd:`Del`               | :kbd:`Cmd + BkSp`        | ``file_dialog/delete``              |
 +---------------------+--------------------------+--------------------------+-------------------------------------+
-| Focus Path          | :kbd:`Ctrl + D`          | :kbd:`Cmd + D`           | ``file_dialog/focus_path``          |
+| Focus Path          | :kbd:`Ctrl + L`          | :kbd:`Cmd + Shift + G`   | ``file_dialog/focus_path``          |
 +---------------------+--------------------------+--------------------------+-------------------------------------+
 | Move Favorite Up    | :kbd:`Ctrl + Up Arrow`   | :kbd:`Cmd + Up Arrow`    | ``file_dialog/move_favorite_up``    |
 +---------------------+--------------------------+--------------------------+-------------------------------------+
 | Move Favorite Down  | :kbd:`Ctrl + Down Arrow` | :kbd:`Cmd + Down Arrow`  | ``file_dialog/move_favorite_down``  |
 +---------------------+--------------------------+--------------------------+-------------------------------------+
 
-FileSystem Dock
+FileSystem dock
 ---------------
 
 +-------------+-----------------+-------------------+-------------------------------+
@@ -415,7 +444,7 @@ FileSystem Dock
 | Delete      | :kbd:`Del`      | :kbd:`Cmd + BkSp` | ``filesystem_dock/delete``    |
 +-------------+-----------------+-------------------+-------------------------------+
 
-Scene Tree Dock
+Scene tree dock
 ---------------
 
 +----------------+--------------------------+-------------------------+----------------------------------+
@@ -438,7 +467,7 @@ Scene Tree Dock
 | Move Down      | :kbd:`Ctrl + Down Arrow` | :kbd:`Cmd + Down Arrow` | ``scene_tree/move_down``         |
 +----------------+--------------------------+-------------------------+----------------------------------+
 
-Animation Track Editor
+Animation track editor
 ----------------------
 
 +----------------------+---------------------------+--------------------------+-----------------------------------------------------+
@@ -455,8 +484,8 @@ Animation Track Editor
 | Go to Previous Step  | :kbd:`Ctrl + Left Arrow`  | :kbd:`Cmd + Left Arrow`  | ``animation_editor/goto_prev_step``                 |
 +----------------------+---------------------------+--------------------------+-----------------------------------------------------+
 
-Tile Map Editor
----------------
+TileMap editor
+--------------
 
 +-------------------+-----------------+-------------------+---------------------------------------+
 | Action name       | Windows, Linux  | macOS             | Editor setting                        |
@@ -494,7 +523,7 @@ Tile Map Editor
 | Rotate Right      | :kbd:`X`        | :kbd:`X`          | ``tiles_editor/rotate_tile_right``    |
 +-------------------+-----------------+-------------------+---------------------------------------+
 
-Tileset Editor
+TileSet Editor
 --------------
 
 +---------------------+----------------+---------------+----------------------------------------+
@@ -520,3 +549,24 @@ Tileset Editor
 +---------------------+----------------+---------------+----------------------------------------+
 | Z Index Mode        | :kbd:`8`       | :kbd:`8`      | ``tileset_editor/editmode_z_index``    |
 +---------------------+----------------+---------------+----------------------------------------+
+
+Project manager
+---------------
+
++---------------------+-----------------+-------------------+------------------------------------+
+| Action name         | Windows, Linux  | macOS             | Editor setting                     |
++=====================+=================+===================+====================================+
+| New Project         | :kbd:`Ctrl + N` | :kbd:`Cmd + N`    | ``project_manager/new_project``    |
++---------------------+-----------------+-------------------+------------------------------------+
+| Import Project      | :kbd:`Ctrl + I` | :kbd:`Cmd + I`    | ``project_manager/import_project`` |
++---------------------+-----------------+-------------------+------------------------------------+
+| Scan for Projects   | :kbd:`Ctrl + S` | :kbd:`Cmd + S`    | ``project_manager/scan_projects``  |
++---------------------+-----------------+-------------------+------------------------------------+
+| Edit Project        | :kbd:`Ctrl + E` | :kbd:`Cmd + E`    | ``project_manager/edit_project``   |
++---------------------+-----------------+-------------------+------------------------------------+
+| Run Project         | :kbd:`Ctrl + R` | :kbd:`Cmd + R`    | ``project_manager/run_project``    |
++---------------------+-----------------+-------------------+------------------------------------+
+| Rename Project      | :kbd:`F2`       | :kbd:`Enter`      | ``project_manager/rename_project`` |
++---------------------+-----------------+-------------------+------------------------------------+
+| Remove Project      | :kbd:`Delete`   | :kbd:`Cmd + BkSp` | ``project_manager/remove_project`` |
++---------------------+-----------------+-------------------+------------------------------------+

tutorials/editor/project_manager.rst

@@ -33,10 +33,11 @@ Creating and importing projects
 To create a new project:
 
 1. Click the **Create** button on the top-left of the window.
-2. Give the project a name, choose an empty folder on your computer to save the
-   files. Alternatively, you can enable **Create Folder** option to automatically create 
-   a new sub-folder with the project name, following the directory naming convention
-   set in the settings. An empty folder will show a green tick on the right.
+2. Give the project a name, then open the file browser using the **Browse** button,
+   and choose an empty folder on your computer to save the files. Alternatively,
+   you can enable **Create Folder** option to automatically create a new sub-folder
+   with the project name, following the directory naming convention set in the
+   settings. An empty folder will show a green tick on the right.
 3. Select one of the rendering backends (this can also be changed later).
 4. Click the **Create & Edit** button to create the project folder and open it in the editor.
 
@@ -49,8 +50,9 @@ To create a new project:
 Using the file browser
 ~~~~~~~~~~~~~~~~~~~~~~
 
-Click the **Browse** button to open Godot's file browser.
-You can pick a location or type the folder's path in the **Path** field, after choosing a drive.
+From the **Create New Project** window, click the **Browse** button to open
+Godot's file browser. You can pick a location or type the folder's path in the
+**Path** field, after choosing a drive.
 
 Left of the path field on the top row contains arrows to navigate backward and forward through the last
 visited locations.

tutorials/editor/using_the_web_editor.rst

@@ -5,8 +5,8 @@
 Using the Web editor
 ====================
 
-Since Godot 3.3, there is a `Web editor <https://editor.godotengine.org/>`__
-you can use to work on new or existing projects.
+There is a `Web editor <https://editor.godotengine.org/>`__ you can use to work
+on new or existing projects.
 
 .. note::
 
@@ -69,7 +69,8 @@ of the Web platform:
 .. seealso::
 
     See the
-    `list of open issues on GitHub related to the web editor <https://github.com/godotengine/godot/issues?q=is%3Aopen+is%3Aissue+label%3Aplatform%3Ahtml5+label%3Atopic%3Aeditor>`__ for a list of known bugs.
+    `list of open issues on GitHub related to the web editor <https://github.com/godotengine/godot/issues?q=is%3Aopen+is%3Aissue+label%3Aplatform%3Aweb+label%3Atopic%3Aeditor>`__
+    for a list of known bugs.
 
 Importing a project
 -------------------

tutorials/export/exporting_for_android.rst

@@ -100,6 +100,9 @@ There are two types of icons required by Godot:
 
 - **Main Icon:** The "classic" icon. This will be used on all Android versions up to Android 8 (Oreo), exclusive. Must be at least 192×192 px.
 - **Adaptive Icons:** Starting from Android 8 (inclusive), `Adaptive Icons <https://developer.android.com/guide/practices/ui_guidelines/icon_design_adaptive>`_ were introduced. Applications will need to include separate background and foreground icons to have a native look. The user's launcher application will control the icon's animation and masking. Must be at least 432×432 px.
+- **Themed Icons:** Starting from Android 13 (inclusive), Themed Icons were introduced. Applications will need to include a monochrome icon to enable this feature. The user's launcher application will control the icon's theme. Must be at least 432×432 px.
+
+.. caution:: It is mandatory to provide a monochrome icon. Failure to do so will result in the default Godot monochrome icon being used.
 
 .. seealso:: It's important to adhere to some rules when designing adaptive icons. `Google Design has provided a nice article <https://medium.com/google-design/designing-adaptive-icons-515af294c783>`_ that helps to understand those rules and some of the capabilities of adaptive icons.
 
@@ -110,6 +113,7 @@ If you don't provide some of the requested icons, Godot will replace them using
 - **Main Icon:** Provided main icon -> Project icon -> Default Godot main icon.
 - **Adaptive Icon Foreground:** Provided foreground icon -> Provided main icon -> Project icon -> Default Godot foreground icon.
 - **Adaptive Icon Background:** Provided background icon -> Default Godot background icon.
+- **Adaptive Icon Monochrome:** Provided monochrome icon -> Default Godot monochrome icon.
 
 It's highly recommended to provide all the requested icons with their specified resolutions.
 This way, your application will look great on all Android devices and versions.

tutorials/export/exporting_for_web.rst

@@ -11,8 +11,7 @@ Exporting for the Web
 
 HTML5 export allows publishing games made in Godot Engine to the browser.
 This requires support for `WebAssembly
-<https://webassembly.org/>`__, `WebGL <https://www.khronos.org/webgl/>`__ and
-`SharedArrayBuffer <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer>`_
+<https://webassembly.org/>`__ and `WebGL 2.0 <https://www.khronos.org/webgl/>`__
 in the user's browser.
 
 .. attention::
@@ -26,28 +25,61 @@ in the user's browser.
     with :kbd:`F12` (:kbd:`Cmd + Option + I` on macOS), to view
     **debug information** like JavaScript, engine, and WebGL errors.
 
-.. attention::
+.. seealso::
+
+    See the
+    `list of open issues on GitHub related to the web export <https://github.com/godotengine/godot/issues?q=is%3Aopen+is%3Aissue+label%3Aplatform%3Aweb>`__
+    for a list of known bugs.
+
+Export file name
+----------------
 
-    Godot 4's HTML5 exports currently cannot run on macOS and iOS due to upstream bugs
-    with SharedArrayBuffer and WebGL 2.0. We recommend using
-    :ref:`macOS <doc_exporting_for_macos>` and :ref:`iOS <doc_exporting_for_ios>`
-    native export functionality instead, as it will also result in better performance.
+We suggest users to export their Web projects with ``index.html`` as the file name.
+``index.html`` is usually the default file loaded by web servers when accessing the
+parent directory, usually hiding the name of that file.
 
-    Godot 3's HTML5 exports are more compatible with various browsers in
-    general, especially when using the GLES2 rendering backend (which only
-    requires WebGL 1.0).
+.. attention::
+
+    The Godot 4 Web export expects some files to be named the same name as the one set in the
+    initial export. Some issues could occur if some exported files are renamed, including the
+    main HTML file.
 
 WebGL version
 -------------
 
 Godot 4.0 and later can only target WebGL 2.0 (using the Compatibility rendering
-method). There is no stable way to run Vulkan applications on the web yet.
+method). Forward+/Mobile are not supported on the web platform, as these
+rendering methods are designed around modern low-level graphics APIs. Godot
+currently does not support WebGPU, which is a prerequisite for allowing
+Forward+/Mobile to run on the web platform.
 
 See `Can I use WebGL 2.0 <https://caniuse.com/webgl2>`__ for a list of browser
 versions supporting WebGL 2.0. Note that Safari has several issues with WebGL
 2.0 support that other browsers don't have, so we recommend using a
 Chromium-based browser or Firefox if possible.
 
+.. _doc_exporting_for_web_audio_playback:
+
+Audio playback
+--------------
+
+Since Godot 4.3, audio playback is done using the Web Audio API on the web
+platform. This **Sample** playback mode allows for low latency even when the
+project is exported without thread support, but it has several limitations:
+
+- AudioEffects are not supported.
+- :ref:`Reverberation and doppler <doc_audio_streams_reverb_buses>` effects are not supported.
+- Procedural audio generation is not supported.
+- Positional audio may not always work correctly depending on the node's properties.
+
+To use Godot's own audio playback system on the web platform, you can change the
+default playback mode using the **Audio > General > Default Playback Type.web**
+project setting, or change the **Playback Type** property to **Stream** on an
+:ref:`class_AudioStreamPlayer`, :ref:`class_AudioStreamPlayer2D` or
+:ref:`class_AudioStreamPlayer3D` node. This leads to increased latency
+(especially when thread support is disabled), but it allows the full suite
+of Godot's audio features to work.
+
 .. _doc_javascript_export_options:
 
 Export options
@@ -60,7 +92,7 @@ game in the default browser for testing.
 If your project uses GDExtension **Extension Support** needs to be enabled.
 
 If you plan to use :ref:`VRAM compression <doc_importing_images>` make sure that
-**Vram Texture Compression** is enabled for the targeted platforms (enabling
+**VRAM Texture Compression** is enabled for the targeted platforms (enabling
 both **For Desktop** and **For Mobile** will result in a bigger, but more
 compatible export).
 
@@ -78,6 +110,59 @@ JavaScript APIs, include CSS, or run JavaScript code.
                To customize the generated file, use the **Custom HTML shell**
                option.
 
+.. _doc_exporting_for_web_thread_extension_support:
+
+Thread and extension support
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If **Thread Support** is enabled, the exported project will be able to
+:ref:`make use of multithreading <doc_using_multiple_threads>` to improve
+performance. This also allows for low-latency audio playback
+when the playback type is set to **Stream** (instead of the default **Sample**
+that is used in web exports). Enabling this feature requires the use of
+cross-origin isolation headers, which are described in the
+:ref:`doc_exporting_for_web_serving_the_files` section below.
+
+If **Extensions Support** is enabled, :ref:`GDExtensions <doc_what_is_gdextension>`
+will be able to be loaded. Note that GDExtensions still need to be specifically
+compiled for the web platform to work. Like thread support, enabling this feature
+requires the use of cross-origin isolation headers.
+
+Exporting as a Progressive Web App (PWA)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If **Progressive Web App > Enable** is enabled, it will have several effects:
+
+- Configure high-resolution icons, a display mode and screen orientation. These
+  are configured at the end of the Progressive Web App section in the export
+  options. These options are used if the user adds the project to their device's
+  homescreen, which is common on mobile platforms. This is also supported on
+  desktop platforms, albeit in a more limited capacity.
+
+- Allow the project to be loaded without an Internet connection if it has been
+  loaded at least once beforehand. This works thanks to the *service worker*
+  that is installed when the project is first loaded in the user's browser. This
+  service worker provides a local fallback when no Internet connection is
+  available.
+
+  - Note that web browsers can choose to evict the cached data if the user runs
+    low on disk space, or if the user hasn't opened the project for a while.
+    To ensure data is cached for a longer duration, the user can bookmark the page,
+    or ideally add it to their device's home screen.
+
+  - If the offline data is not available because it was evicted from the cache,
+    you can configure an **Offline Page** that will be displayed in this case.
+    The page must be in HTML format and will be saved on the client's machine
+    the first time the project is loaded.
+
+- Ensure cross-origin isolation headers are always present, even if the web
+  server hasn't been configured to send them. This allows exports with threads
+  enabled to work when hosted on any website, even if there is no way for you to
+  control the headers it sends.
+
+  - This behavior can be disabled by unchecking **Enable Cross Origin Isolation Headers**
+    in the Progressive Web App section.
+
 Limitations
 -----------
 
@@ -141,7 +226,7 @@ player to click, tap or press a key/button to enable audio, for instance when di
 .. seealso:: Google offers additional information about their `Web Audio autoplay
              policies <https://sites.google.com/a/chromium.org/dev/audio-video/autoplay>`__.
 
-             Apple's Safari team also posted additional information about their `Auto-Play Policy Changes for macOS 
+             Apple's Safari team also posted additional information about their `Auto-Play Policy Changes for macOS
              <https://webkit.org/blog/7734/auto-play-policy-changes-for-macos/>`__.
 
 .. warning:: Access to microphone requires a
@@ -205,8 +290,8 @@ used, see :ref:`doc_customizing_html5_shell`.
 
 .. warning::
 
-    To ensure low audio latency and the ability to use :ref:`class_Thread` in web exports,
-    Godot 4 web exports always use
+    If either :ref:`thread support or extension support <doc_exporting_for_web_thread_extension_support>`
+    are enabled, the exported project will require
     `SharedArrayBuffer <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer>`__.
     This requires a :ref:`secure context <doc_javascript_secure_contexts>`,
     while also requiring the following CORS headers to be set when serving the files:
@@ -217,11 +302,13 @@ used, see :ref:`doc_customizing_html5_shell`.
         Cross-Origin-Embedder-Policy: require-corp
 
     If you don't control the web server or are unable to add response headers,
-    use `coi-serviceworker <https://github.com/gzuidhof/coi-serviceworker>`__
-    as a workaround.
+    check **Progressive Web App > Enable** in the export options. This applies
+    a service worker-based workaround that allows the project to run by
+    simulating the presence of these response headers. A secure context
+    is still required in this case.
 
-    If the client doesn't receive the required response headers,
-    **the project will not run**.
+    If the client doesn't receive the required response headers or the service
+    worker-based workaround is not applied, **the project will not run**.
 
 The generated ``.html`` file can be used as ``DirectoryIndex`` in Apache
 servers and can be renamed to e.g. ``index.html`` at any time. Its name is
@@ -289,7 +376,8 @@ supported on your web server for further file size savings.
 Interacting with the browser and JavaScript
 -------------------------------------------
 
-See the :ref:`dedicated page <doc_web_javascript_bridge>` on how to interact with JavaScript and access some unique Web browser features.
+See the :ref:`dedicated page <doc_web_javascript_bridge>` on how to interact
+with JavaScript and access some unique Web browser features.
 
 Environment variables
 ---------------------

tutorials/export/exporting_for_windows.rst

@@ -24,7 +24,7 @@ Code signing
 Godot is capable of automatic code signing on export. To do this you must have the
 ``Windows SDK`` (on Windows) or `osslsigncode <https://github.com/mtrojnar/osslsigncode>`__
 (on any other OS) installed. You will also need a package signing certificate,
-information on creating one can be found `here <https://docs.microsoft.com/en-us/windows/win32/appxpkg/how-to-create-a-package-signing-certificate?redirectedfrom=MSDN>`__.
+information on creating one can be found `here <https://learn.microsoft.com/en-us/windows/msix/package/create-certificate-package-signing>`__.
 
 .. warning::
 

tutorials/inputs/controllers_gamepads_joysticks.rst

@@ -136,10 +136,6 @@ use ``Input.is_action_pressed()``:
     held, ``Input.is_action_just_pressed()`` will only return ``true`` for one
     frame after the button has been pressed.
 
-In Godot versions before 3.4, such as 3.3, ``Input.get_vector()`` and
-``Input.get_axis()`` aren't available. Only ``Input.get_action_strength()``
-and ``Input.is_action_pressed()`` are available in Godot 3.3.
-
 Vibration
 ---------
 

tutorials/inputs/custom_mouse_cursor.rst

@@ -7,17 +7,14 @@ You might want to change the appearance of the mouse cursor in your game in
 order to suit the overall design. There are two ways to customize the mouse
 cursor:
 
-1. Using project settings
-2. Using a script
-
-Using project settings is a simpler (but more limited) way to customize the mouse cursor.
-The second way is more customizable, but involves scripting:
+1. Using project settings. This is simpler, but more limited.
+2. Using a script. This is more customizable, but involves scripting.
 
 .. note::
 
     You could display a "software" mouse cursor by hiding the mouse cursor and
     moving a Sprite2D to the cursor position in a ``_process()`` method, but
-    this will add at least one frame of latency compared to an "hardware" mouse
+    this will add at least one frame of latency compared to a "hardware" mouse
     cursor. Therefore, it's recommended to use the approach described here
     whenever possible.
 
@@ -27,18 +24,20 @@ The second way is more customizable, but involves scripting:
 Using project settings
 ----------------------
 
-Open project settings, go to Display>Mouse Cursor. You will see Custom Image, Custom Image Hotspot
-and Tooltip Position Offset.
+Open the **Project Settings** and go to **Display > Mouse Cursor**. You will see the settings
+:ref:`Custom Image <class_ProjectSettings_property_display/mouse_cursor/custom_image>`,
+:ref:`Custom Image Hotspot <class_ProjectSettings_property_display/mouse_cursor/custom_image_hotspot>`,
+and :ref:`Tooltip Position Offset <class_ProjectSettings_property_display/mouse_cursor/tooltip_position_offset>`.
 
 .. image:: img/cursor_project_settings.webp
 
-Custom Image is the desired image that you would like to set as the mouse cursor.
-Custom Hotspot is the point in the image that you would like to use as the cursor's detection point.
+**Custom Image** is the desired image that you would like to set as the mouse cursor.
+**Custom Hotspot** is the point in the image that you would like to use as the cursor's detection point.
 
 .. warning::
 
     The custom image **must** be 256×256 pixels at most. To avoid rendering
-    issues, sizes lower than or equal to 128×128 are recommended.
+    issues, sizes of 128×128 or smaller are recommended.
 
     On the web platform, the maximum allowed cursor image size is 128×128.
 
@@ -68,18 +67,23 @@ Create a Node and attach the following script.
 
  .. code-tab:: csharp
 
-    public override void _Ready()
-    {
-        // Load the custom images for the mouse cursor.
-        var arrow = ResourceLoader.Load("res://arrow.png");
-        var beam = ResourceLoader.Load("res://beam.png");
-
-        // Changes only the arrow shape of the cursor.
-        // This is similar to changing it in the project settings.
-        Input.SetCustomMouseCursor(arrow);
+    using Godot;
 
-        // Changes a specific shape of the cursor (here, the I-beam shape).
-        Input.SetCustomMouseCursor(beam, Input.CursorShape.Ibeam);
+    public partial class MyNode : Node
+    {
+        public override void _Ready()
+        {
+            // Load the custom images for the mouse cursor.
+            var arrow = ResourceLoader.Load("res://arrow.png");
+            var beam = ResourceLoader.Load("res://beam.png");
+
+            // Changes only the arrow shape of the cursor.
+            // This is similar to changing it in the project settings.
+            Input.SetCustomMouseCursor(arrow);
+
+            // Changes a specific shape of the cursor (here, the I-beam shape).
+            Input.SetCustomMouseCursor(beam, Input.CursorShape.Ibeam);
+        }
     }
 
 .. seealso::
@@ -90,6 +94,6 @@ Create a Node and attach the following script.
 Cursor list
 -----------
 
-As documented in the :ref:`Input <class_Input>` class (see the **CursorShape**
-enum), there are multiple mouse cursors you can define. Which ones you want to
-use depends on your use case.
+There are multiple mouse cursors you can define, documented in the 
+:ref:`Input.CursorShape <enum_Input_CursorShape>` enum. Which ones you want to use
+depends on your use case.

tutorials/inputs/inputevent.rst

@@ -194,10 +194,10 @@ There are several specialized types of InputEvent, described in the table below:
 |                                                                   | as feedback. (more on this below)       |
 +-------------------------------------------------------------------+-----------------------------------------+
 
-Actions
--------
+Input actions
+-------------
 
-Actions are a grouping of zero or more InputEvents into a commonly
+Input actions are a grouping of zero or more InputEvents into a commonly
 understood title (for example, the default "ui_left" action grouping both joypad-left input and a keyboard's left arrow key). They are not required to represent an
 InputEvent but are useful because they abstract various inputs when
 programming the game logic.
@@ -239,6 +239,12 @@ The Input singleton has a method for this:
     // Feedback.
     Input.ParseInputEvent(ev);
 
+
+.. seealso::
+
+   See :ref:`doc_first_3d_game_input_actions` for a tutorial on adding input
+   actions in the project settings.
+
 InputMap
 --------
 

tutorials/math/random_number_generation.rst

@@ -33,9 +33,6 @@ Global scope methods are easier to set up, but they don't offer as much control.
 RandomNumberGenerator requires more code to use, but allows creating
 multiple instances, each with their own seed and state.
 
-This tutorial uses global scope methods, except when the method only exists in
-the RandomNumberGenerator class.
-
 The randomize() method
 ----------------------
 
@@ -134,7 +131,7 @@ number between 0 and 1. This is useful to implement a
 :ref:`doc_random_number_generation_weighted_random_probability` system, among
 other things.
 
-:ref:`randfn() <class_RandomNumberGenerator_method_randfn>` returns a random
+:ref:`randfn() <class_@GlobalScope_method_randfn>` returns a random
 floating-point number following a `normal distribution
 <https://en.wikipedia.org/wiki/Normal_distribution>`__. This means the returned
 value is more likely to be around the mean (0.0 by default),
@@ -144,16 +141,12 @@ varying by the deviation (1.0 by default):
  .. code-tab:: gdscript GDScript
 
     # Prints a random floating-point number from a normal distribution with a mean 0.0 and deviation 1.0.
-    var random = RandomNumberGenerator.new()
-    random.randomize()
-    print(random.randfn())
+    print(randfn())
 
  .. code-tab:: csharp
 
     // Prints a normally distributed floating-point number between 0.0 and 1.0.
-    var random = new RandomNumberGenerator();
-    random.Randomize();
-    GD.Print(random.Randfn());
+    GD.Print(GD.Randfn());
 
 :ref:`randf_range() <class_@GlobalScope_method_randf_range>` takes two arguments
 ``from`` and ``to``, and returns a random floating-point number between ``from``
@@ -165,28 +158,31 @@ and ``to``:
     # Prints a random floating-point number between -4 and 6.5.
     print(randf_range(-4, 6.5))
 
-:ref:`RandomNumberGenerator.randi_range()
-<class_RandomNumberGenerator_method_randi_range>` takes two arguments ``from``
+ .. code-tab:: csharp
+
+    // Prints a random floating-point number between -4 and 6.5.
+    GD.Print(GD.RandfRange(-4, 6.5));
+
+:ref:`randi_range() <class_@GlobalScope_method_randi_range>` takes two arguments ``from``
 and ``to``, and returns a random integer between ``from`` and ``to``:
 
 .. tabs::
  .. code-tab:: gdscript GDScript
 
     # Prints a random integer between -10 and 10.
-    var random = RandomNumberGenerator.new()
-    random.randomize()
-    print(random.randi_range(-10, 10))
+    print(randi_range(-10, 10))
 
  .. code-tab:: csharp
 
     // Prints a random integer number between -10 and 10.
-    random.Randomize();
-    GD.Print(random.RandiRange(-10, 10));
+    GD.Print(GD.RandiRange(-10, 10));
 
 Get a random array element
 --------------------------
 
-We can use random integer generation to get a random element from an array:
+We can use random integer generation to get a random element from an array,
+or use the :ref:`Array.pick_random<class_Array_method_pick_random>` method
+to do it for us:
 
 .. tabs::
  .. code-tab:: gdscript GDScript
@@ -194,12 +190,14 @@ We can use random integer generation to get a random element from an array:
     var _fruits = ["apple", "orange", "pear", "banana"]
 
     func _ready():
-        randomize()
-
         for i in range(100):
             # Pick 100 fruits randomly.
             print(get_fruit())
 
+        for i in range(100):
+            # Pick 100 fruits randomly, this time using the `Array.pick_random()`
+            # helper method. This has the same behavior as `get_fruit()`.
+            print(_fruits.pick_random())
 
     func get_fruit():
         var random_fruit = _fruits[randi() % _fruits.size()]
@@ -209,29 +207,37 @@ We can use random integer generation to get a random element from an array:
 
  .. code-tab:: csharp
 
-    private string[] _fruits = { "apple", "orange", "pear", "banana" };
+    // Use Godot's Array type instead of a BCL type so we can use `PickRandom()` on it.
+    private Godot.Collections.Array<string> _fruits = new Godot.Collections.Array<string> { "apple", "orange", "pear", "banana" };
 
     public override void _Ready()
     {
-        GD.Randomize();
-
         for (int i = 0; i < 100; i++)
         {
             // Pick 100 fruits randomly.
             GD.Print(GetFruit());
         }
+
+        for (int i = 0; i < 100; i++)
+        {
+            // Pick 100 fruits randomly, this time using the `Array.PickRandom()`
+            // helper method. This has the same behavior as `GetFruit()`.
+            GD.Print(_fruits.PickRandom());
+        }
     }
 
     public string GetFruit()
     {
-        string randomFruit = _fruits[GD.Randi() % _fruits.Length];
+        string randomFruit = _fruits[GD.Randi() % _fruits.Size()];
         // Returns "apple", "orange", "pear", or "banana" every time the code runs.
         // We may get the same fruit multiple times in a row.
         return randomFruit;
     }
 
 To prevent the same fruit from being picked more than once in a row, we can add
-more logic to this method:
+more logic to the above method. In this case, we can't use
+:ref:`Array.pick_random<class_Array_method_pick_random>` since it lacks a way to
+prevent repetition:
 
 .. tabs::
  .. code-tab:: gdscript GDScript
@@ -241,8 +247,6 @@ more logic to this method:
 
 
     func _ready():
-        randomize()
-
         # Pick 100 fruits randomly.
         for i in range(100):
             print(get_fruit())
@@ -270,8 +274,6 @@ more logic to this method:
 
     public override void _Ready()
     {
-        GD.Randomize();
-
         for (int i = 0; i < 100; i++)
         {
             // Pick 100 fruits randomly.
@@ -316,8 +318,6 @@ We can apply similar logic from arrays to dictionaries as well:
 
 
     func _ready():
-        randomize()
-
         for i in range(20):
             print(get_metal())
 
@@ -341,8 +341,6 @@ floating-point number between 0.0 and 1.0. We can use this to create a
  .. code-tab:: gdscript GDScript
 
     func _ready():
-        randomize()
-
         for i in range(100):
             print(get_item_rarity())
 
@@ -364,8 +362,6 @@ floating-point number between 0.0 and 1.0. We can use this to create a
 
     public override void _Ready()
     {
-        GD.Randomize();
-
         for (int i = 0; i < 100; i++)
         {
             GD.Print(GetItemRarity());
@@ -413,7 +409,6 @@ ends up empty. When that happens, you reinitialize it to its default value::
 
 
     func _ready():
-        randomize()
         _fruits_full = _fruits.duplicate()
         _fruits.shuffle()
 
@@ -456,7 +451,6 @@ terrain. Godot provides :ref:`class_fastnoiselite` for this, which supports
     var _noise = FastNoiseLite.new()
 
     func _ready():
-        randomize()
         # Configure the FastNoiseLite instance.
         _noise.noise_type = FastNoiseLite.NoiseType.TYPE_SIMPLEX_SMOOTH
         _noise.seed = randi()
@@ -474,7 +468,6 @@ terrain. Godot provides :ref:`class_fastnoiselite` for this, which supports
 
     public override void _Ready()
     {
-        GD.Randomize();
         // Configure the FastNoiseLite instance.
         _noise.NoiseType = NoiseTypeEnum.SimplexSmooth;
         _noise.Seed = (int)GD.Randi();

tutorials/migrating/upgrading_to_godot_4.rst

@@ -71,9 +71,10 @@ in future Godot releases:
   manually change it to GodotPhysics. There are no plans to re-add Bullet physics
   in core, but a third-party add-on could be created for it thanks to
   GDExtension.
-- Rendering in 2D is no longer performed in HDR, which means "overbright"
-  modulate values have no visible effect. This is planned to be restored at some
-  point in the future.
+- By default, rendering in 2D is no longer performed in HDR, which means
+  "overbright" modulate values have no visible effect. Since Godot 4.2, you can
+  enable the project setting :ref:`HDR 2D<class_ProjectSettings_property_rendering/viewport/hdr_2d>`
+  to perform 2D rendering in HDR. See also :ref:`doc_environment_and_post_processing_using_glow_in_2d`.
 - While rendering still happens in HDR in 3D when using the Forward Plus or
   Forward Mobile backends, Viewports cannot return HDR data anymore. This is
   planned to be restored at some point in the future.
@@ -509,13 +510,15 @@ environment effect and its visual knobs remain within the Environment resource.
 Updating shaders
 ^^^^^^^^^^^^^^^^
 
-There have been some changes to shaders that aren't covered by the upgrade tool.
+There have been some changes to shaders that aren't covered by the upgrade tool. 
+You will need to make some manual changes, especially if your shader uses coordinate
+space transformations or a custom ``light()`` function.
 
 The ``.shader`` file extension is no longer supported, which means you must
 rename ``.shader`` files to ``.gdshader`` and update references accordingly in
 scene/resource files using an external text editor.
 
-Some notable renames you will need to perform in shaders are:
+Some notable changes you will need to perform in shaders are:
 
 - Texture filter and repeat modes are now set on individual uniforms, rather
   than the texture files themselves.
@@ -524,9 +527,22 @@ Some notable renames you will need to perform in shaders are:
 - :ref:`Built in matrix variables were renamed. <doc_spatial_shader>`
 - Particles shaders no longer use the ``vertex()`` processor function. Instead
   they use ``start()`` and ``process()``.
+- In the Forward+ and Mobile renderers, normalized device coordinates now have a Z-range of ``[0.0,1.0]``
+  instead of ``[-1.0,1.0]``. When reconstructing NDC from ``SCREEN_UV`` and depth, use 
+  ``vec3 ndc = vec3(SCREEN_UV * 2.0 - 1.0, depth);`` instead of 
+  ``vec3 ndc = vec3(SCREEN_UV, depth) * 2.0 - 1.0;``. The Compatibility renderer is unchanged,
+  using the same NDC Z-range as 3.x.
+- The lighting model changed. If your shader has a custom ``light()`` function,
+  you may need to make changes to get the same visual result.
+- In 4.3 and up, the reverse Z depth buffer technique is now implemented, which 
+  may break advanced shaders. See 
+  `Introducing Reverse Z (AKA I'm sorry for breaking your shader) <https://godotengine.org/article/introducing-reverse-z/>`__.
 
 See :ref:`doc_shading_language` for more information.
 
+This list is not exhaustive. If you made all the changes mentioned here and your 
+shader still doesn't work, try asking for help in one of the `community channels <https://godotengine.org/community/>`__.
+
 Updating scripts to take backwards-incompatible changes into account
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

tutorials/platform/consoles.rst

@@ -82,6 +82,7 @@ Following is the list of providers:
 - `Seaven Studio <https://www.seaven-studio.com/>`_ offers
   Switch, Xbox One, Xbox Series, PlayStation 4 & PlayStation 5 porting of Godot games.
 - `Sickhead Games <https://www.sickhead.com>`_ offers console porting to Nintendo Switch, PlayStation 4, PlayStation 5, Xbox One, and Xbox Series X/S for Godot games.
+- `W4 Games <https://www.w4games.com/>`_ offers console ports for Nintendo Switch, Xbox Series X/S, and Playstation 5 for you to port your game yourself.
 
 If your company offers porting, or porting *and* publishing services for Godot games,
 feel free to

tutorials/platform/web/javascript_bridge.rst

@@ -1,6 +1,6 @@
 .. _doc_web_javascript_bridge:
 
-The JavaScriptBridge Singleton
+The JavaScriptBridge singleton
 ==============================
 
 In web builds, the :ref:`JavaScriptBridge <class_JavaScriptBridge>` singleton
@@ -93,6 +93,12 @@ Arguments passed by JavaScript to the callback will be passed as a single Godot
         js_event.preventDefault()
         js_event.returnValue = ''
 
+.. warning::
+
+    The number of arguments accepted by the callback method (``_my_callback`` in the above example)
+    **must** match the number of arguments sent by JavaScript. Otherwise, the callback method will
+    not be called.
+
 Here is another example that asks the user for the `Notification permission <https://developer.mozilla.org/en-US/docs/Web/API/Notifications_API>`__
 and waits asynchronously to deliver a notification if the permission is
 granted:

tutorials/plugins/editor/making_plugins.rst

@@ -450,12 +450,12 @@ Use the following code to register a singleton from an editor plugin:
     const AUTOLOAD_NAME = "SomeAutoload"
 
 
-    func _enter_tree():
+    func _enable_plugin():
         # The autoload can be a scene or script file.
         add_autoload_singleton(AUTOLOAD_NAME, "res://addons/my_addon/some_autoload.tscn")
 
 
-    func _exit_tree():
+    func _disable_plugin():
         remove_autoload_singleton(AUTOLOAD_NAME)
 
  .. code-tab:: csharp
@@ -469,13 +469,13 @@ Use the following code to register a singleton from an editor plugin:
         // Replace this value with a PascalCase autoload name.
         private const string AutoloadName = "SomeAutoload";
 
-        public override void _EnterTree()
+        public override void _EnablePlugin()
         {
             // The autoload can be a scene or script file.
             AddAutoloadSingleton(AutoloadName, "res://addons/MyAddon/SomeAutoload.tscn");
         }
 
-        public override void _ExitTree()
+        public override void _DisablePlugin()
         {
             RemoveAutoloadSingleton(AutoloadName);
         }

tutorials/rendering/index.rst

@@ -3,6 +3,11 @@
 Rendering
 =========
 
+.. seealso::
+
+   Most rendering topics are covered in :ref:`2D rendering <doc_2d_rendering>`
+   and :ref:`3D rendering <doc_3d_rendering>`.
+
 .. toctree::
    :maxdepth: 1
    :name: toc-learn-features-rendering

tutorials/scripting/c_sharp/c_sharp_exports.rst

@@ -108,7 +108,7 @@ Properties with a backing field use the default value of the backing field.
     node with an attached tool script, ``_number`` will be ``2``, and
     ``NumberWithBackingField`` will return ``5``. This difference may cause
     confusing behavior. To avoid this, don't use complex properties. Alternatively,
-    if the default value can be explicitly specified, it can be overridden with the 
+    if the default value can be explicitly specified, it can be overridden with the
     :ref:`_PropertyCanRevert() <class_Object_private_method__property_can_revert>` and
     :ref:`_PropertyGetRevert() <class_Object_private_method__property_get_revert>` methods.
 
@@ -259,14 +259,30 @@ the slider.
 Floats with easing hint
 -----------------------
 
-Display a visual representation of the 'ease()' function
-when editing.
+Display a visual representation of the :ref:`ease<class_@GlobalScope_method_ease>`
+function when editing.
 
 .. code-block:: csharp
 
     [Export(PropertyHint.ExpEasing)]
     public float TransitionSpeed { get; set; }
 
+Export with suffix hint
+-----------------------
+
+Display a unit hint suffix for exported variables. Works with numeric types,
+such as floats or vectors:
+
+.. code-block:: csharp
+
+    [Export(PropertyHint.None, "suffix:m/s\u00b2")]
+    public float Gravity { get; set; } = 9.8f;
+    [Export(PropertyHint.None, "suffix:m/s")]
+    public Vector3 Velocity { get; set; }
+
+In the above example, ``\u00b2`` is used to write the "squared" character
+(``²``).
+
 Colors
 ------
 
@@ -363,7 +379,7 @@ combine multiple flags using logical OR (``|``) are also possible.
 .. code-block:: csharp
 
     [Flags]
-    public enum MyEnum
+    public enum SpellElements
     {
         Fire = 1 << 1,
         Water = 1 << 2,
@@ -450,7 +466,7 @@ of the selected option (i.e. ``0``, ``1``, or ``2``).
 .. code-block:: csharp
 
     [Export(PropertyHint.Enum, "Warrior,Magician,Thief")]
-    public int CharacterClass { get; set; };
+    public int CharacterClass { get; set; }
 
 You can add explicit values using a colon:
 

tutorials/scripting/c_sharp/c_sharp_global_classes.rst

@@ -3,8 +3,11 @@
 C# global classes
 =================
 
-Global classes (also known as named scripts) are types registered in Godot's editor so they can be used
-more conveniently.
+Global classes (also known as named scripts) are types registered in Godot's
+editor so they can be used more conveniently.
+:ref:`In GDScript <doc_gdscript_basics_class_name>`, this is achieved
+using the ``class_name`` keyword at the top of a script. This page describes how
+to achieve the same effect in C#.
 
 - Global classes show up in the *Add Node* and *Create Resource* dialogs.
 - If an :ref:`exported property <doc_c_sharp_exports>` is a global class, the
@@ -22,6 +25,12 @@ Global classes are registered with the ``[GlobalClass]`` attribute.
     {
     }
 
+.. warning::
+
+    The file name must match the class name in **case-sensitive** fashion.
+    For example, a global class named "MyNode" must have a file name of
+    ``MyNode.cs``, not ``myNode.cs``.
+
 The ``MyNode`` type will be registered as a global class with the same name as the type's name.
 
 .. image:: img/globalclasses_addnode.webp
@@ -84,8 +93,7 @@ will let you create and load instances of this type easily.
 .. warning::
 
     The Godot editor will hide these custom classes with names that begin with the prefix
-    "Editor" in the 'Create New Node' or 'Create New Scene' dialog windows. The classes 
-    are available for instantiation at runtime via their class names, but are 
-    automatically hidden by the editor windows along with the built-in editor nodes used 
+    "Editor" in the "Create New Node" or "Create New Scene" dialog windows. The classes
+    are available for instantiation at runtime via their class names, but are
+    automatically hidden by the editor windows along with the built-in editor nodes used
     by the Godot editor.
-    

tutorials/scripting/c_sharp/diagnostics/index.rst

@@ -8,8 +8,8 @@ C# diagnostics
 Godot includes analyzers that inspect your C# source code to check for invalid
 or unsupported code and let you know that something is wrong during build time.
 
-Rules
------
+.. rubric:: Rules
+   :heading-level: 2
 
 .. toctree::
    :maxdepth: 1

tutorials/scripting/debug/overview_of_debugging_tools.rst

@@ -232,8 +232,8 @@ broke on.
 Debug project settings
 ----------------------
 
-In the project settings, there is a **Debug** category with three subcategories
-which control different things.
+In the project settings, there is a **Debug** category with subcategories which
+control different things. Enable **Advanced Settings** to change these settings.
 
 Settings
 ++++++++
@@ -242,12 +242,29 @@ These are some general settings such as printing the current FPS
 to the **Output** panel, the maximum amount of functions when profiling
 and others.
 
+File Logging
+++++++++++++
+
+These settings allow you to log console output and error messages to files.
+
 GDScript
 ++++++++
 
 These settings allow you to toggle specific GDScript warnings, such as for
+unused variables. You can also turn off warnings completely. See 
+:ref:`doc_gdscript_warning_system` for more information.
+
+Shader Language
++++++++++++++++
+
+These settings allow you to toggle specific shader warnings, such as for
 unused variables. You can also turn off warnings completely.
 
+Canvas Items
+++++++++++++
+
+These settings are for canvas item redraw debugging.
+
 Shapes
 ++++++
 

tutorials/scripting/gdextension/gdextension_docs_system.rst

@@ -170,3 +170,31 @@ Currently they supported tags for the GDExtension documentation system are:
         ``#ff00ff``, see :ref:`doc_bbcode_in_richtextlabel_hex_colors`).
 
     - ``[color={code/name}]{text}[/color]``
+
+
+Publishing documentation online
+-------------------------------
+
+You may want to publish an online reference for your GDExtension, similar to this website.
+The most important step is to build reStructuredText (``.rst``) files from your XML class reference:
+
+.. code-block:: bash
+
+    # You need a version.py file, so download it first.
+    curl -sSLO https://raw.githubusercontent.com/godotengine/godot/refs/heads/master/version.py
+
+    # Edit version.py according to your project before proceeding.
+    # Then, run the rst generator. You'll need to have Python installed for this command to work.
+    curl -sSL https://raw.githubusercontent.com/godotengine/godot/master/doc/tools/make_rst.py | python3 - -o "docs/classes" -l "en" doc_classes
+
+Your ``.rst`` files will now be available in ``docs/classes/``. From here, you can use
+any documentation builder that supports reStructuredText syntax to create a website from them.
+
+`godot-docs <https://github.com/godotengine/godot-docs>`_ uses `Sphinx <https://www.sphinx-doc.org/en/master/>`_. You can use the repository as a basis to build your own documentation system. The following guide describes the basic steps, but they are not exhaustive: You will need a bit of personal insight to make it work.
+
+1. Add `godot-docs <https://github.com/godotengine/godot-docs>`_ as a submodule to your ``docs/`` folder.
+2. Copy over its ``conf.py``, ``index.rst``, ``.readthedocs.yaml`` files into ``/docs/``. You may later decide to copy over and edit more of godot-docs' files, like ``_templates/layout.html``.
+3. Modify these files according to your project. This mostly involves adjusting paths to point to the ``godot-docs`` subfolder, as well as strings to reflect it's your project rather than Godot you're building the docs for.
+4. Create an account on `readthedocs.org <http://readthedocs.org>`_. Import your project, and modify its base ``.readthedocs.yaml`` file path to ``/docs/.readthedocs.yaml``.
+
+Once you have completed all these steps, your documentation should be available at ``<repo-name>.readthedocs.io``.

tutorials/scripting/gdscript/gdscript_basics.rst

@@ -118,15 +118,8 @@ If you have previous experience with statically typed languages such as
 C, C++, or C# but never used a dynamically typed one before, it is advised you
 read this tutorial: :ref:`doc_gdscript_more_efficiently`.
 
-Language
---------
-
-In the following, an overview is given to GDScript. Details, such as which
-methods are available to arrays or other objects, should be looked up in
-the linked class descriptions.
-
 Identifiers
-~~~~~~~~~~~
+-----------
 
 Any string that restricts itself to alphabetic characters (``a`` to ``z`` and
 ``A`` to ``Z``), digits (``0`` to ``9``) and ``_`` qualifies as an identifier.
@@ -140,7 +133,7 @@ that are considered "confusable" for ASCII characters and emoji are not allowed
 in identifiers.
 
 Keywords
-~~~~~~~~
+--------
 
 The following is the list of keywords supported by the language. Since
 keywords are reserved words (tokens), they can't be used as identifiers.
@@ -226,7 +219,7 @@ in case you want to take a look under the hood.
 +------------+---------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Operators
-~~~~~~~~~
+---------
 
 The following is the list of supported operators and their precedence. All binary operators are `left-associative <https://en.wikipedia.org/wiki/Operator_associativity>`_,
 including the ``**`` operator. This means that ``2 ** 2 ** 3`` is equal to ``(2 ** 2) ** 3``. Use parentheses to explicitly specify precedence you need, for
@@ -338,7 +331,7 @@ example ``2 ** (2 ** 3)``. The ternary ``if/else`` operator is right-associative
        and :ref:`is_zero_approx() <class_@GlobalScope_method_is_zero_approx>` functions instead.
 
 Literals
-~~~~~~~~
+--------
 
 +---------------------------------+-------------------------------------------+
 | **Example(s)**                  | **Description**                           |
@@ -452,7 +445,7 @@ Thus, a string can have a quote that matches the opening one, but only if it's p
 GDScript also supports :ref:`format strings <doc_gdscript_printf>`.
 
 Annotations
-~~~~~~~~~~~
+-----------
 
 Annotations are special tokens in GDScript that act as modifiers to a script or
 its code and may affect how the script is treated by the Godot engine or
@@ -538,7 +531,7 @@ can replace the above code with a single line::
     as an error by default. We do not recommend disabling or ignoring it.
 
 Comments
-~~~~~~~~
+--------
 
 Anything from a ``#`` to the end of the line is ignored and is
 considered a comment.
@@ -573,7 +566,7 @@ considered a comment.
     Editor > Theme > Comment Markers** section of the Editor Settings.
 
 Code regions
-~~~~~~~~~~~~
+------------
 
 Code regions are special types of comments that the script editor understands as
 *foldable regions*. This means that after writing code region comments, you can
@@ -641,7 +634,7 @@ folding code regions.
     group multiple elements together.
 
 Line continuation
-~~~~~~~~~~~~~~~~~
+-----------------
 
 A line of code in GDScript can be continued on the next line by using a backslash
 (``\``). Add one at the end of a line and the code on the next line will act like
@@ -684,6 +677,11 @@ null
 ``null`` is an empty data type that contains no information and can not
 be assigned any other value.
 
+Only types that inherit from Object can have a ``null`` value
+(Object is therefore called a "nullable" type).
+:ref:`Variant types <doc_variant_class>` must have a valid value at all times,
+and therefore cannot have a ``null`` value.
+
 :ref:`bool <class_bool>`
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -970,11 +968,8 @@ will set the value of ``x`` to a callable with ``$Sprite2D`` as the object and
 
 You can call it using the ``call`` method: ``x.call(PI)``.
 
-Data
-----
-
 Variables
-~~~~~~~~~
+---------
 
 Variables can exist as class members or local to functions. They are
 created with the ``var`` keyword and may, optionally, be assigned a
@@ -1028,7 +1023,7 @@ Valid types are:
     the project settings. See :ref:`doc_gdscript_warning_system` for details.
 
 Initialization order
-^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~
 
 Member variables are initialized in the following order:
 
@@ -1074,7 +1069,7 @@ Member variables are initialized in the following order:
     or remove the empty dictionary assignment (``= {}``).
 
 Static variables
-^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~
 
 A class member variable can be declared static::
 
@@ -1178,7 +1173,7 @@ and must be placed at the top of the script, before ``class_name`` and ``extends
 See also `Static functions`_ and `Static constructor`_.
 
 Casting
-^^^^^^^
+~~~~~~~
 
 Values assigned to typed variables must have a compatible type. If it's needed to
 coerce a value to be of a certain type, in particular for object types, you can
@@ -1218,7 +1213,7 @@ the scene tree::
     ($AnimPlayer as AnimationPlayer).play("walk")
 
 Constants
-~~~~~~~~~
+---------
 
 Constants are values you cannot change when the game is running.
 Their value must be known at compile-time. Using the
@@ -1250,7 +1245,7 @@ You can also create constants inside a function, which is useful to name local
 magic values.
 
 Enums
-^^^^^
+~~~~~
 
 Enums are basically a shorthand for constants, and are pretty useful if you
 want to assign consecutive integers to some constant.
@@ -1293,9 +1288,12 @@ a dictionary can also be used with a named enum.
         # prints '[0, 5, 6]'
         print(State.values())
 
+If not assigning a value to a key of an enum it will be assigned the previous value plus one,
+or ``0`` if it is the first entry in the enum. Multiple keys with the same value are allowed.
+
 
 Functions
-~~~~~~~~~
+---------
 
 Functions always belong to a `class <Classes_>`_. The scope priority for
 variable look-up is: local → class member → global. The ``self`` variable is
@@ -1354,7 +1352,7 @@ return early with the ``return`` keyword, but they can't return any value.
           valid value to return.
 
 Referencing functions
-^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~
 
 Functions are first-class values in terms of the :ref:`Callable <class_Callable>` object.
 Referencing a function by name without calling it will automatically generate the proper
@@ -1383,7 +1381,7 @@ callable. This can be used to pass functions as arguments.
     performance issues on direct function calls.
 
 Lambda functions
-^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~
 
 Lambda functions allow you to declare functions that do not belong to a class. Instead, a
 :ref:`Callable <class_Callable>` object is created and assigned to a variable directly.
@@ -1456,7 +1454,7 @@ Lambda functions capture the local environment::
         print(a) # Prints `[1]`.
 
 Static functions
-^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~
 
 A function can be declared static. When a function is static, it has no access to the instance member variables or ``self``.
 A static function has access to static variables. Also static functions are useful to make libraries of helper functions::
@@ -1469,14 +1467,14 @@ Lambda functions cannot be declared static.
 See also `Static variables`_ and `Static constructor`_.
 
 Statements and control flow
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+---------------------------
 
 Statements are standard and can be assignments, function calls, control
 flow structures, etc (see below). ``;`` as a statement separator is
 entirely optional.
 
 Expressions
-^^^^^^^^^^^
+~~~~~~~~~~~
 
 Expressions are sequences of operators and their operands in orderly fashion. An expression by itself can be a
 statement too, though only calls are reasonable to use as statements since other expressions don't have side effects.
@@ -1504,7 +1502,7 @@ Identifiers, attributes, and subscripts are valid assignment targets. Other expr
 an assignment.
 
 if/else/elif
-^^^^^^^^^^^^
+~~~~~~~~~~~~
 
 Simple conditions are created by using the ``if``/``else``/``elif`` syntax.
 Parenthesis around conditions are allowed, but not required. Given the
@@ -1567,7 +1565,7 @@ use an ``if`` statement combined with the ``in`` operator to accomplish this::
     if "varName" in get_parent(): print("varName is defined in parent!")
 
 while
-^^^^^
+~~~~~
 
 Simple loops are created by using ``while`` syntax. Loops can be broken
 using ``break`` or continued using ``continue`` (which skips to the next
@@ -1579,7 +1577,7 @@ iteration of the loop without executing any further code in the current iteratio
         statement(s)
 
 for
-^^^
+~~~
 
 To iterate through a range, such as an array or table, a *for* loop is
 used. When iterating over an array, the current array element is stored in
@@ -1642,7 +1640,7 @@ be manipulated by calling methods on the loop variable.
         node.add_to_group("Cool_Group") # This has an effect
 
 match
-^^^^^
+~~~~~
 
 A ``match`` statement is used to branch execution of a program.
 It's the equivalent of the ``switch`` statement found in many other languages, but offers some additional features.
@@ -1653,7 +1651,7 @@ It's the equivalent of the ``switch`` statement found in many other languages, b
     for example, the String ``"hello"`` is considered equal to the StringName ``&"hello"``.
 
 Basic syntax
-""""""""""""
+^^^^^^^^^^^^
 
 ::
 
@@ -1665,7 +1663,7 @@ Basic syntax
         <...>
 
 Crash-course for people who are familiar with switch statements
-"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 1. Replace ``switch`` with ``match``.
 2. Remove ``case``.
@@ -1673,7 +1671,7 @@ Crash-course for people who are familiar with switch statements
 4. Change ``default`` to a single underscore.
 
 Control flow
-""""""""""""
+^^^^^^^^^^^^
 
 The patterns are matched from top to bottom.
 If a pattern matches, the first corresponding block will be executed. After that, the execution continues below the ``match`` statement.
@@ -1791,7 +1789,7 @@ The following pattern types are available:
                 print("Yep, you've taken damage")
 
 Pattern guards
-""""""""""""""
+^^^^^^^^^^^^^^
 
 A *pattern guard* is an optional condition that follows the pattern list
 and allows you to make additional checks before choosing a ``match`` branch.
@@ -1823,7 +1821,7 @@ you can specify a pattern guard after the list of patterns with the ``when`` key
   - If it's false, then the patterns of the next branch are checked.
 
 Classes
-~~~~~~~
+-------
 
 By default, all script files are unnamed classes. In this case, you can only
 reference them using the file's path, using either a relative or an absolute
@@ -1897,14 +1895,14 @@ If you want to use ``extends`` too, you can keep both on the same line::
 
 .. warning::
 
-    The Godot editor will hide these custom classes with names that beging with the prefix
-    "Editor" in the 'Create New Node' or 'Create New Scene' dialog windows. The classes 
-    are available for instantiation at runtime via their class names, but are 
-    automatically hidden by the editor windows along with the built-in editor nodes used 
+    The Godot editor will hide these custom classes with names that begin with the prefix
+    "Editor" in the 'Create New Node' or 'Create New Scene' dialog windows. The classes
+    are available for instantiation at runtime via their class names, but are
+    automatically hidden by the editor windows along with the built-in editor nodes used
     by the Godot editor.
 
 Inheritance
-^^^^^^^^^^^
+~~~~~~~~~~~
 
 A class (stored as a file) can inherit from:
 
@@ -1981,7 +1979,7 @@ the function name with the attribute operator::
     Signals and notifications can also be useful for these purposes.
 
 Class constructor
-^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~
 
 The class constructor, called on class instantiation, is named ``_init``. If you
 want to call the base class constructor, you can also use the ``super`` syntax.
@@ -2034,7 +2032,7 @@ There are a few things to keep in mind here:
         super(5)
 
 Static constructor
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 
 A static constructor is a static function ``_static_init`` that is called automatically
 when the class is loaded, after the static variables have been initialized::
@@ -2049,7 +2047,7 @@ A static constructor cannot take arguments and must not return any value.
 .. _doc_gdscript_basics_inner_classes:
 
 Inner classes
-^^^^^^^^^^^^^
+~~~~~~~~~~~~~
 
 A class file can contain inner classes. Inner classes are defined using the
 ``class`` keyword. They are instanced using the ``ClassName.new()``
@@ -2076,7 +2074,7 @@ function.
 .. _doc_gdscript_classes_as_resources:
 
 Classes as resources
-^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~
 
 Classes stored as files are treated as :ref:`GDScripts <class_GDScript>`. They
 must be loaded from disk to access them in other classes. This is done using
@@ -2095,7 +2093,7 @@ class resource is done by calling the ``new`` function on the class object::
         a.some_function()
 
 Exports
-~~~~~~~
+-------
 
 .. note::
 
@@ -2105,7 +2103,7 @@ Exports
 .. _doc_gdscript_basics_setters_getters:
 
 Properties (setters and getters)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------------
 
 Sometimes, you want a class' member variable to do more than just hold data and actually perform
 some validation or computation whenever its value changes. It may also be desired to
@@ -2132,7 +2130,7 @@ Example::
     code use that name.
 
 Alternative syntax
-^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~
 
 Also there is another notation to use existing class functions if you want to split the code from the variable declaration
 or you need to reuse the code across multiple properties (but you can't distinguish which property the setter/getter is being called for)::
@@ -2153,7 +2151,7 @@ The setter and getter must use the same notation, mixing styles for the same var
     Separated setter/getter functions can have type hints, and the type must match the variable's type or be a wider type.
 
 When setter/getter is not called
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 When a variable is initialized, the value of the initializer will be written directly to the variable.
 Including if the ``@onready`` annotation is applied to the variable.
@@ -2191,7 +2189,7 @@ This also applies to the alternative syntax::
 .. _doc_gdscript_tool_mode:
 
 Tool mode
-~~~~~~~~~
+---------
 
 By default, scripts don't run inside the editor and only the exported
 properties can be changed. In some cases, it is desired that they do run
@@ -2216,7 +2214,7 @@ See :ref:`doc_running_code_in_the_editor` for more information.
 .. _doc_gdscript_basics_memory_management:
 
 Memory management
-~~~~~~~~~~~~~~~~~
+-----------------
 
 Godot implements reference counting to free certain instances that are no longer
 used, instead of a garbage collector, or requiring purely manual management.
@@ -2264,7 +2262,7 @@ freed.
 .. _doc_gdscript_signals:
 
 Signals
-~~~~~~~
+-------
 
 Signals are a tool to emit messages from an object that other objects can react
 to. To create custom signals for a class, use the ``signal`` keyword.
@@ -2475,7 +2473,7 @@ This also means that returning a signal from a function that isn't a coroutine w
           during runtime.
 
 Assert keyword
-~~~~~~~~~~~~~~
+--------------
 
 The ``assert`` keyword can be used to check conditions in debug builds. These
 assertions are ignored in non-debug builds. This means that the expression

tutorials/scripting/gdscript/gdscript_documentation_comments.rst

@@ -73,13 +73,13 @@ Documenting script members
 
 Members that are applicable for documentation:
 
-- Inner class
-- Constant
-- Function
 - Signal
-- Variable
 - Enum
 - Enum value
+- Constant
+- Variable
+- Function
+- Inner class
 
 Documentation of a script member must immediately precede the member or its annotations
 if it has any. The description can have more than one line but every line must start with
@@ -106,6 +106,8 @@ For example::
 
 Alternatively, you can use inline documentation comments::
 
+    signal my_signal ## My signal.
+
     enum MyEnum { ## My enum.
         VALUE_A = 0, ## Value A.
         VALUE_B = 1, ## Value B.
@@ -115,11 +117,11 @@ Alternatively, you can use inline documentation comments::
 
     var my_var ## My variable.
 
-    signal my_signal ## My signal.
 
     func my_func(): ## My func.
         pass
 
+
     class MyClass: ## My class.
         pass
 
@@ -142,9 +144,6 @@ Complete script example
     ## @tutorial(Tutorial 2): https://example.com/tutorial_2
     ## @experimental
 
-    ## The description of a constant.
-    const GRAVITY = 9.8
-
     ## The description of a signal.
     signal my_signal
 
@@ -160,6 +159,9 @@ Complete script example
         RIGHT = 3,
     }
 
+    ## The description of a constant.
+    const GRAVITY = 9.8
+
     ## The description of the variable v1.
     var v1
 

tutorials/scripting/gdscript/gdscript_exports.rst

@@ -52,7 +52,7 @@ Resources and nodes can be exported.
     @export var resource: Resource
     @export var node: Node
 
-Grouping Exports
+Grouping exports
 ----------------
 
 It is possible to group your exported properties inside the Inspector
@@ -160,18 +160,68 @@ Allow floats from -10 to 20 and snap the value to multiples of 0.2.
 
     @export_range(-10, 20, 0.2) var k: float
 
-The limits can be only for the slider if you add the hints "or_greater" and/or "or_less".
+The limits can be made to affect only the slider if you add the hints ``"or_less"``
+and/or ``"or_greater"``. If either these hints are used, it will be possible for
+the user to enter any value or drag the value with the mouse when not using
+the slider, even if outside the specified range.
 
 ::
 
-    @export_range(0, 100, 1, "or_greater", "or_less")
+    @export_range(0, 100, 1, "or_less", "or_greater") var l: int
 
-.. TODO: Document other hint strings usable with export_range.
+The ``"exp"`` hint can be used to make a value have an exponential slider
+instead of a linear slider. This means that when dragging the slider towards
+the right, changes will become progressively faster when dragging the mouse.
+This is useful to make editing values that can be either very small or very large
+easier, at the cost of being less intuitive.
+
+::
+
+    @export_range(0, 100000, 0.01, "exp") var exponential: float
+
+For values that are meant to represent an easing factor, use
+:ref:`doc_gdscript_exports_floats_with_easing_hint` instead.
+
+The ``"hide_slider"`` hint can be used to hide the horizontal bar that
+appears below ``float`` properties, or the up/down arrows that appear besides
+``int`` properties:
+
+::
+
+    @export_range(0, 1000, 0.01, "hide_slider") var no_slider: float
+
+Adding suffixes and handling degrees/radians
+--------------------------------------------
+
+A suffix can also be defined to make the value more self-explanatory in the
+inspector. For example, to define a value that is meant to be configured as
+"meters" (``m``) by the user:
+
+::
+
+    @export_range(0, 100, 1, "suffix:m") var m: int
+
+For angles that are stored in radians but displayed as degrees to the user, use
+the `"radians_as_degrees"` hint:
+
+::
+
+    @export_range(0, 360, 0.1, "radians_as_degrees") var angle: float
+
+This performs automatic conversion when the value is displayed or modified in
+the inspector and also displays a degree (``°``) suffix. This approach is used
+by Godot's own `rotation` properties throughout the editor.
+
+If the angle is stored in degrees instead, use the `"degrees"` hint to display
+the degree symbol while disabling the automatic degrees-to-radians conversion
+when the value is modified from the inspector.
+
+.. _doc_gdscript_exports_floats_with_easing_hint:
 
 Floats with easing hint
 -----------------------
 
-Display a visual representation of the 'ease()' function
+Display a visual representation of the ``ease()`` function
 when editing.
 
 ::
@@ -374,7 +424,7 @@ Other export variants can also be used when exporting arrays:
 
 ::
 
-    @export_range(-360, 360, 0.001, "radians") var laser_angles: Array[float] = []
+    @export_range(-360, 360, 0.001, "degrees") var laser_angles: Array[float] = []
     @export_file("*.json") var skill_trees: Array[String] = []
     @export_color_no_alpha var hair_colors = PackedColorArray()
     @export_enum("Espresso", "Mocha", "Latte", "Capuccino") var barista_suggestions: Array[String] = []
@@ -401,6 +451,32 @@ or :ref:`Node.duplicate() <class_Node_method_duplicate>` is called, unlike non-e
     @export_storage var b # Stored in the file, not displayed in the editor.
     @export var c: int # Stored in the file, displayed in the editor.
 
+``@export_custom``
+------------------
+
+If you need more control than what's exposed with the built-in ``@export``
+annotations, you can use ``@export_custom`` instead. This allows defining any
+property hint, hint string and usage flags, with a syntax similar to the one
+used by the editor for built-in nodes.
+
+For example, this exposes the ``altitude`` property with no range limits but a
+``m`` (meter) suffix defined:
+
+::
+
+    @export_custom(PROPERTY_HINT_NONE, "altitude:m") var altitude: Vector3
+
+The above is normally not feasible with the standard ``@export_range`` syntax,
+since it requires defining a range.
+
+See the :ref:`class reference <class_@GDScript_annotation_@export_custom>`
+for a list of parameters and their allowed values.
+
+.. warning::
+
+    When using ``@export_custom``, GDScript does not perform any validation on
+    the syntax. Invalid syntax may have unexpected behavior in the inspector.
+
 Setting exported variables from a tool script
 ---------------------------------------------
 

tutorials/scripting/gdscript/gdscript_format_string.rst

@@ -3,21 +3,24 @@
 GDScript format strings
 =======================
 
-GDScript offers a feature called *format strings*, which allows reusing text
-templates to succinctly create different but similar strings.
+Godot offers multiple ways to dynamically change the contents of strings:
 
-Format strings are just like normal strings, except they contain certain
-placeholder character-sequences. These placeholders can then easily be replaced
-by parameters handed to the format string.
+- Format strings: ``var string = "I have %s cats." % "3"``
+- The ``String.format()`` method: ``var string = "I have {} cats.".format([3])``
+- String concatenation: ``var string = "I have " + str(3) + " cats."``
 
-As an example, with ``%s`` as a placeholder, the format string ``"Hello %s, how
-are you?"`` can easily be changed to ``"Hello World, how are you?"``. Notice
-the placeholder is in the middle of the string; modifying it without format
-strings could be cumbersome.
+This page explains how to use format strings, and briefly explains the ``format()``
+method and string concatenation.
 
+Format strings
+--------------
 
-Usage in GDScript
------------------
+*Format strings* are a way to reuse text templates to succinctly create different
+but similar strings.
+
+Format strings are just like normal strings, except they contain certain
+placeholder character sequences such as ``%s``. These placeholders can then
+be replaced by parameters handed to the format string.
 
 Examine this concrete GDScript example:
 
@@ -38,34 +41,12 @@ string.
 
 The ``%s`` seen in the example above is the simplest placeholder and works for
 most use cases: it converts the value by the same method by which an implicit
-String conversion or ``str()`` would convert it. Strings remain unchanged,
-Booleans turn into either ``"True"`` or ``"False"``, an integral or real number
-becomes a decimal, other types usually return their data in a human-readable
-string.
-
-There is also another way to format text in GDScript, namely the ``String.format()``
-method. It replaces all occurrences of a key in the string with the corresponding
-value. The method can handle arrays or dictionaries for the key/value pairs.
-
-Arrays can be used as key, index, or mixed style (see below examples). Order only
-matters when the index or mixed style of Array is used.
-
-A quick example in GDScript:
-
-::
-
-    # Define a format string
-    var format_string = "We're waiting for {str}"
-
-    # Using the 'format' method, replace the 'str' placeholder
-    var actual_string = format_string.format({"str": "Godot"})
-
-    print(actual_string)
-    # Output: "We're waiting for Godot"
-
-There are other `format specifiers`_, but they are only applicable when using
-the ``%`` operator.
+String conversion or :ref:`str() <class_@GlobalScope_method_str>` would convert
+it. Strings remain unchanged, booleans turn into either ``"True"`` or ``"False"``,
+an ``int`` or ``float`` becomes a decimal, and other types usually return their data
+in a human-readable string.
 
+There are other `format specifiers`_.
 
 Multiple placeholders
 ---------------------
@@ -108,19 +89,19 @@ specifier. Apart from ``s``, these require certain types of parameters.
 | ``c`` | A single **Unicode character**. Expects an unsigned 8-bit integer   |
 |       | (0-255) for a code point or a single-character string.              |
 +-------+---------------------------------------------------------------------+
-| ``d`` | A **decimal integral** number. Expects an integral or real number   |
+| ``d`` | A **decimal integer**. Expects an integer or a real number          |
 |       | (will be floored).                                                  |
 +-------+---------------------------------------------------------------------+
-| ``o`` | An **octal integral** number. Expects an integral or real number    |
+| ``o`` | An **octal integer**. Expects an integer or a real number           |
 |       | (will be floored).                                                  |
 +-------+---------------------------------------------------------------------+
-| ``x`` | A **hexadecimal integral** number with **lower-case** letters.      |
-|       | Expects an integral or real number (will be floored).               |
+| ``x`` | A **hexadecimal integer** with **lower-case** letters.              |
+|       | Expects an integer or a real number (will be floored).              |
 +-------+---------------------------------------------------------------------+
-| ``X`` | A **hexadecimal integral** number with **upper-case** letters.      |
-|       | Expects an integral or real number (will be floored).               |
+| ``X`` | A **hexadecimal integer** with **upper-case** letters.              |
+|       | Expects an integer or a real number (will be floored).              |
 +-------+---------------------------------------------------------------------+
-| ``f`` | A **decimal real** number. Expects an integral or real number.      |
+| ``f`` | A **decimal real** number. Expects an integer or a real number.     |
 +-------+---------------------------------------------------------------------+
 | ``v`` | A **vector**. Expects any float or int-based vector object (        |
 |       | ``Vector2``, ``Vector3``, ``Vector4``, ``Vector2i``, ``Vector3i`` or|
@@ -149,7 +130,7 @@ conditions.
 +---------+-------------------------------------------------------------------+
 | ``-``   | **Pad to the right** rather than the left.                        |
 +---------+-------------------------------------------------------------------+
-| ``*``   | **Dynamic padding**, expect additional integral parameter to set  |
+| ``*``   | **Dynamic padding**, expects additional integer parameter to set  |
 |         | padding or precision after ``.``, see `dynamic padding`_.         |
 +---------+-------------------------------------------------------------------+
 
@@ -170,7 +151,7 @@ To pad a string to a minimum length, add an integer to the specifier:
     # output: "     12345"
     # 5 leading spaces for a total length of 10
 
-If the integer starts with ``0``, integral values are padded with zeroes
+If the integer starts with ``0``, integer values are padded with zeroes
 instead of white space:
 
 ::
@@ -180,7 +161,7 @@ instead of white space:
 
 Precision can be specified for real numbers by adding a ``.`` (*dot*) with an
 integer following it. With no integer after ``.``, a precision of 0 is used,
-rounding to integral value. The integer to use for padding must appear before
+rounding to integer values. The integer to use for padding must appear before
 the dot.
 
 ::
@@ -238,12 +219,36 @@ avoid reading it as a placeholder. This is done by doubling the character:
     # Output: "Remaining health: 56%"
 
 
+String format method
+--------------------
+
+There is also another way to format text in GDScript, namely the 
+:ref:`String.format() <class_String_method_format>`
+method. It replaces all occurrences of a key in the string with the corresponding
+value. The method can handle arrays or dictionaries for the key/value pairs.
+
+Arrays can be used as key, index, or mixed style (see below examples). Order only
+matters when the index or mixed style of Array is used.
+
+A quick example in GDScript:
+
+::
+
+    # Define a format string
+    var format_string = "We're waiting for {str}"
+
+    # Using the 'format' method, replace the 'str' placeholder
+    var actual_string = format_string.format({"str": "Godot"})
+
+    print(actual_string)
+    # Output: "We're waiting for Godot"
+
+
 Format method examples
-----------------------
+~~~~~~~~~~~~~~~~~~~~~~
 
 The following are some examples of how to use the various invocations of the
-``String.format``  method.
-
+``String.format()``  method.
 
 +------------+-----------+------------------------------------------------------------------------------+-------------------+
 | **Type**   | **Style** | **Example**                                                                  | **Result**        |
@@ -258,9 +263,9 @@ The following are some examples of how to use the various invocations of the
 +------------+-----------+------------------------------------------------------------------------------+-------------------+
 | Array      | index     | ``"Hi, {0} v{1}!".format(["Godette","3.0"])``                                | Hi, Godette v3.0! |
 +------------+-----------+------------------------------------------------------------------------------+-------------------+
-| Array      | mix       | ``"Hi, {name} v{0}!".format([3.0, ["name","Godette"]])``                     | Hi, Godette v3.0! |
+| Array      | mix       | ``"Hi, {name} v{0}!".format(["3.0", ["name","Godette"]])``                   | Hi, Godette v3.0! |
 +------------+-----------+------------------------------------------------------------------------------+-------------------+
-| Array      | no index  | ``"Hi, {} v{}!".format(["Godette", 3.0], "{}")``                             | Hi, Godette v3.0! |
+| Array      | no index  | ``"Hi, {} v{}!".format(["Godette", "3.0"], "{}")``                           | Hi, Godette v3.0! |
 +------------+-----------+------------------------------------------------------------------------------+-------------------+
 
 Placeholders can also be customized when using ``String.format``, here's some
@@ -285,3 +290,41 @@ Combining both the ``String.format`` method and the ``%`` operator could be usef
 +---------------------------------------------------------------------------+-------------------+
 | ``"Hi, {0} v{version}".format({0:"Godette", "version":"%0.2f" % 3.114})`` | Hi, Godette v3.11 |
 +---------------------------------------------------------------------------+-------------------+
+
+String concatenation
+--------------------
+
+You can also combine strings by *concatenating* them together, using the ``+``
+operator.
+
+::
+
+    # Define a base string
+    var base_string = "We're waiting for "
+
+    # Concatenate the string
+    var actual_string = base_string + "Godot"
+
+    print(actual_string)
+    # Output: "We're waiting for Godot"
+
+When using string concatenation, values that are not strings must be converted using
+the ``str()`` function. There is no way to specify the string format of converted
+values.
+
+::
+
+    var name_string = "Godette"
+    var version = 3.0
+    var actual_string = "Hi, " + name_string + " v" + str(version) + "!"
+
+    print(actual_string)
+    # Output: "Hi, Godette v3!"
+
+Because of these limitations, format strings or the ``format()`` method are often
+a better choice. In many cases, string concatenation is also less readable.
+
+.. note::
+
+    In Godot's C++ code, GDScript format strings can be accessed using the
+    ``vformat()`` helper function in the :ref:`Variant<class_Variant>` header.

tutorials/scripting/gdscript/gdscript_styleguide.rst

@@ -744,7 +744,7 @@ We suggest to organize GDScript code this way:
     01. @tool
     02. class_name
     03. extends
-    04. # docstring
+    04. ## docstring
 
     05. signals
     06. enums
@@ -917,7 +917,7 @@ in that order.
 Static typing
 -------------
 
-Since Godot 3.1, GDScript supports :ref:`optional static typing<doc_gdscript_static_typing>`.
+GDScript supports :ref:`optional static typing<doc_gdscript_static_typing>`.
 
 Declared types
 ~~~~~~~~~~~~~~

tutorials/scripting/gdscript/static_typing.rst

@@ -198,14 +198,17 @@ To define the type of an ``Array``, enclose the type name in ``[]``.
 An array's type applies to ``for`` loop variables, as well as some operators like
 ``[]``, ``[]=``, and ``+``. Array methods (such as ``push_back``) and other operators
 (such as ``==``) are still untyped. Built-in types, native and custom classes,
-and enums may be used as element types. Nested array types are not supported.
+and enums may be used as element types. Nested array types
+(like ``Array[Array[int]]``) are not supported.
+
 
 ::
 
     var scores: Array[int] = [10, 20, 30]
     var vehicles: Array[Node] = [$Car, $Plane]
     var items: Array[Item] = [Item.new()]
-    # var arrays: Array[Array] -- disallowed
+    var array_of_arrays: Array[Array] = [[], []]
+    # var arrays: Array[Array[int]] -- disallowed
 
     for score in scores:
         # score has type `int`
@@ -381,9 +384,9 @@ Warning system
     Detailed documentation about the GDScript warning system has been moved to
     :ref:`doc_gdscript_warning_system`.
 
-From version 3.1, Godot gives you warnings about your code as you write it:
-the engine identifies sections of your code that may lead to issues at runtime,
-but lets you decide whether or not you want to leave the code as it is.
+Godot gives you warnings about your code as you write it. The engine identifies
+sections of your code that may lead to issues at runtime, but lets you decide
+whether or not you want to leave the code as it is.
 
 We have a number of warnings aimed specifically at users of typed GDScript.
 By default, these warnings are disabled, you can enable them in Project Settings
@@ -407,10 +410,10 @@ that has a script attached with ``class_name MyScript`` and that ``extends
 Node2D``. If we have a reference to the object as a ``Node2D`` (for instance,
 as it was passed to us by the physics system), we can first check if the
 property and method exist and then set and call them if they do::
-    
+
     if "some_property" in node_2d:
         node_2d.some_property = 20  # Produces UNSAFE_PROPERTY_ACCESS warning.
-    
+
     if node_2d.has_method("some_function"):
         node_2d.some_function()  # Produces UNSAFE_METHOD_ACCESS warning.
 
@@ -420,7 +423,7 @@ in the referenced type - in this case a ``Node2D``. To make these operations
 safe, you can first check if the object is of type ``MyScript`` using the
 ``is`` keyword and then declare a variable with the type ``MyScript`` on
 which you can set its properties and call its methods::
-    
+
     if node_2d is MyScript:
         var my_script: MyScript = node_2d
         my_script.some_property = 20
@@ -443,7 +446,7 @@ collision area to show the area's name. Once the object enters the collision
 area, the physics system sends a signal with a ``Node2D`` object, and the most
 straightforward (but not statically typed) solution to do what we want could
 be achieved like this::
-    
+
     func _on_body_entered(body: Node2D) -> void:
         body.label.text = name  # Produces UNSAFE_PROPERTY_ACCESS warning.
 

tutorials/scripting/index.rst

@@ -11,6 +11,7 @@ sections. For instance, to learn about inputs, we recommend you to read
 :ref:`Inputs <toc-learn-features-inputs>`.
 
 .. rubric:: Programming languages
+   :heading-level: 2
 
 The sections below each focus on a given programming language.
 

tutorials/scripting/singletons_autoload.rst

@@ -60,7 +60,7 @@ You can create an Autoload to load a scene or a script that inherits from
 
 .. image:: img/singleton.webp
 
-To autoload a scene or script, start from the menu and navigate to 
+To autoload a scene or script, start from the menu and navigate to
 **Project > Project Settings > Globals > Autoload**.
 
 .. image:: img/autoload_tab.webp
@@ -172,7 +172,8 @@ means that the last child of root is always the loaded scene.
 
     func _ready():
         var root = get_tree().root
-        current_scene = root.get_child(root.get_child_count() - 1)
+        # Using a negative index counts from the end, so this gets the last child node of `root`.
+        current_scene = root.get_child(-1)
 
  .. code-tab:: csharp
 
@@ -185,7 +186,8 @@ means that the last child of root is always the loaded scene.
         public override void _Ready()
         {
             Viewport root = GetTree().Root;
-            CurrentScene = root.GetChild(root.GetChildCount() - 1);
+            // Using a negative index counts from the end, so this gets the last child node of `root`.
+            CurrentScene = root.GetChild(-1);
         }
     }
 

tutorials/shaders/shader_reference/shading_language.rst

@@ -86,6 +86,14 @@ Most GLSL ES 3.0 datatypes are supported:
 |                      | Only supported in Forward+ and Mobile, not Compatibility.                       |
 +----------------------+---------------------------------------------------------------------------------+
 
+.. warning::
+
+    Local variables are not initialized to a default value such as ``0.0``. If
+    you use a variable without assigning it first, it will contain whatever
+    value was already present at that memory location, and unpredictable visual
+    glitches will appear. However, uniforms and varyings are initialized to a
+    default value.
+
 Comments
 ~~~~~~~~
 
@@ -155,8 +163,8 @@ Individual scalar members of vector types are accessed via the "x", "y", "z" and
 equivalent. Use whatever fits best for your needs.
 
 For matrices, use the ``m[column][row]`` indexing syntax to access each scalar,
-or ``m[idx]`` to access a vector by row index. For example, for accessing the y
-position of an object in a mat4 you use ``m[3][1]``.
+or ``m[column]`` to access a vector by column index. For example, for accessing the
+y-component of the translation from a mat4 transform matrix (4th column, 2nd line) you use ``m[3][1]`` or ``m[3].y``.
 
 Constructing
 ~~~~~~~~~~~~
@@ -174,7 +182,7 @@ Construction of vector types must always pass:
     vec4 a = vec4(0.0);
 
 Construction of matrix types requires vectors of the same dimension as the
-matrix. You can also build a diagonal matrix using ``matx(float)`` syntax.
+matrix, interpreted as columns. You can also build a diagonal matrix using ``matx(float)`` syntax.
 Accordingly, ``mat4(1.0)`` is an identity matrix.
 
 .. code-block:: glsl

tutorials/shaders/shader_reference/spatial_shader.rst

@@ -268,8 +268,9 @@ these properties, and if you don't write to them, Godot will optimize away the c
 +========================================+==================================================================================================+
 | in vec2 **VIEWPORT_SIZE**              | Size of viewport (in pixels).                                                                    |
 +----------------------------------------+--------------------------------------------------------------------------------------------------+
-| in vec4 **FRAGCOORD**                  | Coordinate of pixel center in screen space. ``xy`` specifies position in window, ``z``           |
-|                                        | specifies fragment depth if ``DEPTH`` is not used. Origin is lower-left.                         |
+| in vec4 **FRAGCOORD**                  | Coordinate of pixel center in screen space. ``xy`` specifies position in window. Origin is lower |
+|                                        | left. ``z`` specifies fragment depth. It is also used as the output value for the fragment depth |
+|                                        | unless ``DEPTH`` is written to.                                                                  |
 +----------------------------------------+--------------------------------------------------------------------------------------------------+
 | in bool **FRONT_FACING**               | ``true`` if current face is front facing.                                                        |
 +----------------------------------------+--------------------------------------------------------------------------------------------------+

tutorials/troubleshooting.rst

@@ -177,7 +177,7 @@ OpenGL applications by your graphics driver.
 - **AMD (Windows):** Open the start menu and choose **AMD Software**. Click the
   settings "cog" icon in the top-right corner. Go to the **Graphics** tab,
   scroll to the bottom and click **Advanced** to unfold its settings. Disable
-  **Morphological Anti-Aliasing**.
+  **Morphological Antialiasing**.
 
 Third-party vendor-independent utilities such as vkBasalt may also force
 sharpening or FXAA on all Vulkan applications. You may want to check their

tutorials/ui/size_and_anchors.rst

@@ -1,4 +1,3 @@
-:article_outdated: True
 
 .. _doc_size_and_anchors:
 
@@ -10,58 +9,62 @@ resolution, positioning controls would be a simple matter of setting the
 position and size of each one of them. Unfortunately, that is rarely the
 case.
 
-Only TVs nowadays have a standard resolution and aspect ratio.
-Everything else, from computer monitors to tablets, portable consoles
-and mobile phones have different resolutions and aspect ratios.
+While some configurations may be more common than others, devices like 
+phones, tablets and portable gaming consoles can vary greatly. Therefore, 
+we often have to account for different aspect ratios, resolutions and user 
+scaling.
 
-There are several ways to handle this, but for now, let's just imagine
+There are several ways to account for this, but for now, let's just imagine
 that the screen resolution has changed and the controls need to be
 re-positioned. Some will need to follow the bottom of the screen, others
 the top of the screen, or maybe the right or left margins.
 
 .. image:: img/anchors.png
 
-This is done by editing the *margin* properties of controls. Each
-control has four margins: left, right, bottom, and top, which correspond
+This is done by editing the *anchor offsets* of controls, which behave similar
+to a margin. To access these settings, you will first need to select the *Custom* 
+anchor preset.
+
+Each control has four anchor offsets: left, right, bottom, and top, which correspond
 to the respective edges of the control. By default, all of
 them represent a distance in pixels relative to the top-left corner of
 the parent control or (in case there is no parent control) the viewport.
 
-.. image:: img/margin.png
+.. image:: img/offset.webp
 
-So to make the control wider you can make the right margin larger and/or
-make the left margin smaller. This lets you set the exact placement
+So to make the control wider you can make the right offset larger and/or
+make the left offset smaller. This lets you set the exact placement
 and shape of the control.
 
-The *anchor* properties adjust where the margin distances are relative *to*.
-Each margin has an individual anchor that can be adjusted from the
+The *anchor* properties adjust where the offsets are relative *to*.
+Each offset has an individual anchor that can be adjusted from the
 beginning to the end of the parent. So the vertical (top, bottom) anchors
-adjust from 0 (top of parent) to 1.0 (bottom of parent) with 0.5 being
-the center, and the control margins will be placed relative to that
+adjust from ``0.0`` (top of parent) to ``1.0`` (bottom of parent) with ``0.5`` being
+the center, and the control offsets will be placed relative to that
 point. The horizontal (left, right) anchors similarly adjust from left to
 right of the parent.
 
 Note that when you wish the edge of a control to be above or left of the
-anchor point, you must change the margin value to be negative.
+anchor point, you must change the offset value to be negative.
 
-For example: when horizontal anchors are changed to 1, the margin values
+For example: when horizontal anchors are changed to ``1.0``, the offset values
 become relative to the top-right corner of the parent control or viewport.
 
-.. image:: img/marginend.png
+.. image:: img/offset_end.webp
 
 Adjusting the two horizontal or the two vertical anchors to different
 values will make the control change size when the parent control does.
 Here, the control is set to anchor its bottom-right corner to the
-parent's bottom-right, while the top-left control margins are still
+parent's bottom-right, while the top-left control offsets are still
 anchored to the top-left of the parent, so when re-sizing the parent,
-the control will always cover it, leaving a 20 pixel margin:
+the control will always cover it, leaving a 20 pixel offset:
 
-.. image:: img/marginaround.png
+.. image:: img/offset_around.webp
 
 Centering a control
 -------------------
 
-To center a control in its parent, set its anchors to 0.5 and each margin
+To center a control in its parent, set its anchors to ``0.5`` and each offset
 to half of its relevant dimension. For example, the code below shows how
 a TextureRect can be centered in its parent:
 
@@ -99,15 +102,15 @@ a TextureRect can be centered in its parent:
     rect.OffsetBottom = textureSize.Y / 2;
     AddChild(rect);
 
-Setting each anchor to 0.5 moves the reference point for the margins to
-the center of its parent. From there, we set negative margins so that
+Setting each anchor to ``0.5`` moves the reference point for the offsets to
+the center of its parent. From there, we set negative offsets so that
 the control gets its natural size.
 
-Layout Presets
+Anchor Presets
 --------------
 
-Instead of manually adjusting the margin and anchor values, you can use the
-toolbar's Layout menu, above the viewport. Besides centering, it gives you many
+Instead of manually adjusting the offset and anchor values, you can use the
+toolbar's Anchor menu, above the viewport. Besides centering, it gives you many
 options to align and resize control nodes.
 
-.. image:: img/layout_dropdown_menu.png
+.. image:: img/anchor_presets.webp

tutorials/xr/a_better_xr_start_script.rst

@@ -20,7 +20,7 @@ Signals for our script
 We are introducing 3 signals to our script so that our game can add further logic:
 
 - ``focus_lost`` is emitted when the player takes off their headset or when the player enters the menu system of the headset.
-- ``focus_gained`` is emitted when the player puts their headset back on or exists the menu system and returns to the game.
+- ``focus_gained`` is emitted when the player puts their headset back on or exits the menu system and returns to the game.
 - ``pose_recentered`` is emitted when the headset requests the players position to be reset.
 
 Our game should react accordingly to these signals.