From 73841919b69ed5a5068f68bc3c3b52a64d98c93b Mon Sep 17 00:00:00 2001
From: Relintai <relintai@protonmail.com>
Date: Thu, 12 Jan 2023 20:47:54 +0100
Subject: [PATCH] More cleanups.

---
 README.md                                     |  2 +-
 about/complying_with_licenses.md              |  6 +-
 about/docs_changelog.md                       |  4 +-
 about/faq.md                                  | 22 +++---
 about/introduction.md                         |  8 +--
 about/list_of_features.md                     | 70 +++++++++----------
 about/troubleshooting.md                      |  6 +-
 .../contributing/bisecting_regressions.md     |  4 +-
 .../class_reference_writing_guidelines.md     |  2 +-
 .../contributing/code_style_guidelines.md     |  4 +-
 .../contributing_to_the_documentation.md      |  4 +-
 .../contributing/docs_writing_guidelines.md   |  2 +-
 .../contributing/documentation_guidelines.md  |  2 +-
 .../editor_and_docs_localization.md           | 12 ++--
 community/contributing/pr_workflow.md         | 14 ++--
 .../contributing/testing_pull_requests.md     |  4 +-
 .../updating_the_class_reference.md           |  8 +--
 community/contributing/ways_to_contribute.md  |  4 +-
 .../compiling/compiling_for_android.md        | 18 ++---
 development/compiling/compiling_for_osx.md    |  2 +-
 development/compiling/compiling_for_web.md    |  6 +-
 .../compiling/compiling_for_windows.md        |  2 +-
 development/compiling/compiling_for_x11.md    |  4 +-
 development/compiling/compiling_with_mono.md  |  6 +-
 development/compiling/getting_source.md       |  6 +-
 development/compiling/optimizing_for_size.md  |  2 +-
 development/cpp/configuring_an_ide/clion.md   |  2 +-
 .../cpp/configuring_an_ide/qt_creator.md      |  4 +-
 .../cpp/configuring_an_ide/visual_studio.md   |  2 +-
 development/cpp/custom_godot_servers.md       |  2 +-
 development/cpp/custom_modules_in_cpp.md      |  4 +-
 .../cpp/custom_resource_format_loaders.md     |  2 +-
 development/editor/creating_icons.md          |  2 +-
 .../introduction_to_editor_development.md     |  4 +-
 .../first_2d_game/02.player_scene.md          |  6 +-
 .../first_2d_game/06.heads_up_display.md      |  2 +-
 .../first_3d_game/06.jump_and_squash.md       | 10 +--
 .../first_3d_game/08.score_and_replay.md      |  4 +-
 .../first_3d_game/going_further.md            |  6 +-
 .../introduction/first_look_at_the_editor.md  |  2 +-
 .../introduction/introduction_to_godot.md     |  2 +-
 getting_started/step_by_step/instancing.md    |  2 +-
 .../step_by_step/scripting_first_script.md    |  4 +-
 .../step_by_step/scripting_languages.md       |  8 +--
 getting_started/step_by_step/signals.md       |  2 +-
 index.md                                      |  2 +-
 tutorials/2d/2d_lights_and_shadows.md         |  2 +-
 tutorials/2d/2d_movement.md                   |  2 +-
 tutorials/2d/2d_sprite_animation.md           |  4 +-
 tutorials/2d/2d_transforms.md                 |  2 +-
 tutorials/2d/custom_drawing_in_2d.md          |  4 +-
 tutorials/3d/3d_text.md                       |  2 +-
 tutorials/3d/baked_lightmaps.md               |  2 +-
 .../portals/advanced_room_and_portal_usage.md |  8 +--
 .../3d/portals/editing_rooms_and_portals.md   | 14 ++--
 .../first_steps_with_rooms_and_portals.md     | 10 +--
 .../introduction_to_rooms_and_portals.md      |  2 +-
 .../3d/portals/rooms_and_portals_example.md   | 12 ++--
 .../using_objects_in_rooms_and_portals.md     |  6 +-
 tutorials/3d/procedural_geometry/index.md     |  8 +--
 .../3d/procedural_geometry/meshdatatool.md    |  4 +-
 tutorials/3d/using_gridmaps.md                |  4 +-
 tutorials/animation/cutout_animation.md       |  2 +-
 tutorials/animation/playing_videos.md         |  2 +-
 tutorials/assets_pipeline/import_process.md   |  4 +-
 .../importing_audio_samples.md                |  2 +-
 .../assets_pipeline/importing_translations.md |  2 +-
 tutorials/audio/audio_buses.md                |  4 +-
 tutorials/audio/sync_with_audio.md            | 10 +--
 .../autoloads_versus_internal_nodes.md        |  4 +-
 tutorials/best_practices/data_preferences.md  |  2 +-
 tutorials/best_practices/godot_interfaces.md  |  2 +-
 tutorials/best_practices/logic_preferences.md |  2 +-
 tutorials/best_practices/node_alternatives.md |  2 +-
 .../best_practices/scene_organization.md      |  6 +-
 .../best_practices/scenes_versus_scripts.md   |  6 +-
 .../best_practices/what_are_godot_classes.md  |  2 +-
 tutorials/editor/command_line_tutorial.md     | 20 +++---
 tutorials/editor/index.md                     |  2 +-
 tutorials/export/android_custom_build.md      |  4 +-
 .../changing_application_icon_for_windows.md  |  2 +-
 .../export/exporting_for_dedicated_servers.md |  2 +-
 tutorials/export/exporting_for_macos.md       |  6 +-
 tutorials/export/exporting_for_web.md         | 36 +++++-----
 tutorials/export/exporting_pcks.md            |  2 +-
 tutorials/export/exporting_projects.md        |  2 +-
 tutorials/export/feature_tags.md              |  4 +-
 tutorials/i18n/internationalizing_games.md    |  6 +-
 tutorials/i18n/localization_using_gettext.md  |  2 +-
 tutorials/inputs/input_examples.md            |  8 +--
 tutorials/io/background_loading.md            |  8 +--
 tutorials/io/binary_serialization_api.md      | 52 +++++++-------
 tutorials/io/data_paths.md                    |  4 +-
 tutorials/io/saving_games.md                  | 10 +--
 tutorials/math/beziers_and_curves.md          |  6 +-
 tutorials/math/interpolation.md               |  2 +-
 tutorials/math/random_number_generation.md    | 12 ++--
 .../navigation/real_time_navigation_3d.md     | 16 ++---
 .../networking/high_level_multiplayer.md      |  2 +-
 tutorials/networking/http_client_class.md     |  2 +-
 tutorials/networking/http_request_class.md    |  2 +-
 tutorials/networking/webrtc.md                |  4 +-
 tutorials/networking/websocket.md             |  2 +-
 tutorials/performance/batching.md             |  8 +--
 tutorials/performance/cpu_optimization.md     |  2 +-
 tutorials/performance/gpu_optimization.md     |  4 +-
 .../performance/optimizing_3d_performance.md  |  6 +-
 .../performance/threads/thread_safe_apis.md   |  2 +-
 .../threads/using_multiple_threads.md         | 14 ++--
 tutorials/performance/using_multimesh.md      |  8 +--
 tutorials/performance/using_servers.md        |  4 +-
 .../animating_thousands_of_fish.md            |  2 +-
 .../controlling_thousands_of_fish.md          |  2 +-
 .../advanced_physics_interpolation.md         | 22 +++---
 .../physics_interpolation_introduction.md     |  4 +-
 ...physics_interpolation_quick_start_guide.md |  6 +-
 .../using_physics_interpolation.md            | 10 +--
 tutorials/physics/physics_introduction.md     |  4 +-
 .../android/android_in_app_purchases.md       |  2 +-
 tutorials/platform/android/android_plugin.md  |  2 +-
 tutorials/platform/customizing_html5_shell.md |  2 +-
 tutorials/platform/html5_shell_classref.md    |  6 +-
 .../platform/mobile_rendering_limitations.md  |  2 +-
 tutorials/plugins/editor/import_plugins.md    | 10 +--
 tutorials/plugins/editor/making_plugins.md    |  6 +-
 tutorials/plugins/editor/spatial_gizmos.md    | 14 ++--
 .../plugins/running_code_in_the_editor.md     |  4 +-
 tutorials/rendering/multiple_resolutions.md   |  4 +-
 tutorials/rendering/viewports.md              | 10 +--
 tutorials/scripting/debug/debugger_panel.md   |  2 +-
 .../debug/overview_of_debugging_tools.md      |  2 +-
 .../scripting/gdscript/gdscript_basics.md     | 18 ++---
 .../scripting/gdscript/gdscript_exports.md    |  2 +-
 .../scripting/gdscript/gdscript_styleguide.md |  4 +-
 tutorials/scripting/gdscript/static_typing.md |  4 +-
 .../scripting/gdscript/warning_system.md      |  2 +-
 tutorials/scripting/groups.md                 |  2 +-
 .../scripting/idle_and_physics_processing.md  |  2 +-
 .../scripting/nodes_and_scene_instances.md    |  4 +-
 tutorials/scripting/overridable_functions.md  |  6 +-
 tutorials/scripting/resources.md              | 10 +--
 tutorials/scripting/singletons_autoload.md    |  2 +-
 tutorials/shaders/advanced_postprocessing.md  |  4 +-
 .../converting_glsl_to_godot_shaders.md       |  6 +-
 tutorials/shaders/custom_postprocessing.md    |  6 +-
 tutorials/shaders/introduction_to_shaders.md  | 12 ++--
 .../shader_reference/canvas_item_shader.md    |  2 +-
 .../shader_reference/shading_language.md      | 10 +--
 .../shader_reference/spatial_shader.md        |  4 +-
 .../your_first_shader/your_first_2d_shader.md | 18 ++---
 .../your_first_shader/your_first_3d_shader.md | 20 +++---
 .../your_second_3d_shader.md                  |  8 +--
 tutorials/ui/bbcode_in_richtextlabel.md       |  2 +-
 tutorials/ui/gui_containers.md                |  2 +-
 tutorials/ui/gui_navigation.md                |  2 +-
 tutorials/ui/gui_skinning.md                  | 10 +--
 tutorials/ui/gui_theme_type_variations.md     |  4 +-
 157 files changed, 491 insertions(+), 491 deletions(-)

diff --git a/README.md b/README.md
index 9113da0..4750d9b 100644
--- a/README.md
+++ b/README.md
@@ -54,7 +54,7 @@ To add images, please put them in an `img/` folder next to the .rst file with a
 
 Similarly, you can include attachments (like assets as support material for a tutorial) by placing them into a `files/` folder next to the .rst file, and using this inline markup:
 ```rst
-:download:`myfilename.zip <files/myfilename.zip )`
+:download:`myfilename.zip ( files/myfilename.zip )`
 ```
 
 ## Building with Sphinx
diff --git a/about/complying_with_licenses.md b/about/complying_with_licenses.md
index 2b7aa03..08ed6d0 100644
--- a/about/complying_with_licenses.md
+++ b/about/complying_with_licenses.md
@@ -112,11 +112,11 @@ Godot uses `FreeType ( https://www.freetype.org/ )`_ to render fonts. Its licens
 requires attribution, so the following text must be included together with the
 Godot license:
 
-    Portions of this software are copyright © <year> The FreeType Project (www.freetype.org).  All rights reserved.
+    Portions of this software are copyright © ( year> The FreeType Project (www.freetype.org).  All rights reserved.
 
 .. note::
 
-    <year> should correspond to the value from the FreeType version used
+    ( year> should correspond to the value from the FreeType version used
     in your build. This information can be found in the editor by opening
     the **Help > About** dialog and going to the **Third-party Licenses**
     tab.
@@ -163,5 +163,5 @@ as the latest version of OpenSSL currently uses (as of April 2022).
 .. note::
 
     If you exported your project using a
-    `custom build with specific modules disabled <doc_optimizing_for_size )`,
+    `custom build with specific modules disabled ( doc_optimizing_for_size )`,
     you don't need to list the disabled modules' licenses in your exported project.
diff --git a/about/docs_changelog.md b/about/docs_changelog.md
index 960d5da..88ba230 100644
--- a/about/docs_changelog.md
+++ b/about/docs_changelog.md
@@ -5,7 +5,7 @@ Documentation changelog
 
 The documentation is continually being improved. The release of version 3.2
 includes many new tutorials, many fixes and updates for old tutorials, and many updates
-to the `class reference <toc-class-ref )`. Below is a list of new tutorials
+to the `class reference ( toc-class-ref )`. Below is a list of new tutorials
 added since version 3.1.
 
 .. note:: This document only contains new tutorials so not all changes are reflected,
@@ -83,7 +83,7 @@ Creating content
 ^^^^^^^^^^^^^^^^
 
 Procedural geometry series:
-  - `Procedural geometry <toc-procedural_geometry )`
+  - `Procedural geometry ( toc-procedural_geometry )`
   - `doc_arraymesh`
   - `doc_surfacetool`
   - `doc_meshdatatool`
diff --git a/about/faq.md b/about/faq.md
index 528b760..733d27b 100644
--- a/about/faq.md
+++ b/about/faq.md
@@ -38,7 +38,7 @@ Which platforms are supported by Godot?
 * Windows
 * macOS
 * X11 (Linux, \*BSD)
-* `Web <doc_using_the_web_editor )`
+* `Web ( doc_using_the_web_editor )`
 * Android (experimental)
 
 **For exporting your games:**
@@ -60,15 +60,15 @@ Additionally, there is some unofficial third-party work being done on building
 for some consoles. However, none of this is included in the default build
 scripts or export templates at this time.
 
-For more on this, see the sections on `exporting <toc-learn-workflow-export )`
-and `compiling Godot yourself <toc-devel-compiling )`.
+For more on this, see the sections on `exporting ( toc-learn-workflow-export )`
+and `compiling Godot yourself ( toc-devel-compiling )`.
 
 Which programming languages are supported in Godot?
 ---------------------------------------------------
 
 The officially supported languages for Godot are GDScript, Visual Scripting,
 C#, and C++. See the subcategories for each language in the
-`scripting <toc-learn-scripting )` section.
+`scripting ( toc-learn-scripting )` section.
 
 If you are just starting out with either Godot or game development in general,
 GDScript is the recommended language to learn and use since it is native to Godot.
@@ -99,7 +99,7 @@ up to maximize Godot's potential in the least amount of code, affording both nov
 and expert developers alike to capitalize on Godot's strengths as fast as possible.
 If you've ever written anything in a language like Python before then you'll feel
 right at home. For examples, history, and a complete overview of the power GDScript
-offers you, check out the `GDScript scripting guide <doc_gdscript )`.
+offers you, check out the `GDScript scripting guide ( doc_gdscript )`.
 
 There are several reasons to use GDScript--especially when you are prototyping, in
 alpha/beta stages of your project, or are not creating the next AAA title--but the
@@ -225,7 +225,7 @@ Linux
   This is typically `/usr/local/bin/godot` or `/usr/bin/godot`.
   Doing this requires administrator privileges,
   but this also allows you to
-  `run the Godot editor from a terminal <doc_command_line_tutorial )` by entering `godot`.
+  `run the Godot editor from a terminal ( doc_command_line_tutorial )` by entering `godot`.
 
   - If you cannot move the Godot editor binary to a protected location, you can
     keep the binary somewhere in your home directory, and modify the `Path=`
@@ -309,7 +309,7 @@ functionality in Godot. This is why we are aiming to move some core
 functionality to officially supported add-ons in future versions of Godot. In
 terms of binary size, this also has the advantage of making you pay only for what
 you actually use in your project. (In the meantime, you can
-`compile custom export templates with unused features disabled <doc_optimizing_for_size )`
+`compile custom export templates with unused features disabled ( doc_optimizing_for_size )`
 to optimize the distribution size of your project.)
 
 How should assets be created to handle multiple resolutions and aspect ratios?
@@ -344,7 +344,7 @@ This is mostly needed for 2D, as in 3D it's just a matter of Camera XFov or YFov
    if there is one aspect ratio and you want black bars to appear
    instead. This is also explained in `doc_multiple_resolutions`.
 
-4. For user interfaces, use the `anchoring <doc_size_and_anchors )`
+4. For user interfaces, use the `anchoring ( doc_size_and_anchors )`
    to determine where controls should stay and move. If UIs are more
    complex, consider learning about Containers.
 
@@ -359,7 +359,7 @@ How can I extend Godot?
 -----------------------
 
 For extending Godot, like creating Godot Editor plugins or adding support
-for additional languages, take a look at `EditorPlugins <doc_making_plugins )`
+for additional languages, take a look at `EditorPlugins ( doc_making_plugins )`
 and tool scripts.
 
 Also, see the official blog posts on these topics:
@@ -474,9 +474,9 @@ have to deal with the LGPL licensing caveats that come with GTK or Qt. Lastly,
 this means Godot is "eating its own dog food" since the editor itself is one of
 the most complex users of Godot's UI system.
 
-This custom UI toolkit `can't be used as a library <doc_faq_use_godot_as_library )`,
+This custom UI toolkit `can't be used as a library ( doc_faq_use_godot_as_library )`,
 but you can still
-`use Godot to create non-game applications by using the editor <doc_faq_non_game_applications )`.
+`use Godot to create non-game applications by using the editor ( doc_faq_non_game_applications )`.
 
 .. _doc_faq_why_not_stl:
 
diff --git a/about/introduction.md b/about/introduction.md
index 453b839..1b945b1 100644
--- a/about/introduction.md
+++ b/about/introduction.md
@@ -20,12 +20,12 @@ where to look if you need info on a specific feature.
 Before you start
 ----------------
 
-The `Tutorials and resources <doc_community_tutorials )` page lists
+The `Tutorials and resources ( doc_community_tutorials )` page lists
 video tutorials contributed by the community. If you prefer video to text,
 those may be worth a look.
 
 In case you have trouble with one of the tutorials or your project,
-you can find help on the various `Community channels <doc_community_channels )`,
+you can find help on the various `Community channels ( doc_community_channels )`,
 especially the Godot Discord community, Q&A, and IRC.
 
 About Godot Engine
@@ -51,7 +51,7 @@ if you need a quick writeup about Godot Engine.
 
 For a more in-depth view of the engine, you are encouraged to read this
 documentation further, especially the `Step by step
-<toc-learn-step_by_step )` tutorial.
+( toc-learn-step_by_step )` tutorial.
 
 About the documentation
 -----------------------
@@ -86,7 +86,7 @@ relatively intuitive:
 - The `sec-learn` section is the *raison d'être* of this
   documentation, as it contains all the necessary information on using the
   engine to make games. It starts with the `Step by step
-  <toc-learn-step_by_step )` tutorial which should be the entry point for all
+  ( toc-learn-step_by_step )` tutorial which should be the entry point for all
   new users.
 - The `sec-tutorials` section can be read as needed,
   in any order. It contains feature-specific tutorials and documentation.
diff --git a/about/list_of_features.md b/about/list_of_features.md
index afb328f..e936694 100644
--- a/about/list_of_features.md
+++ b/about/list_of_features.md
@@ -33,8 +33,8 @@ Platforms
 
 - Android 4.4 and later.
 - iOS 10.0 and later.
-- `Consoles <doc_consoles )`.
-- `Headless Linux and macOS servers <doc_exporting_for_dedicated_servers )`.
+- `Consoles ( doc_consoles )`.
+- `Headless Linux and macOS servers ( doc_exporting_for_dedicated_servers )`.
 
 Godot aims to be as platform-independent as possible and can be ported to new
 platforms with relative ease.
@@ -46,9 +46,9 @@ Editor
 
 - Scene tree editor.
 - Built-in script editor.
-- Support for `external script editors <doc_external_editor )` such as
+- Support for `external script editors ( doc_external_editor )` such as
   Visual Studio Code or Vim.
-- GDScript `debugger <doc_debugger_panel )`.
+- GDScript `debugger ( doc_debugger_panel )`.
 
    - No support for debugging in threads yet.
 - Performance monitoring tools.
@@ -71,10 +71,10 @@ Editor
 **Plugins:**
 
 - Editor plugins can be downloaded from the
-  `asset library <doc_what_is_assetlib )` to extend editor functionality.
-- `Create your own plugins <doc_making_plugins )` using GDScript to add new
+  `asset library ( doc_what_is_assetlib )` to extend editor functionality.
+- `Create your own plugins ( doc_making_plugins )` using GDScript to add new
   features or speed up your workflow.
-- `Download projects from the asset library <doc_using_assetlib_editor )`
+- `Download projects from the asset library ( doc_using_assetlib_editor )`
   in the project manager and import them directly.
 
 2D graphics
@@ -275,7 +275,7 @@ Editor
 
 **Performance:**
 
-- Occlusion culling with `rooms and portals <doc_rooms_and_portals )`.
+- Occlusion culling with `rooms and portals ( doc_rooms_and_portals )`.
   Supports gameplay notifications with primary and secondary visibility to
   disable AI/physics processing for nodes that don't need it.
 - Real-time occluder shapes (sphere and polygon). Not as effective as rooms and portals
@@ -291,8 +291,8 @@ Editor
 ^^^^^^^^
 
 - Built-in meshes: cube, cylinder/cone, (hemi)sphere, prism, plane, quad.
-- Tools for `procedural geometry generation <doc_procedural_geometry )`.
-- `Constructive solid geometry <doc_csg_tools )` (intended for prototyping).
+- Tools for `procedural geometry generation ( doc_procedural_geometry )`.
+- `Constructive solid geometry ( doc_csg_tools )` (intended for prototyping).
 - Path3D node to represent a path in 3D space.
 
    - Can be drawn in the editor or generated procedurally.
@@ -326,7 +326,7 @@ Shaders
 
 - *2D:* Custom vertex, fragment, and light shaders.
 - *3D:* Custom vertex, fragment, light, and sky shaders.
-- Text-based shaders using a `shader language inspired by GLSL <doc_shading_language )`.
+- Text-based shaders using a `shader language inspired by GLSL ( doc_shading_language )`.
 - Visual shader editor.
 
    - Support for visual shader plugins.
@@ -338,19 +338,19 @@ Scripting
 
 - Object-oriented design pattern with scripts extending nodes.
 - Signals and groups for communicating between scripts.
-- Support for `cross-language scripting <doc_cross_language_scripting )`.
+- Support for `cross-language scripting ( doc_cross_language_scripting )`.
 - Many 2D and 3D linear algebra data types such as vectors and transforms.
 
-`GDScript: <toc-learn-scripting-gdscript )`
+`GDScript: ( toc-learn-scripting-gdscript )`
 
-- `High-level interpreted language <doc_gdscript )` with
-  `optional static typing <doc_gdscript_static_typing )`.
+- `High-level interpreted language ( doc_gdscript )` with
+  `optional static typing ( doc_gdscript_static_typing )`.
 - Syntax inspired by Python.
 - Syntax highlighting is provided on GitHub.
-- `Use threads <doc_using_multiple_threads )` to perform asynchronous actions
+- `Use threads ( doc_using_multiple_threads )` to perform asynchronous actions
   or make use of multiple processor cores.
 
-`C#: <toc-learn-scripting-C# )`
+`C#: ( toc-learn-scripting-C# )`
 
 - Packaged in a separate binary to keep file sizes and dependencies down.
 - Uses Mono 6.x.
@@ -360,9 +360,9 @@ Scripting
 - Supports all platforms.
 - Using an external editor is recommended to benefit from IDE functionality.
 
-`VisualScript: <toc-learn-scripting-visual_script )`
+`VisualScript: ( toc-learn-scripting-visual_script )`
 
-- `Graph-based visual scripting language <doc_what_is_visual_script )`.
+- `Graph-based visual scripting language ( doc_what_is_visual_script )`.
 - Works best when used for specific purposes (such as level-specific logic)
   rather than as a language to create entire projects.
 
@@ -386,7 +386,7 @@ Scripting
     Future Godot 4.x releases may have VisualScript reimplemented as an extension.
 
     While Godot 3.x will keep VisualScript supported, we recommend
-    `trying out GDScript <toc-learn-scripting-gdscript )` instead,
+    `trying out GDScript ( toc-learn-scripting-gdscript )` instead,
     especially if you intend to migrate your project to Godot 4.
 
 Audio
@@ -399,7 +399,7 @@ Audio
 
    - Optional Doppler effect in 2D and 3D.
 
-- Support for re-routable `audio buses <doc_audio_buses )` and effects
+- Support for re-routable `audio buses ( doc_audio_buses )` and effects
   with dozens of effects included.
 - Listener2D and Listener3D nodes to listen from a position different than the camera.
 - Audio input to record microphones with real-time access using the AudioEffectCapture class.
@@ -416,7 +416,7 @@ Audio
 Import
 ^^^^^^
 
-- Support for `custom import plugins <doc_import_plugins )`.
+- Support for `custom import plugins ( doc_import_plugins )`.
 
 **Formats:**
 
@@ -492,8 +492,8 @@ Internationalization
 ^^^^^^^^^^^^^^^^^^^^
 
 - Full support for Unicode including emoji.
-- Store localization strings using `CSV <doc_internationalizing_games )`
-  or `gettext <doc_localization_using_gettext )`.
+- Store localization strings using `CSV ( doc_internationalizing_games )`
+  or `gettext ( doc_localization_using_gettext )`.
 - Use localized strings in your project automatically in GUI elements or by
   using the `tr()` function.
 - Support for right-to-left typesetting and text shaping planned in Godot 4.0.
@@ -516,10 +516,10 @@ Windowing and OS integration
 - Execute commands in a blocking or non-blocking manner.
 - Open file paths and URLs using default or custom protocol handlers (if registered on the system).
 - Parse custom command line arguments.
-- `Headless/server binaries <doc_exporting_for_dedicated_servers )` can be
-  downloaded for Linux and `compiled for macOS <doc_compiling_for_osx )`.
+- `Headless/server binaries ( doc_exporting_for_dedicated_servers )` can be
+  downloaded for Linux and `compiled for macOS ( doc_compiling_for_osx )`.
   Any binary can be used without a window using the `--no-window`
-  `command line argument <doc_command_line_tutorial )`.
+  `command line argument ( doc_command_line_tutorial )`.
 
 Mobile
 ^^^^^^
@@ -552,7 +552,7 @@ The editor UI can easily be extended in many ways using add-ons.
 - Dropdown menus using PopupMenu and OptionButton.
 - Scrollbars.
 - Labels.
-- RichTextLabel for `text formatted using BBCode <doc_bbcode_in_richtextlabel )`.
+- RichTextLabel for `text formatted using BBCode ( doc_bbcode_in_richtextlabel )`.
 - Trees (can also be used to represent tables).
 - Color picker with RGB and HSV modes.
 - Containers (horizontal, vertical, grid, flow, center, margin, aspect ratio, draggable splitter, ...).
@@ -600,7 +600,7 @@ Animation
 File formats
 ^^^^^^^^^^^^
 
-- Scenes and resources can be saved in `text-based <doc_tscn_file_format )` or binary formats.
+- Scenes and resources can be saved in `text-based ( doc_tscn_file_format )` or binary formats.
 
    - Text-based formats are human-readable and more friendly to version control.
    - Binary formats are faster to save/load for large scenes/resources.
@@ -617,25 +617,25 @@ File formats
 - Read XML files using `XMLParser`.
 - Pack game data into a PCK file (custom format optimized for fast seeking),
   into a ZIP archive, or directly into the executable for single-file distribution.
-- `Export additional PCK files<doc_exporting_pcks )` that can be read
+- `Export additional PCK files( doc_exporting_pcks )` that can be read
   by the engine to support mods and DLCs.
 
 Miscellaneous
 ^^^^^^^^^^^^^
 
-- `Low-level access to servers <doc_using_servers )` which allows bypassing
+- `Low-level access to servers ( doc_using_servers )` which allows bypassing
   the scene tree's overhead when needed.
-- `Command line interface <doc_command_line_tutorial )` for automation.
+- `Command line interface ( doc_command_line_tutorial )` for automation.
 
    - Export and deploy projects using continuous integration platforms.
    - `Shell completion scripts ( https://github.com/godotengine/godot/tree/master/misc/dist/shell )`
      are available for Bash, zsh and fish.
 
-- Support for `C++ modules <doc_custom_modules_in_c++ )` statically linked
+- Support for `C++ modules ( doc_custom_modules_in_c++ )` statically linked
   into the engine binary.
 - Engine and editor written in C++03.
 
-   - Can be `compiled <doc_introduction_to_the_buildsystem )` using GCC,
+   - Can be `compiled ( doc_introduction_to_the_buildsystem )` using GCC,
      Clang and MSVC. MinGW is also supported.
    - Friendly towards packagers. In most cases, system libraries can be used
      instead of the ones provided by Godot. The build system doesn't download anything.
@@ -644,7 +644,7 @@ Miscellaneous
 
 - Licensed under the permissive MIT license.
 
-   - Open developement process with `contributions welcome <doc_ways_to_contribute )`.
+   - Open developement process with `contributions welcome ( doc_ways_to_contribute )`.
 
 .. seealso::
 
diff --git a/about/troubleshooting.md b/about/troubleshooting.md
index 6712aa4..8b086d6 100644
--- a/about/troubleshooting.md
+++ b/about/troubleshooting.md
@@ -81,7 +81,7 @@ done to improve performance, especially on integrated graphics, where rendering
 
 To resolve this, open **Project > Project Settings** and enable **Display >
 Window > Dpi > Allow Hidpi**. On top of that, make sure your project is
-configured to support `multiple resolutions <doc_multiple_resolutions )`.
+configured to support `multiple resolutions ( doc_multiple_resolutions )`.
 
 The project window doesn't appear centered when I run the project.
 ------------------------------------------------------------------
@@ -89,7 +89,7 @@ The project window doesn't appear centered when I run the project.
 This is a `known bug ( https://github.com/godotengine/godot/issues/13017 )`. To
 resolve this, open **Project > Project Settings** and enable **Display > Window
 > Dpi > Allow Hidpi**. On top of that, make sure your project is configured to
-support `multiple resolutions <doc_multiple_resolutions )`.
+support `multiple resolutions ( doc_multiple_resolutions )`.
 
 The project works when run from the editor, but fails to load some files when running from an exported copy.
 ------------------------------------------------------------------------------------------------------------
@@ -102,7 +102,7 @@ project, you need to specify `*.json` in the non-resource export filter. See
 `doc_exporting_projects_export_mode` for more information.
 
 On Windows, this can also be due to `case sensitivity
-<doc_project_organization_case_sensitivity )` issues. If you reference a resource
+( doc_project_organization_case_sensitivity )` issues. If you reference a resource
 in your script with a different case than on the filesystem, loading will fail
 once you export the project. This is because the virtual PCK filesystem is
 case-sensitive, while Windows's filesystem is case-insensitive by default.
diff --git a/community/contributing/bisecting_regressions.md b/community/contributing/bisecting_regressions.md
index 8e8fa08..72a1827 100644
--- a/community/contributing/bisecting_regressions.md
+++ b/community/contributing/bisecting_regressions.md
@@ -59,7 +59,7 @@ reproduce the bug.
 
     Before bisecting a regression, you need to set up a build environment to
     compile Godot from source. To do so, read the
-    `Compiling <toc-devel-compiling )` page for your target platform.
+    `Compiling ( toc-devel-compiling )` page for your target platform.
     (Compiling Godot from source doesn't require C++ programming knowledge.)
 
     Note that compiling Godot can take a while on slow hardware (up an hour for
@@ -88,7 +88,7 @@ following commit hashes depending on the version:
 To refer to the latest state of the master branch, you can use `master`
 instead of a commit hash.
 
-`Get Godot's source code using Git <doc_getting_source )`. Once this
+`Get Godot's source code using Git ( doc_getting_source )`. Once this
 is done, in the terminal window, use `cd` to reach the Godot repository
 folder and enter the following command:
 
diff --git a/community/contributing/class_reference_writing_guidelines.md b/community/contributing/class_reference_writing_guidelines.md
index 9f78f2e..e92fd53 100644
--- a/community/contributing/class_reference_writing_guidelines.md
+++ b/community/contributing/class_reference_writing_guidelines.md
@@ -80,7 +80,7 @@ their documentation by completing or improving the text in these tags:
 - `<constant )`
 
 Write in a clear and simple language. Always follow the `writing guidelines
-<doc_docs_writing_guidelines )` to keep your descriptions short and easy to read.
+( doc_docs_writing_guidelines )` to keep your descriptions short and easy to read.
 **Do not leave empty lines** in the descriptions: each line in the XML file will
 result in a new paragraph, even if it is empty.
 
diff --git a/community/contributing/code_style_guidelines.md b/community/contributing/code_style_guidelines.md
index 02a4e65..4a87b39 100644
--- a/community/contributing/code_style_guidelines.md
+++ b/community/contributing/code_style_guidelines.md
@@ -149,7 +149,7 @@ ones, the following rules should be followed:
   separation.
 - Finally, third-party headers (either from `thirdparty` or from the system's
   include paths) come next and should be included with the < and > symbols, e.g.
-  `#include <png.h )`. The block of third-party headers should also be followed
+  `#include <png.h>`. The block of third-party headers should also be followed
   by an empty line for separation.
 - Godot and third-party headers should be included in the file that requires
   them, i.e. in the `.h` header if used in the declarative code or in the `.cpp`
@@ -344,7 +344,7 @@ Don't repeat what the code says in a comment. Explain the *why* rather than *how
 You can use Javadoc-style comments above function or macro definitions. It's
 recommended to use Javadoc-style comments *only* for methods which are not
 exposed to scripting. This is because exposed methods should be documented in
-the `class reference XML <doc_updating_the_class_reference )`
+the `class reference XML ( doc_updating_the_class_reference )`
 instead.
 
 **Example:**
diff --git a/community/contributing/contributing_to_the_documentation.md b/community/contributing/contributing_to_the_documentation.md
index ce71efe..22cdd80 100644
--- a/community/contributing/contributing_to_the_documentation.md
+++ b/community/contributing/contributing_to_the_documentation.md
@@ -26,7 +26,7 @@ request triggers a rebuild of the online documentation upon merging.
 
 .. warning:: The class reference's source files are in the `Godot engine
              repository ( https://github.com/godotengine/godot )`_. We generate
-             the `Godot API <toc-class-ref )` section of this documentation
+             the `Godot API ( toc-class-ref )` section of this documentation
              from them. If you want to update the description of a class, its
              methods, or properties, read
              `doc_updating_the_class_reference`.
@@ -173,7 +173,7 @@ using this inline markup:
 
 .. code:: rst
 
-   :download:`myfilename.zip <files/myfilename.zip )`
+   :download:`myfilename.zip ( files/myfilename.zip )`
 
 
 License
diff --git a/community/contributing/docs_writing_guidelines.md b/community/contributing/docs_writing_guidelines.md
index 81524dd..46bd51a 100644
--- a/community/contributing/docs_writing_guidelines.md
+++ b/community/contributing/docs_writing_guidelines.md
@@ -34,7 +34,7 @@ There are 3 rules to describe classes:
 
 .. seealso::
 
-    See the `content guidelines <doc_content_guidelines )` for information
+    See the `content guidelines ( doc_content_guidelines )` for information
     on the types of documentation you can write in the official documentation.
 
 7 rules for clear English
diff --git a/community/contributing/documentation_guidelines.md b/community/contributing/documentation_guidelines.md
index e4f1453..4625d15 100644
--- a/community/contributing/documentation_guidelines.md
+++ b/community/contributing/documentation_guidelines.md
@@ -27,7 +27,7 @@ documentation.
 
 .. warning:: The class reference's source files are in the `Godot engine repository
              ( https://github.com/godotengine/godot )`_. We generate the `Godot API
-             <toc-class-ref )` section of this documentation from them. If you want to update the
+             ( toc-class-ref )` section of this documentation from them. If you want to update the
              description of a class, its methods, or properties, read
              `doc_updating_the_class_reference`.
 
diff --git a/community/contributing/editor_and_docs_localization.md b/community/contributing/editor_and_docs_localization.md
index 8622147..b4128d4 100644
--- a/community/contributing/editor_and_docs_localization.md
+++ b/community/contributing/editor_and_docs_localization.md
@@ -258,7 +258,7 @@ external links, etc. Here are some examples::
     # "Have a look here" is a link pointing to https://docs.godotengine.org/en/latest.
     # You should translate "Have a look here", but not the URL, unless there is
     # a matching URL for the same content in your language.
-    # Note: The `, <, >, and _ characters all have a meaning in the hyperlink
+    # Note: The `, ( , >, and _ characters all have a meaning in the hyperlink
     # syntax and should be preserved.
 
     Looking for the documentation of the current **development** branch?
@@ -281,7 +281,7 @@ external links, etc. Here are some examples::
 
     # Or it can be used with an optional custom title, which should thus be translated:
 
-    See `how to contribute <doc_ways_to_contribute )`.
+    See `how to contribute ( doc_ways_to_contribute )`.
 
     # You may encounter other Sphinx roles, such as :kbd: used for shortcut keys.
     # You can translate the content between backticks to match the usual key names,
@@ -328,7 +328,7 @@ breaks if they are not part of the original translation.
 .. seealso::
 
     See our documentation for class reference writers for the `list of
-    BBCode-like tags <doc_class_reference_writing_guidelines_bbcode )` which are used
+    BBCode-like tags ( doc_class_reference_writing_guidelines_bbcode )` which are used
     throughout the class reference.
 
 Offline translation and testing
@@ -357,9 +357,9 @@ upload mode.
     version.
 
 If you want to test changes locally (especially for the editor translation), you
-can use the downloaded PO file and `compile Godot from source <toc-devel-compiling )`.
+can use the downloaded PO file and `compile Godot from source ( toc-devel-compiling )`.
 
-Rename the editor translation PO file to `<lang>.po` (e.g. `eo.po` for
+Rename the editor translation PO file to `( lang>.po` (e.g. `eo.po` for
 Esperanto) and place it in the `editor/translations/` folder
 (`GitHub ( https://github.com/godotengine/godot/tree/master/editor/translations )`).
 
@@ -413,4 +413,4 @@ original image in the `images` subfolder
 and place your translated image there. In our example, the end result should be
 `images/getting_started/step_by_step/img/project_manager_first_open.fr.png)`.
 
-Repeat this for other images and `make a Pull Request <doc_pr_workflow )`.
+Repeat this for other images and `make a Pull Request ( doc_pr_workflow )`.
diff --git a/community/contributing/pr_workflow.md b/community/contributing/pr_workflow.md
index 2b11e9b..c88a0dd 100644
--- a/community/contributing/pr_workflow.md
+++ b/community/contributing/pr_workflow.md
@@ -236,11 +236,11 @@ You will then be back to the original state of your branch before calling
 If you have already created a merge commit without using `rebase`, or
 have made any other changes that have resulted in undesired history, the best option
 is to use an *interactive rebase* on the upstream branch. See the `dedicated
-section <doc_pr_workflow_rebase )` for instructions.
+section ( doc_pr_workflow_rebase )` for instructions.
 
 .. tip:: If at any time you want to *reset* a local branch to a given commit or branch,
-         you can do so with `git reset --hard <commit ID )` or
-         `git reset --hard <remote>/<branch )` (e.g. `git reset --hard upstream/master`).
+         you can do so with `git reset --hard ( commit ID )` or
+         `git reset --hard ( remote>/( branch )` (e.g. `git reset --hard upstream/master`).
 
          Be warned that this will remove any changes that you might have committed in
          this branch. If you ever lose commits by mistake, use the `git reflog` command
@@ -266,12 +266,12 @@ before staging it, while it is staged, and after it has been committed.
 
 - `git diff` will show you the current unstaged changes, i.e. the
   differences between your working directory and the staging area.
-- `git checkout -- <files )` will undo the unstaged changes to the given
+- `git checkout -- ( files )` will undo the unstaged changes to the given
   files.
-- `git add <files )` will *stage* the changes on the listed files.
+- `git add ( files )` will *stage* the changes on the listed files.
 - `git diff --staged` will show the current staged changes, i.e. the
   differences between the staging area and the last commit.
-- `git reset HEAD <files )` will *unstage* changes to the listed files.
+- `git reset HEAD ( files )` will *unstage* changes to the listed files.
 - `git status` will show you what are the currently staged and unstaged
   modifications.
 - `git commit` will commit the staged files. It will open a text editor
@@ -336,7 +336,7 @@ remote branch to share them with the world. The syntax for this is:
 
 ::
 
-    $ git push <remote> <local branch>[:<remote branch>]
+    $ git push ( remote> ( local branch>[:( remote branch>]
 
 The part about the remote branch can be omitted if you want it to have the
 same name as the local branch, which is our case in this example, so we will
diff --git a/community/contributing/testing_pull_requests.md b/community/contributing/testing_pull_requests.md
index 88dd12d..e61433b 100644
--- a/community/contributing/testing_pull_requests.md
+++ b/community/contributing/testing_pull_requests.md
@@ -23,7 +23,7 @@ depending on whether you have a GitHub account or not.
     Due to a GitHub Actions limitation, builds are only available for 90 days
     after the pull request was last updated. If you still wish to try a
     pull request locally, you can
-    `compile the pull request branch from source <doc_testing_pull_requests_compile )`
+    `compile the pull request branch from source ( doc_testing_pull_requests_compile )`
     instead.
 
 If you have a GitHub account
@@ -100,5 +100,5 @@ by Godot's GitHub Actions setup.
 
 ![](img/testing_pull_requests_fork_zip.png)
 
-- Extract the ZIP archive and follow the `compiling <toc-devel-compiling )` instructions
+- Extract the ZIP archive and follow the `compiling ( toc-devel-compiling )` instructions
   for your operating system.
diff --git a/community/contributing/updating_the_class_reference.md b/community/contributing/updating_the_class_reference.md
index 01a5417..33dbb8a 100644
--- a/community/contributing/updating_the_class_reference.md
+++ b/community/contributing/updating_the_class_reference.md
@@ -4,7 +4,7 @@ Contributing to the class reference
 ===================================
 
 
-The class reference is available online in the `classes <toc-class-ref )`
+The class reference is available online in the `classes ( toc-class-ref )`
 section of the documentation and in the Godot editor, from the help menu.
 
 In the class reference, some methods, variables, and signals lack descriptions.
@@ -19,7 +19,7 @@ taking care of a given class.
 
 .. seealso::
 
-    You can find the writing guidelines for the class reference `here <doc_class_reference_writing_guidelines )`.
+    You can find the writing guidelines for the class reference `here ( doc_class_reference_writing_guidelines )`.
 
     For details on Git usage and the pull request workflow, please
     refer to the `doc_pr_workflow` page.
@@ -40,11 +40,11 @@ repository: `doc/classes/
 ( https://github.com/godotengine/godot/tree/master/doc/classes )`_.
 
 .. note:: For some modules in the engine's source code, you'll find the XML
-          files in the `modules/<module_name>/doc_classes/` directory instead.
+          files in the `modules/( module_name>/doc_classes/` directory instead.
 
 .. warning:: Always edit the API reference through these source XML files. Do
              not edit the generated `.rst` files `in the online documentation
-             <toc-class-ref )`, hosted in the `godot-docs
+             ( toc-class-ref )`, hosted in the `godot-docs
              ( https://github.com/godotengine/godot-docs )`_ repository.
 
 .. warning::
diff --git a/community/contributing/ways_to_contribute.md b/community/contributing/ways_to_contribute.md
index d78c2a6..5af8540 100644
--- a/community/contributing/ways_to_contribute.md
+++ b/community/contributing/ways_to_contribute.md
@@ -125,7 +125,7 @@ Testing development versions
 To help with the testing, you have several possibilities:
 
 -  Compile the engine from source yourself, following the instructions of the
-   `Compiling <toc-devel-compiling )` page for your platform.
+   `Compiling ( toc-devel-compiling )` page for your platform.
 
 -  Test official pre-release binaries when they are announced (usually on the
    blog and other community platforms), such as alpha, beta and release candidate (RC) builds.
@@ -197,7 +197,7 @@ There are two separate resources referred to as "documentation" in Godot:
 - **The class reference.** This is the documentation for the complete Godot API
   as exposed to GDScript and the other scripting languages. It can be consulted
   offline, directly in Godot's code editor, or online at `Godot API
-  <toc-class-ref )`. To contribute to the class reference, you have to edit the
+  ( toc-class-ref )`. To contribute to the class reference, you have to edit the
   XML file corresponding to the class and make a pull request.
   See `doc_updating_the_class_reference` and
   `doc_class_reference_writing_guidelines` for more details.
diff --git a/development/compiling/compiling_for_android.md b/development/compiling/compiling_for_android.md
index 5ad521f..aaa0de0 100644
--- a/development/compiling/compiling_for_android.md
+++ b/development/compiling/compiling_for_android.md
@@ -61,13 +61,13 @@ Setting up the buildsystem
 
     ::
 
-        tools/bin/sdkmanager --sdk_root=<android_sdk_path> --licenses
+        tools/bin/sdkmanager --sdk_root=( android_sdk_path> --licenses
 
     -  Complete setup by running the following command where `android_sdk_path` is the path to the Android SDK.
 
     ::
 
-        tools/bin/sdkmanager --sdk_root=<android_sdk_path> "platform-tools" "build-tools;30.0.3" "platforms;android-29" "cmdline-tools;latest" "cmake;3.10.2.4988404"
+        tools/bin/sdkmanager --sdk_root=( android_sdk_path> "platform-tools" "build-tools;30.0.3" "platforms;android-29" "cmdline-tools;latest" "cmake;3.10.2.4988404"
 
 .. seealso::   To set the environment variable on Windows, press :kbd:`Windows + R`, type 
             "control system", then click on **Advanced system settings** in the left
@@ -177,11 +177,11 @@ The newly-compiled templates (`android_debug.apk`
 and `android_release.apk`) must be copied to Godot's templates folder
 with their respective names. The templates folder can be located in:
 
--  Windows: `%APPDATA%\Godot\templates\<version>\`
--  Linux: `$HOME/.local/share/godot/templates/<version>/`
--  macOS: `$HOME/Library/Application Support/Godot/templates/<version>/`
+-  Windows: `%APPDATA%\Godot\templates\( version>\`
+-  Linux: `$HOME/.local/share/godot/templates/( version>/`
+-  macOS: `$HOME/Library/Application Support/Godot/templates/( version>/`
 
-`<version )` is of the form `major.minor[.patch].status` using values from
+`( version )` is of the form `major.minor[.patch].status` using values from
 `version.py` in your Godot source repository (e.g. `3.0.5.stable` or `3.1.dev`).
 You also need to write this same version string to a `version.txt` file located
 next to your export templates.
@@ -208,7 +208,7 @@ Platform doesn't appear in SCons
 Double-check that you've set the `ANDROID_SDK_ROOT`
 environment variable. This is required for the platform to appear in SCons'
 list of detected platforms.
-See `Setting up the buildsystem <doc_android_setting_up_the_buildsystem )`
+See `Setting up the buildsystem ( doc_android_setting_up_the_buildsystem )`
 for more information.
 
 Application not installed
@@ -238,8 +238,8 @@ one of the following reasons:
 
 -  Make sure to use export templates that match your editor version; if
    you use a new Godot version, you *have* to update the templates too.
--  `libgodot_android.so` is not in `libs/<android_arch>/`
-   where `<android_arch )` is the device's architecture.
+-  `libgodot_android.so` is not in `libs/( android_arch>/`
+   where `( android_arch )` is the device's architecture.
 -  The device's architecture does not match the exported one(s).
    Make sure your templates were built for that device's architecture,
    and that the export settings included support for that architecture.
diff --git a/development/compiling/compiling_for_osx.md b/development/compiling/compiling_for_osx.md
index 41a38ca..3e3aabb 100644
--- a/development/compiling/compiling_for_osx.md
+++ b/development/compiling/compiling_for_osx.md
@@ -85,7 +85,7 @@ projects in an automated manner, use::
     scons platform=server tools=yes target=release_debug --jobs=$(sysctl -n hw.logicalcpu)
 
 To compile a debug *server* build which can be used with
-`remote debugging tools <doc_command_line_tutorial )`, use::
+`remote debugging tools ( doc_command_line_tutorial )`, use::
 
     scons platform=server tools=no target=release_debug --jobs=$(sysctl -n hw.logicalcpu)
 
diff --git a/development/compiling/compiling_for_web.md b/development/compiling/compiling_for_web.md
index cfa630e..79efe69 100644
--- a/development/compiling/compiling_for_web.md
+++ b/development/compiling/compiling_for_web.md
@@ -38,7 +38,7 @@ either `release` for a release build or `release_debug` for a debug build::
     scons platform=javascript tools=no target=release
     scons platform=javascript tools=no target=release_debug
 
-By default, the `JavaScript singleton <doc_javascript_eval )` will be built
+By default, the `JavaScript singleton ( doc_javascript_eval )` will be built
 into the engine. Official export templates also have the JavaScript singleton
 enabled. Since `eval()` calls can be a security concern, the
 `javascript_eval` option can be used to build without the singleton::
@@ -65,7 +65,7 @@ Threads and GDNative
 
 The default export templates do not include threads and GDNative support for
 performance and compatibility reasons. See the
-`export page <doc_javascript_export_options )` for more info.
+`export page ( doc_javascript_export_options )` for more info.
 
 You can build the export templates using the option `threads_enabled=yes` or
 `gdnative_enabled=yes` to enable threads or GDNative support::
@@ -104,5 +104,5 @@ Once finished, the resulting file will be placed in the `bin` subdirectory.
 Its name will be `godot.javascript.opt.tools.threads.zip`. You can upload the
 zip content to your web server and visit it with your browser to use the editor.
 
-Refer to the `export page <doc_javascript_export_options )` for the web
+Refer to the `export page ( doc_javascript_export_options )` for the web
 server requirements.
diff --git a/development/compiling/compiling_for_windows.md b/development/compiling/compiling_for_windows.md
index c3058e0..afdb44f 100644
--- a/development/compiling/compiling_for_windows.md
+++ b/development/compiling/compiling_for_windows.md
@@ -273,7 +273,7 @@ with the following flags::
     C:\godot> scons platform=windows tools=no target=release bits=64
 
 If you plan on replacing the standard export templates, copy these to the
-following location, replacing `<version )` with the version identifier
+following location, replacing `( version )` with the version identifier
 (such as `3.1.1.stable` or `3.2.dev`)::
 
     %USERPROFILE%\AppData\Roaming\Godot\templates\<version>\
diff --git a/development/compiling/compiling_for_x11.md b/development/compiling/compiling_for_x11.md
index adee2f2..865d1d3 100644
--- a/development/compiling/compiling_for_x11.md
+++ b/development/compiling/compiling_for_x11.md
@@ -150,7 +150,7 @@ projects in an automated manner, use::
     scons -j8 platform=server tools=yes target=release_debug
 
 To compile a debug *server* build which can be used with
-`remote debugging tools <doc_command_line_tutorial )`, use::
+`remote debugging tools ( doc_command_line_tutorial )`, use::
 
     scons -j8 platform=server tools=no target=release_debug
 
@@ -254,7 +254,7 @@ to get even faster builds.
 
     ln -s ~/.local/opt/pyston/bin/scons ~/.local/bin/pyston-scons
 
-- Instead of running `scons <build arguments )`, run `pyston-scons <build arguments )`
+- Instead of running `scons ( build arguments )`, run `pyston-scons ( build arguments )`
   to compile Godot.
 
 If you can't run `pyston-scons` after creating the symbolic link,
diff --git a/development/compiling/compiling_with_mono.md b/development/compiling/compiling_with_mono.md
index 8620ea1..de92378 100644
--- a/development/compiling/compiling_with_mono.md
+++ b/development/compiling/compiling_with_mono.md
@@ -248,7 +248,7 @@ to the Gradle project.
 
 Once you've built Mono, you can proceed to build Godot with the instructions
 described in this page and the
-`Compiling for Android<doc_compiling_for_android )` page.
+`Compiling for Android( doc_compiling_for_android )` page.
 Make sure to let SCons know about the location of the Mono runtime you've just built, e.g.:
 `scons [...] mono_prefix="$HOME/mono-installs/android-armeabi-v7a-release"`
 (This path may be different on your system).
@@ -258,7 +258,7 @@ Targeting iOS
 
 Once you've built Mono, you can proceed to build Godot with the instructions
 described in this page and the
-`Compiling for iOS<doc_compiling_for_ios )` page.
+`Compiling for iOS( doc_compiling_for_ios )` page.
 Make sure to let SCons know about the location of the Mono runtime you've just built, e.g.:
 `scons [...] mono_prefix="$HOME/mono-installs/ios-arm64-release"`
 (This path may be different on your system).
@@ -307,7 +307,7 @@ Building for WebAssembly currently involves the same process regardless of wheth
 
 Once you've built Mono, you can proceed to build Godot with the instructions
 described in this page and the
-`Compiling for the Web<doc_compiling_for_web )` page.
+`Compiling for the Web( doc_compiling_for_web )` page.
 Make sure to let SCons know about the location of the Mono runtime you've just built, e.g.:
 `scons [...] mono_prefix="$HOME/mono-installs/wasm-runtime-release"`
 (This path may be different on your system).
diff --git a/development/compiling/getting_source.md b/development/compiling/getting_source.md
index ab7e2bd..2161735 100644
--- a/development/compiling/getting_source.md
+++ b/development/compiling/getting_source.md
@@ -7,7 +7,7 @@ Getting the source
 Downloading the Godot source code
 ---------------------------------
 
-Before `getting into the SCons build system <doc_introduction_to_the_buildsystem )`
+Before `getting into the SCons build system ( doc_introduction_to_the_buildsystem )`
 and compiling Godot, you need to actually download the Godot source code.
 
 The source code is available on `GitHub ( https://github.com/godotengine/godot )`
@@ -15,7 +15,7 @@ and while you can manually download it via the website, in general you want to
 do it via the `git` version control system.
 
 If you are compiling in order to make contributions or pull requests, you should
-follow the instructions from the `Pull Request workflow <doc_pr_workflow )`.
+follow the instructions from the `Pull Request workflow ( doc_pr_workflow )`.
 
 If you don't know much about `git` yet, there are a great number of
 `tutorials ( https://git-scm.com/book )` available on various websites.
@@ -50,4 +50,4 @@ after the `--branch` (or just `-b`) argument::
 There are also generally branches besides `master` for each major version.
 
 After downloading the Godot source code,
-you can `continue to compiling Godot <doc_introduction_to_the_buildsystem )`.
+you can `continue to compiling Godot ( doc_introduction_to_the_buildsystem )`.
diff --git a/development/compiling/optimizing_for_size.md b/development/compiling/optimizing_for_size.md
index 7d603d7..642400e 100644
--- a/development/compiling/optimizing_for_size.md
+++ b/development/compiling/optimizing_for_size.md
@@ -39,7 +39,7 @@ On Windows, `strip.exe` is included in most MinGW toolchain setups.
 This will reduce the size of compiled binaries by a factor between 5× and 10×.
 The downside is that crash backtraces will no longer provide accurate information
 (which is useful for troubleshooting the cause of a crash).
-`C++ profilers <doc_using_cpp_profilers )` will also no longer be able to display
+`C++ profilers ( doc_using_cpp_profilers )` will also no longer be able to display
 function names (this does not affect the built-in GDScript profiler).
 
 .. note::
diff --git a/development/cpp/configuring_an_ide/clion.md b/development/cpp/configuring_an_ide/clion.md
index 6073c9c..1aef5df 100644
--- a/development/cpp/configuring_an_ide/clion.md
+++ b/development/cpp/configuring_an_ide/clion.md
@@ -11,7 +11,7 @@ Importing the project
 
 CLion requires a `CMakeLists.txt` file as a project file, which is problematic
 for Godot because it uses the SCons buildsystem instead of CMake. However, 
-there is a `CMakeLists.txt` configuration for `Android Studio <doc_configuring_an_ide_android_studio )` 
+there is a `CMakeLists.txt` configuration for `Android Studio ( doc_configuring_an_ide_android_studio )` 
 which can also be used by CLion.
 
 - From the CLion's welcome window choose the option to import an existing 
diff --git a/development/cpp/configuring_an_ide/qt_creator.md b/development/cpp/configuring_an_ide/qt_creator.md
index 5e58ee8..0d232dc 100644
--- a/development/cpp/configuring_an_ide/qt_creator.md
+++ b/development/cpp/configuring_an_ide/qt_creator.md
@@ -85,12 +85,12 @@ Debugging the project
    :align: center
 
 To learn more about command line arguments, refer to the
-`command line tutorial <doc_command_line_tutorial )`.
+`command line tutorial ( doc_command_line_tutorial )`.
 
 Code style configuration
 ------------------------
 
-Developers must follow the project's `code style <doc_code_style_guidelines )`
+Developers must follow the project's `code style ( doc_code_style_guidelines )`
 and the IDE should help them follow it. By default, Qt Creator uses spaces
 for indentation which doesn't match the Godot code style guidelines. You can
 change this behavior by changing the **Code Style** in **Tools > Options > C++**.
diff --git a/development/cpp/configuring_an_ide/visual_studio.md b/development/cpp/configuring_an_ide/visual_studio.md
index 9fff915..1c2a554 100644
--- a/development/cpp/configuring_an_ide/visual_studio.md
+++ b/development/cpp/configuring_an_ide/visual_studio.md
@@ -53,7 +53,7 @@ project manager opens a project, the initial process is terminated and the debug
    :align: center
 
 To learn more about command line arguments, refer to the
-`command line tutorial <doc_command_line_tutorial )`.
+`command line tutorial ( doc_command_line_tutorial )`.
 
 Even if you start the project without a debugger attached it can still be connected to the running
 process using **Debug > Attach to Process...** menu.
diff --git a/development/cpp/custom_godot_servers.md b/development/cpp/custom_godot_servers.md
index e2ce774..c145ec6 100644
--- a/development/cpp/custom_godot_servers.md
+++ b/development/cpp/custom_godot_servers.md
@@ -315,7 +315,7 @@ object-oriented C code.
 References
 ~~~~~~~~~~~
 
-- `RID<class_rid )`
+- `RID( rid )`
 - `core/rid.h ( https://github.com/godotengine/godot/blob/3.x/core/rid.h )`
 
 Registering the class in GDScript
diff --git a/development/cpp/custom_modules_in_cpp.md b/development/cpp/custom_modules_in_cpp.md
index c2539e8..2ad494a 100644
--- a/development/cpp/custom_modules_in_cpp.md
+++ b/development/cpp/custom_modules_in_cpp.md
@@ -303,7 +303,7 @@ and compile them accordingly, including our "summator" module.
 
 .. seealso::
 
-    `Introduction to the buildsystem - Custom modules build option <doc_buildsystem_custom_modules )`.
+    `Introduction to the buildsystem - Custom modules build option ( doc_buildsystem_custom_modules )`.
 
 Improving the build system for development
 ------------------------------------------
@@ -312,7 +312,7 @@ Improving the build system for development
 
     This shared library support is not designed to support distributing a module
     to other users without recompiling the engine. For that purpose, use
-    `GDNative <doc_what_is_gdnative )` instead.
+    `GDNative ( doc_what_is_gdnative )` instead.
 
 So far, we defined a clean SCsub that allows us to add the sources
 of our new module as part of the Godot binary.
diff --git a/development/cpp/custom_resource_format_loaders.md b/development/cpp/custom_resource_format_loaders.md
index 49492bc..6bc4fab 100644
--- a/development/cpp/custom_resource_format_loaders.md
+++ b/development/cpp/custom_resource_format_loaders.md
@@ -17,7 +17,7 @@ data types. If not, refer to this guide `doc_custom_modules_in_c++`.
 References
 ~~~~~~~~~~
 
-- `ResourceLoader<class_resourceloader )`
+- `ResourceLoader( resourceloader )`
 - `core/io/resource_loader.cpp ( https://github.com/godotengine/godot/blob/master/core/io/resource_loader.cpp )`_
 
 What for?
diff --git a/development/editor/creating_icons.md b/development/editor/creating_icons.md
index 2391cca..0809428 100644
--- a/development/editor/creating_icons.md
+++ b/development/editor/creating_icons.md
@@ -86,7 +86,7 @@ make a separate pull request for your icons to be available within the editor
 as they can be self-contained.
 
 For specific instructions on how to create module icons, refer to
-`Creating custom module icons<doc_custom_module_icons )`.
+`Creating custom module icons( doc_custom_module_icons )`.
 
 Troubleshooting
 ~~~~~~~~~~~~~~~
diff --git a/development/editor/introduction_to_editor_development.md b/development/editor/introduction_to_editor_development.md
index 04ac438..0ced323 100644
--- a/development/editor/introduction_to_editor_development.md
+++ b/development/editor/introduction_to_editor_development.md
@@ -37,7 +37,7 @@ The editor's code is fully self-contained in the
 of the Godot source repository.
 
 Some editor functionality is also implemented via
-`modules <doc_custom_modules_in_c++ )`. Some of these are only enabled in
+`modules ( doc_custom_modules_in_c++ )`. Some of these are only enabled in
 editor builds to decrease the binary size of export templates. See the
 `modules/ ( https://github.com/godotengine/godot/tree/master/modules )` folder
 in the Godot source repository.
@@ -83,6 +83,6 @@ Development tips
 ----------------
 
 To iterate quickly on the editor, we recommend to set up a test project and
-`open it from the command line <doc_command_line_tutorial )` after compiling
+`open it from the command line ( doc_command_line_tutorial )` after compiling
 the editor. This way, you don't have to go through the project manager every
 time you start Godot.
diff --git a/getting_started/first_2d_game/02.player_scene.md b/getting_started/first_2d_game/02.player_scene.md
index 48acfa2..c8a429c 100644
--- a/getting_started/first_2d_game/02.player_scene.md
+++ b/getting_started/first_2d_game/02.player_scene.md
@@ -16,7 +16,7 @@ Node structure
 To begin, we need to choose a root node for the player object. As a general
 rule, a scene's root node should reflect the object's desired functionality -
 what the object *is*. Click the "Other Node" button and add an `Area2D
-<class_Area2D )` node to the scene.
+( Area2D )` node to the scene.
 
 ![](img/add_node.png)
 
@@ -54,10 +54,10 @@ Sprite animation
 ~~~~~~~~~~~~~~~~
 
 Click on the `Player` node and add an `AnimatedSprite
-<class_AnimatedSprite )` node as a child. The `AnimatedSprite` will handle the
+( AnimatedSprite )` node as a child. The `AnimatedSprite` will handle the
 appearance and animations for our player. Notice that there is a warning symbol
 next to the node. An `AnimatedSprite` requires a `SpriteFrames
-<class_SpriteFrames )` resource, which is a list of the animations it can
+( SpriteFrames )` resource, which is a list of the animations it can
 display. To create one, find the `Frames` property in the Inspector and click
 "[empty]" -> "New SpriteFrames". Click again to open the "SpriteFrames" panel:
 
diff --git a/getting_started/first_2d_game/06.heads_up_display.md b/getting_started/first_2d_game/06.heads_up_display.md
index b6e597f..4561045 100644
--- a/getting_started/first_2d_game/06.heads_up_display.md
+++ b/getting_started/first_2d_game/06.heads_up_display.md
@@ -22,7 +22,7 @@ The HUD needs to display the following information:
 
 The basic node for UI elements is `Control`. To create our
 UI, we'll use two types of `Control` nodes: `Label
-<class_Label )` and `Button`.
+( Label )` and `Button`.
 
 Create the following as children of the `HUD` node:
 
diff --git a/getting_started/first_3d_game/06.jump_and_squash.md b/getting_started/first_3d_game/06.jump_and_squash.md
index 39682d7..1ba2178 100644
--- a/getting_started/first_3d_game/06.jump_and_squash.md
+++ b/getting_started/first_3d_game/06.jump_and_squash.md
@@ -8,7 +8,7 @@ lesson, we'll make the player die when a monster hits them on the ground.
 
 First, we have to change a few settings related to physics interactions. Enter
 the world of `physics layers
-<doc_physics_introduction_collision_layers_and_masks )`.
+( doc_physics_introduction_collision_layers_and_masks )`.
 
 Controlling physics interactions
 --------------------------------
@@ -156,7 +156,7 @@ over monsters and kill them at the same time.
 
 We need to detect collisions with a monster and to differentiate them from
 collisions with the floor. To do so, we can use Godot's `group
-<doc_groups )` tagging feature.
+( doc_groups )` tagging feature.
 
 Open the scene `Mob.tscn` again and select the *Mob* node. Go to the *Node*
 dock on the right to see a list of signals. The *Node* dock has two tabs:
@@ -224,18 +224,18 @@ gdscript GDScript
  That's a lot of new functions. Here's some more information about them.
 
 The functions `get_slide_count()` and `get_slide_collision()` both come from
-the `KinematicBody<class_KinematicBody )` class and are related to
+the `KinematicBody( KinematicBody )` class and are related to
 `move_and_slide()`.
 
 `get_slide_collision()` returns a
-`KinematicCollision<class_KinematicCollision )` object that holds
+`KinematicCollision( KinematicCollision )` object that holds
 information about where and how the collision occurred. For example, we use its
 `collider` property to check if we collided with a "mob" by calling
 `is_in_group()` on it: `collision.collider.is_in_group("mob")`.
 
 .. note::
 
-    The method `is_in_group()` is available on every `Node<class_Node )`.
+    The method `is_in_group()` is available on every `Node( Node )`.
 
 To check that we are landing on the monster, we use the vector dot product:
 `Vector3.UP.dot(collision.normal) > 0.1`. The collision normal is a 3D vector
diff --git a/getting_started/first_3d_game/08.score_and_replay.md b/getting_started/first_3d_game/08.score_and_replay.md
index 5daea02..309c34a 100644
--- a/getting_started/first_3d_game/08.score_and_replay.md
+++ b/getting_started/first_3d_game/08.score_and_replay.md
@@ -262,14 +262,14 @@ gdscript GDScript
 ```
 
 The function `get_tree()` gives us access to the global `SceneTree
-<class_SceneTree )` object, which allows us to reload and restart the current
+( SceneTree )` object, which allows us to reload and restart the current
 scene.
 
 Adding music
 ------------
 
 To add music that plays continuously in the background, we're going to use
-another feature in Godot: `autoloads <doc_singletons_autoload )`.
+another feature in Godot: `autoloads ( doc_singletons_autoload )`.
 
 To play audio, all you need to do is add an *AudioStreamPlayer* node to your
 scene and attach an audio file to it. When you start the scene, it can play
diff --git a/getting_started/first_3d_game/going_further.md b/getting_started/first_3d_game/going_further.md
index cb200a7..705e240 100644
--- a/getting_started/first_3d_game/going_further.md
+++ b/getting_started/first_3d_game/going_further.md
@@ -29,11 +29,11 @@ information about 2D, 3D, physics, rendering and performance, and much more.
 
 Here are the sections we recommend you to explore next:
 
-1. Read the `Scripting section <toc-scripting-core-features )` to learn essential programming features you’ll use
+1. Read the `Scripting section ( toc-scripting-core-features )` to learn essential programming features you’ll use
    in every project.
-2. The `3D <toc-learn-features-3d )` and `Physics <toc-learn-features-physics )` sections will teach you more about 3D game creation in the
+2. The `3D ( toc-learn-features-3d )` and `Physics ( toc-learn-features-physics )` sections will teach you more about 3D game creation in the
    engine.
-3. `Inputs <toc-learn-features-inputs )` is another important one for any game project.
+3. `Inputs ( toc-learn-features-inputs )` is another important one for any game project.
 
 You can start with these or, if you prefer, look at the sidebar menu on the left
 and pick your options.
diff --git a/getting_started/introduction/first_look_at_the_editor.md b/getting_started/introduction/first_look_at_the_editor.md
index 6850d07..cce18d6 100644
--- a/getting_started/introduction/first_look_at_the_editor.md
+++ b/getting_started/introduction/first_look_at_the_editor.md
@@ -13,7 +13,7 @@ This page will give you a brief overview of Godot's interface. We're going to
 look at the different main screens and docks to help you situate yourself.
 
 .. seealso:: For a comprehensive breakdown of the editor's interface and how to
-             use it, see the `Editor manual <toc-learn-editor )`.
+             use it, see the `Editor manual ( toc-learn-editor )`.
 
 The Project manager
 -------------------
diff --git a/getting_started/introduction/introduction_to_godot.md b/getting_started/introduction/introduction_to_godot.md
index 1cb7564..0f56724 100644
--- a/getting_started/introduction/introduction_to_godot.md
+++ b/getting_started/introduction/introduction_to_godot.md
@@ -90,7 +90,7 @@ completely free and open-source.
 .. seealso:: These are the five officially supported programming languages. The
              community maintains support for many more. For more information,
              see `GDNative third-party bindings
-             <doc_what_is_gdnative_third_party_bindings )`.
+             ( doc_what_is_gdnative_third_party_bindings )`.
 
 What do I need to know to use Godot?
 ------------------------------------
diff --git a/getting_started/step_by_step/instancing.md b/getting_started/step_by_step/instancing.md
index 14e2b74..c58b495 100644
--- a/getting_started/step_by_step/instancing.md
+++ b/getting_started/step_by_step/instancing.md
@@ -14,7 +14,7 @@ the previous lesson was an example. We call those files "Packed Scenes" as they
 pack information about your scene's content.
 
 Here's an example of a ball. It's composed of a `RigidBody2D
-<class_RigidBody2D )` node as its root named Ball, which allows the ball to fall
+( RigidBody2D )` node as its root named Ball, which allows the ball to fall
 and bounce on walls, a `Sprite` node, and a
 `CollisionShape2D`.
 
diff --git a/getting_started/step_by_step/scripting_first_script.md b/getting_started/step_by_step/scripting_first_script.md
index 8dd9453..b47d4e2 100644
--- a/getting_started/step_by_step/scripting_first_script.md
+++ b/getting_started/step_by_step/scripting_first_script.md
@@ -26,9 +26,9 @@ The equivalent C# code has been included in another tab for convenience.
 ![](img/scripting_first_script_rotating_godot.gif)
 
 .. seealso:: To learn more about GDScript, its keywords, and its syntax, head to
-             the `GDScript reference<doc_gdscript )`.
+             the `GDScript reference( doc_gdscript )`.
 
-.. seealso:: To learn more about C#, head to the `C# basics <doc_c_sharp )` page.
+.. seealso:: To learn more about C#, head to the `C# basics ( doc_c_sharp )` page.
 
 Project setup
 -------------
diff --git a/getting_started/step_by_step/scripting_languages.md b/getting_started/step_by_step/scripting_languages.md
index dc9c0af..9fadbeb 100644
--- a/getting_started/step_by_step/scripting_languages.md
+++ b/getting_started/step_by_step/scripting_languages.md
@@ -25,7 +25,7 @@ Available scripting languages
 
 Godot offers **five gameplay programming languages**: GDScript, C#,
 VisualScript, and, via its GDNative technology, C and C++. There are more
-`community-supported languages <doc_what_is_gdnative_third_party_bindings )`,
+`community-supported languages ( doc_what_is_gdnative_third_party_bindings )`,
 but these are the official ones.
 
 You can use multiple languages in a single project. For instance, in a team, you
@@ -68,7 +68,7 @@ Let's look at each language's features, as well as its pros and cons.
 GDScript
 ~~~~~~~~
 
-`GDScript<doc_gdscript )` is an
+`GDScript( doc_gdscript )` is an
 `object-oriented ( https://en.wikipedia.org/wiki/Object-oriented_programming )`_ and
 `imperative ( https://en.wikipedia.org/wiki/Imperative_programming )`_
 programming language built for Godot. It's made by and for game developers
@@ -149,7 +149,7 @@ VisualScript
     `trying out GDScript <toc-learn-scripting-gdscript )` instead,
     especially if you intend to migrate your project to Godot 4.
 
-`Visual Scripting<doc_what_is_visual_script )` is a graph-based visual
+`Visual Scripting( doc_what_is_visual_script )` is a graph-based visual
 programming language where you connect blocks. It can be a great tool for
 non-programmers like game designers and artists.
 
@@ -166,7 +166,7 @@ is slow compared to using other programming languages.
 .. seealso::
 
     For more information, see
-    `Getting started with VisualScript <doc_getting_started_visual_script )`.
+    `Getting started with VisualScript ( doc_getting_started_visual_script )`.
 
 C and C++ via GDNative
 ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/getting_started/step_by_step/signals.md b/getting_started/step_by_step/signals.md
index 24a0475..fcc8dfc 100644
--- a/getting_started/step_by_step/signals.md
+++ b/getting_started/step_by_step/signals.md
@@ -142,7 +142,7 @@ node's motion.
 
 Our Sprite moves thanks to code in the `_process()` function. Godot provides a
 method to toggle processing on and off: `Node.set_process()
-<class_Node_method_set_process )`. Another method of the Node class,
+( Node_method_set_process )`. Another method of the Node class,
 `is_processing()`, returns `true` if idle processing is active. We can use
 the `not` keyword to invert the value.
 
diff --git a/index.md b/index.md
index dda4b6e..c233f7d 100644
--- a/index.md
+++ b/index.md
@@ -31,7 +31,7 @@ Godot Docs – *3.5* branch
 Welcome to the official documentation of `Godot Engine ( https://godotengine.org )`,
 the free and open source community-driven 2D and 3D game engine! If you are new
 to this documentation, we recommend that you read the
-`introduction page <doc_about_intro )` to get an overview of what this
+`introduction page ( doc_about_intro )` to get an overview of what this
 documentation has to offer.
 
 The table of contents below and in the sidebar should let you easily access the
diff --git a/tutorials/2d/2d_lights_and_shadows.md b/tutorials/2d/2d_lights_and_shadows.md
index 63835e8..618bd09 100644
--- a/tutorials/2d/2d_lights_and_shadows.md
+++ b/tutorials/2d/2d_lights_and_shadows.md
@@ -51,7 +51,7 @@ The demo uses four different nodes:
   * `Light2D`
   * `LightOccluder2D`
 
-`CanvasModulate<class_CanvasModulate )` is used to darken the scene.
+`CanvasModulate( CanvasModulate )` is used to darken the scene.
 
 `Sprites` are used to display the textures for the light blobs, the
 background, and for the shadow casters.
diff --git a/tutorials/2d/2d_movement.md b/tutorials/2d/2d_movement.md
index ed32b83..5256cb5 100644
--- a/tutorials/2d/2d_movement.md
+++ b/tutorials/2d/2d_movement.md
@@ -23,7 +23,7 @@ children: `Sprite` and `CollisionShape2D`. You can use the Godot icon ("icon.png
 for the Sprite's texture or use any other 2D image you have.
 
 Open `Project -> Project Settings` and select the "Input Map" tab. Add the following
-input actions (see `InputEvent <doc_inputevent )` for details):
+input actions (see `InputEvent ( doc_inputevent )` for details):
 
 ![](img/movement_inputs.png)
 
diff --git a/tutorials/2d/2d_sprite_animation.md b/tutorials/2d/2d_sprite_animation.md
index b9bf72f..90690b9 100644
--- a/tutorials/2d/2d_sprite_animation.md
+++ b/tutorials/2d/2d_sprite_animation.md
@@ -40,7 +40,7 @@ with the following nodes:
           `RigidBody2D`. The animation will still be
           made in the same way. Once the animation is completed, you can
           assign a shape to the CollisionShape2D. See
-          `Physics Introduction <doc_physics_introduction )` for more
+          `Physics Introduction ( doc_physics_introduction )` for more
           information.
 
 Now select the `AnimatedSprite` and in its *SpriteFrames* property, select
@@ -147,7 +147,7 @@ setting up your scene tree:
           `RigidBody2D`. The animation will still be
           made in the same way. Once the animation is completed, you can
           assign a shape to the CollisionShape2D. See
-          `Physics Introduction <doc_physics_introduction )` for more
+          `Physics Introduction ( doc_physics_introduction )` for more
           information.
 
 Drag the spritesheet into the Sprite's *Texture* property, and you'll see the
diff --git a/tutorials/2d/2d_transforms.md b/tutorials/2d/2d_transforms.md
index 9a99d50..ef55271 100644
--- a/tutorials/2d/2d_transforms.md
+++ b/tutorials/2d/2d_transforms.md
@@ -21,7 +21,7 @@ can be accessed as a `Transform2D`.
 
 Also covered in the previous tutorial, nodes are drawn by default in Layer 0,
 in the built-in canvas. To put nodes in a different layer, a `CanvasLayer
-<class_CanvasLayer )` node can be used.
+( CanvasLayer )` node can be used.
 
 Global canvas transform
 -----------------------
diff --git a/tutorials/2d/custom_drawing_in_2d.md b/tutorials/2d/custom_drawing_in_2d.md
index 184ffb5..9436ed5 100644
--- a/tutorials/2d/custom_drawing_in_2d.md
+++ b/tutorials/2d/custom_drawing_in_2d.md
@@ -308,11 +308,11 @@ Let's run again! This time, the rotation displays fine!
 Antialiased drawing
 ^^^^^^^^^^^^^^^^^^^
 
-Godot offers method parameters in `draw_line<class_CanvasItem_method_draw_line )`
+Godot offers method parameters in `draw_line( CanvasItem_method_draw_line )`
 to enable antialiasing, but it doesn't work reliably in all situations
 (for instance, on mobile/web platforms, or when HDR is enabled).
 There is also no `antialiased` parameter available in
-`draw_polygon<class_CanvasItem_method_draw_polygon )`.
+`draw_polygon( CanvasItem_method_draw_polygon )`.
 
 As a workaround, install and use the
 `Antialiased Line2D add-on ( https://github.com/godot-extended-libraries/godot-antialiased-line2d )`
diff --git a/tutorials/3d/3d_text.md b/tutorials/3d/3d_text.md
index 4e957e3..b0f7789 100644
--- a/tutorials/3d/3d_text.md
+++ b/tutorials/3d/3d_text.md
@@ -30,7 +30,7 @@ up and shaded by light sources if the shaded flag is enabled, but it
 will not cast a shadow, even with cast shadow turned on under the nodes
 GeometryInstance3D settings. This is because the node is a quad mesh
 (one glyph per quad) with transparent textures and has the same limitations
-as Sprite3D. See `this page <doc_3d_rendering_limitations_transparency_sorting )`
+as Sprite3D. See `this page ( doc_3d_rendering_limitations_transparency_sorting )`
 for more information.
 
 Text mesh
diff --git a/tutorials/3d/baked_lightmaps.md b/tutorials/3d/baked_lightmaps.md
index fa9ede1..3214dbe 100644
--- a/tutorials/3d/baked_lightmaps.md
+++ b/tutorials/3d/baked_lightmaps.md
@@ -333,7 +333,7 @@ Capture
 - **Quality:** The lightmap probe generation quality. Higher values result in
   more accurate lighting, but take longer to bake. This setting does not affect
   the *density* of the lightmap probes, only their quality.
-- **Propagation:** Similar to `GIProbe <doc_gi_probes )`'s Propagation property.
+- **Propagation:** Similar to `GIProbe ( doc_gi_probes )`'s Propagation property.
   Higher values result in brighter and more diffuse indirect lighting for
   dynamic objects. Adjust this value depending on your scene to make dynamic
   objects better fit with static baked lighting.
diff --git a/tutorials/3d/portals/advanced_room_and_portal_usage.md b/tutorials/3d/portals/advanced_room_and_portal_usage.md
index 9b997e2..19cdeff 100644
--- a/tutorials/3d/portals/advanced_room_and_portal_usage.md
+++ b/tutorials/3d/portals/advanced_room_and_portal_usage.md
@@ -17,7 +17,7 @@ This works because if a monster is in an area that is completely out of view for
 How does a monster know whether it is within the gameplay area?
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-This problem is solved because the portal system contains a subsystem called the **Gameplay Monitor** that can be turned on and off from the `RoomManager<class_RoomManager )`. When switched on, any roaming objects that move inside or outside the gameplay area (whether by moving themselves, or the camera moving) will receive callbacks to let them know of this change.
+This problem is solved because the portal system contains a subsystem called the **Gameplay Monitor** that can be turned on and off from the `RoomManager( RoomManager )`. When switched on, any roaming objects that move inside or outside the gameplay area (whether by moving themselves, or the camera moving) will receive callbacks to let them know of this change.
 
 You can choose to either receive these callbacks as `signals`, or as `notifications`.
 
@@ -41,7 +41,7 @@ VisbilityNotifiers / VisibilityEnablers
 
 Gameplay callbacks have one more useful function. By default in Godot, animation and physics are still processed regardless of whether an object is within view. This can sap performance, especially when using software skinning.
 
-The engine's solution to this problem is the `VisibilityNotifier<class_VisibilityNotifier )` node, and its slightly easier to use variation, the `VisibilityEnabler<class_VisibilityEnabler )` node. VisibilityEnabler can be used to switch off animation and sleep physics when an object is outside the view frustum. You do this by simply placing a VisibilityEnabler node in your subscene (for e.g. a monster). It will do the rest. Consult the `VisibilityEnabler<class_VisibilityEnabler )` documentation for full details.
+The engine's solution to this problem is the `VisibilityNotifier( VisibilityNotifier )` node, and its slightly easier to use variation, the `VisibilityEnabler( VisibilityEnabler )` node. VisibilityEnabler can be used to switch off animation and sleep physics when an object is outside the view frustum. You do this by simply placing a VisibilityEnabler node in your subscene (for e.g. a monster). It will do the rest. Consult the `VisibilityEnabler( VisibilityEnabler )` documentation for full details.
 
 ![](img/visibility_enabler.png)
 
@@ -52,11 +52,11 @@ What if the VisibilityEnabler could turn off objects when they were occlusion cu
 RoomGroups
 ~~~~~~~~~~
 
-A `RoomGroup<class_RoomGroup )` is a special node which allows you to deal with a group of rooms at once, instead of having write code for them individually. This is especially useful in conjunction with gameplay callbacks. The most important use for RoomGroups is to delineate between "inside" and "outside" areas.
+A `RoomGroup( RoomGroup )` is a special node which allows you to deal with a group of rooms at once, instead of having write code for them individually. This is especially useful in conjunction with gameplay callbacks. The most important use for RoomGroups is to delineate between "inside" and "outside" areas.
 
 ![](img/roomgroups.png)
 
-For instance, when outside you may wish to use a `DirectionalLight<class_DirectionalLight )` to represent the sun. When the outside RoomGroup receives an `enter gameplay` callback, you can turn the light on, and you can turn it off when the RoomGroup exits gameplay. With the light off, performance will increase as there is no need to render it indoors.
+For instance, when outside you may wish to use a `DirectionalLight( DirectionalLight )` to represent the sun. When the outside RoomGroup receives an `enter gameplay` callback, you can turn the light on, and you can turn it off when the RoomGroup exits gameplay. With the light off, performance will increase as there is no need to render it indoors.
 
 This is an example of a simple RoomGroup script to turn on and off a DirectionalLight. Note that you can also use signals for callbacks (the choice is up to you):
 
diff --git a/tutorials/3d/portals/editing_rooms_and_portals.md b/tutorials/3d/portals/editing_rooms_and_portals.md
index a3b1bf4..0661328 100644
--- a/tutorials/3d/portals/editing_rooms_and_portals.md
+++ b/tutorials/3d/portals/editing_rooms_and_portals.md
@@ -8,9 +8,9 @@ Putting all the ideas together, here is an example scene tree:
 
 ![](img/example_scenetree.png)
 
-- We have used a `RoomGroup<class_RoomGroup )` to denote an outside area.
-- The `MeshInstance<class_MeshInstance )`\ s inside the `Room<class_Room )`\ s are either `STATIC` or `DYNAMIC`.
-- We have created a `Spatial<class_Spatial )` (I decided to call it 'Freeform', but you could use any name) under which to place `STATIC` and `DYNAMIC` objects that will be autoplaced in rooms
+- We have used a `RoomGroup( RoomGroup )` to denote an outside area.
+- The `MeshInstance( MeshInstance )`\ s inside the `Room( Room )`\ s are either `STATIC` or `DYNAMIC`.
+- We have created a `Spatial( Spatial )` (I decided to call it 'Freeform', but you could use any name) under which to place `STATIC` and `DYNAMIC` objects that will be autoplaced in rooms
   (Freeform is inside the `roomlist`, but *not* inside a room.)
 - The player and the monsters are on branches *OUTSIDE* the `roomlist`.
 - The player and monster meshes have portal mode `ROAMING` so they can be in any room.
@@ -26,9 +26,9 @@ Although you can create your room system entirely within the editor, you can als
 Postfix convention
 ^^^^^^^^^^^^^^^^^^
 
-- `-room` becomes a `Room<class_Room )`.
-- `-roomgroup` becomes a `RoomGroup<class_RoomGroup )`.
-- `-portal` becomes a `Portal<class_Portal )`.
+- `-room` becomes a `Room( Room )`.
+- `-roomgroup` becomes a `RoomGroup( RoomGroup )`.
+- `-portal` becomes a `Portal( Portal )`.
 - `-bound` becomes a manual bound.
 
 Rooms and RoomGroups should be created as Empties within Blender. Any mesh children of the `-room` Empty will thus be placed in the Room during conversion in Godot.
@@ -44,7 +44,7 @@ Portals
 
 Portals are different from Rooms. In Portals, we need to specify the geometry of the Portal in our modelling tool, in addition to just the name. To do this your "portal-to-be" should be created as a Mesh.
 
-Portal meshes have some restrictions to work properly. They must be convex, and the polygon points should be in the same plane. The accuracy to the plane does not have to be exact, as Godot will automatically average the direction of the portal plane. Once converted to a `Portal<class_Portal )` node, the snapping to the portal plane is enforced, and the vertices are specified (and editable) as 2D coordinates in the inspector, rather than 3D points.
+Portal meshes have some restrictions to work properly. They must be convex, and the polygon points should be in the same plane. The accuracy to the plane does not have to be exact, as Godot will automatically average the direction of the portal plane. Once converted to a `Portal( Portal )` node, the snapping to the portal plane is enforced, and the vertices are specified (and editable) as 2D coordinates in the inspector, rather than 3D points.
 
 The portal's naming is quite important. You can either name the portal `-portal` which will attempt to autolink the Portal in Godot, or you can use the name of the Room you wish to link the Portal to as a prefix.
 
diff --git a/tutorials/3d/portals/first_steps_with_rooms_and_portals.md b/tutorials/3d/portals/first_steps_with_rooms_and_portals.md
index 2d31424..761be42 100644
--- a/tutorials/3d/portals/first_steps_with_rooms_and_portals.md
+++ b/tutorials/3d/portals/first_steps_with_rooms_and_portals.md
@@ -4,7 +4,7 @@ First steps with Rooms and Portals
 The RoomManager
 ~~~~~~~~~~~~~~~
 
-Anytime you want to use the portal system, you need to include a special node in your scene tree, called the `RoomManager<class_RoomManager )`. The RoomManager is responsible for the runtime maintenance of the system, especially converting the objects in your rooms into a *room graph* which is used at runtime to perform occlusion culling and other tasks.
+Anytime you want to use the portal system, you need to include a special node in your scene tree, called the `RoomManager( RoomManager )`. The RoomManager is responsible for the runtime maintenance of the system, especially converting the objects in your rooms into a *room graph* which is used at runtime to perform occlusion culling and other tasks.
 
 Room Conversion
 ^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ Rooms
 What is a room?
 ^^^^^^^^^^^^^^^
 
-`Room<class_Room )`\ s are a way of spatially partitioning your level into areas that make sense in terms of level design. Rooms often quite literally *are* rooms (like in a building). Ultimately though, as far as the engine is concerned, a room represents a **non-overlapping** convex volume in which you typically place most of your objects that fall within that area.
+`Room( Room )`\ s are a way of spatially partitioning your level into areas that make sense in terms of level design. Rooms often quite literally *are* rooms (like in a building). Ultimately though, as far as the engine is concerned, a room represents a **non-overlapping** convex volume in which you typically place most of your objects that fall within that area.
 
 A room doesn't need to correspond to a literal room. It could, for example, also be a canyon in an outdoor area or a smaller part of a concave room. With a little imagination, you can use the system in almost any scenario.
 
@@ -64,12 +64,12 @@ If you accidentally create overlapping rooms, the editor will warn you when you
 
 The system does attempt to cope with overlapping rooms as best as possible by making the current room *"sticky"*. Each object remembers which room it was in during the previous frame and stays within it as long as it does not move outside the convex hull room bound. This can result in some hysteresis in these overlapping zones.
 
-There is one exception, however, for `internal rooms<doc_rooms_and_portals_internal_rooms )`. You do not have to worry about these to start with.
+There is one exception, however, for `internal rooms( doc_rooms_and_portals_internal_rooms )`. You do not have to worry about these to start with.
 
 How do I create a room?
 ^^^^^^^^^^^^^^^^^^^^^^^
 
-A `Room<class_Room )` is a node type that can be added to the scene tree like any other. You can place objects within the room by making them children and grand-children of the Room node.
+A `Room( Room )` is a node type that can be added to the scene tree like any other. You can place objects within the room by making them children and grand-children of the Room node.
 
 How do I define the shape and position of my room convex hull?
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -93,7 +93,7 @@ Portals
 
 If you create some rooms, place objects within them, then convert the level in the editor, you will see the objects in the rooms appearing and showing as you move between rooms. There is one problem, however! Although you can see the objects within the room that the camera is in, you can't see to any neighbouring rooms! For that we need portals.
 
-`Portal<class_Portal )`\ s are special convex polygons that you position over the openings between rooms in order to allow the system to see between them. You can create a portal node directly in the editor. The default portal has 4 points and behaves much like a `plane` `MeshInstance<class_MeshInstance )`. You can add or remove points using the inspector. A portal requires at least 3 points to work - this is because it needs to form a polygon rather than a point or line.
+`Portal( Portal )`\ s are special convex polygons that you position over the openings between rooms in order to allow the system to see between them. You can create a portal node directly in the editor. The default portal has 4 points and behaves much like a `plane` `MeshInstance( MeshInstance )`. You can add or remove points using the inspector. A portal requires at least 3 points to work - this is because it needs to form a polygon rather than a point or line.
 
 To save editing effort, **only one Portal is required between each pair of Rooms**. You *do not need* to (and indeed should not) create two Portals that overlap in opposite directions. Portals default to being two-way, but you can make them one-way in the Portal inspector.
 
diff --git a/tutorials/3d/portals/introduction_to_rooms_and_portals.md b/tutorials/3d/portals/introduction_to_rooms_and_portals.md
index b2ff300..5417f38 100644
--- a/tutorials/3d/portals/introduction_to_rooms_and_portals.md
+++ b/tutorials/3d/portals/introduction_to_rooms_and_portals.md
@@ -3,7 +3,7 @@
 Introduction to Rooms and Portals
 =================================
 
-The rooms and portals system is an optional component of Godot that allows you to partition your 3D game levels into a series of `Room<class_Room )` s (*aka cells*), and `Portal<class_Portal )` s. Portals are openings between the rooms that the `Camera<class_Camera )` (and lights) can see through.
+The rooms and portals system is an optional component of Godot that allows you to partition your 3D game levels into a series of `Room( Room )` s (*aka cells*), and `Portal( Portal )` s. Portals are openings between the rooms that the `Camera( Camera )` (and lights) can see through.
  
 This allows several features:
 
diff --git a/tutorials/3d/portals/rooms_and_portals_example.md b/tutorials/3d/portals/rooms_and_portals_example.md
index afe677c..f4707a9 100644
--- a/tutorials/3d/portals/rooms_and_portals_example.md
+++ b/tutorials/3d/portals/rooms_and_portals_example.md
@@ -16,13 +16,13 @@ Step 1
 ![](tutorial_simple/img/tutorial_simple_1.png)
 
 - Create a new project.
-- Add a `Spatial<class_Spatial )` as the scene root (on the screenshot, it's called "Root").
-- Next add a `RoomManager<class_RoomManager )` node. We will need this later to process the room system.
+- Add a `Spatial( Spatial )` as the scene root (on the screenshot, it's called "Root").
+- Next add a `RoomManager( RoomManager )` node. We will need this later to process the room system.
 - Next we need to start defining our rooms. We create all our rooms under another Spatial we have called 'RoomList'.
-- Add a new `Room<class_Room )` node as a child of the roomlist.
+- Add a new `Room( Room )` node as a child of the roomlist.
 - We have named the room `Kitchen`.
 - We will now create the geometry of our room. The names you give to the geometry is up to you.
-- Create a `MeshInstance<class_MeshInstance )` for the floor. Create a box by adding a CubeMesh resource to the MeshInstance. Scale and position it to form a floor.
+- Create a `MeshInstance( MeshInstance )` for the floor. Create a box by adding a CubeMesh resource to the MeshInstance. Scale and position it to form a floor.
 - Create MeshInstances for the walls. Create more box meshes for this, then scale and position them. Be sure to leave an opening on one side. You will need to create two wall segments to do this on that side.
 
 Step 2
@@ -41,7 +41,7 @@ Step 3
 ![](tutorial_simple/img/tutorial_simple_3.png)
 
 - Next, we will add a portal between the two rooms.
-- Create a new `Portal<class_Portal )` in the kitchen.
+- Create a new `Portal( Portal )` in the kitchen.
 - Scale and position the portal using the node `Transform` in the inspector, so it fits within the opening between the two rooms.
 - The portal plane should face *outward* from the source room, i.e. towards the lounge. This direction is indicated by the arrow in the editor gizmo, and portal gizmo's color.
 
@@ -54,7 +54,7 @@ Step 4
 - Placing these boxes as children or grandchildren of the room nodes explicitly tells the system which room the objects should be in. However, we can also create these objects *outside* the rooms. Provided they are in the RoomList branch, the system will attempt to automatically place them in the correct room at runtime.
 - On the screenshot, the boxes were places as children of a Spatial I have called `Freeform` to keep things tidy.
 - Boxes also have a green SpatialMaterial assigned to them to make them stand out more from the rest of the room.
-- Let's also create an `OmniLight<class_OmniLight )` so it will be autoplaced in one of the rooms.
+- Let's also create an `OmniLight( OmniLight )` so it will be autoplaced in one of the rooms.
 
 Step 5
 ~~~~~~
diff --git a/tutorials/3d/portals/using_objects_in_rooms_and_portals.md b/tutorials/3d/portals/using_objects_in_rooms_and_portals.md
index 4c08beb..07d87f0 100644
--- a/tutorials/3d/portals/using_objects_in_rooms_and_portals.md
+++ b/tutorials/3d/portals/using_objects_in_rooms_and_portals.md
@@ -1,12 +1,12 @@
 Using objects in Rooms and Portals
 ==================================
 
-Normally, when you use Godot, all objects that you can see (`VisualInstance<class_VisualInstance )`\ s) are treated in the same way by the engine. The portal renderer is slightly different, in that it makes a distinction between the different roles objects will have in your game. It makes this distinction to define the `Room<class_Room )`\ s, and to render and process everything in the most efficient way.
+Normally, when you use Godot, all objects that you can see (`VisualInstance( VisualInstance )`\ s) are treated in the same way by the engine. The portal renderer is slightly different, in that it makes a distinction between the different roles objects will have in your game. It makes this distinction to define the `Room( Room )`\ s, and to render and process everything in the most efficient way.
 
 Portal mode
 ~~~~~~~~~~~
 
-If you look in the inspector, every VisualInstance in Godot is derived from a `CullInstance<class_CullInstance )`, where you can set a `PortalMode`. This determines how objects will behave in the portal system.
+If you look in the inspector, every VisualInstance in Godot is derived from a `CullInstance( CullInstance )`, where you can set a `PortalMode`. This determines how objects will behave in the portal system.
 
 ![](img/cull_instance.png)
 
@@ -90,6 +90,6 @@ While sprawling works great for large moving objects, it also gives you a lot mo
 Lighting
 ~~~~~~~~
 
-In general lights are handled like any other visual instance. They can be placed in rooms, and they will sprawl to affect neighbouring rooms, following the dimensions and direction of the light. The exception to this is `DirectionalLight<class_DirectionalLight )`\ s. DirectionalLights have no source room as they affect *everywhere*. They should therefore not be placed in a room. As DirectionalLights can be expensive, it is a good idea to turn them off when inside, see the later `doc_rooms_and_portals_roomgroups` section for details on how to do this.
+In general lights are handled like any other visual instance. They can be placed in rooms, and they will sprawl to affect neighbouring rooms, following the dimensions and direction of the light. The exception to this is `DirectionalLight( DirectionalLight )`\ s. DirectionalLights have no source room as they affect *everywhere*. They should therefore not be placed in a room. As DirectionalLights can be expensive, it is a good idea to turn them off when inside, see the later `doc_rooms_and_portals_roomgroups` section for details on how to do this.
 
 Congratulations! You have now mastered the intermediate techniques required to use rooms and portals. You can use these to make games already, but there are many more features.
diff --git a/tutorials/3d/procedural_geometry/index.md b/tutorials/3d/procedural_geometry/index.md
index 8baada5..fa759d9 100644
--- a/tutorials/3d/procedural_geometry/index.md
+++ b/tutorials/3d/procedural_geometry/index.md
@@ -84,7 +84,7 @@ ArrayMesh
 The ArrayMesh resource extends Mesh to add a few different quality of life functions and, most
 importantly, the ability to construct a Mesh surface through scripting.
 
-For more information about the ArrayMesh, please see the `ArrayMesh tutorial <doc_arraymesh )`.
+For more information about the ArrayMesh, please see the `ArrayMesh tutorial ( doc_arraymesh )`.
 
 MeshDataTool
 ^^^^^^^^^^^^
@@ -92,14 +92,14 @@ MeshDataTool
 The MeshDataTool is a resource that converts Mesh data into arrays of vertices, faces, and edges that can
 be modified at runtime.
 
-For more information about the MeshDataTool, please see the `MeshDataTool tutorial <doc_meshdatatool )`.
+For more information about the MeshDataTool, please see the `MeshDataTool tutorial ( doc_meshdatatool )`.
 
 SurfaceTool
 ^^^^^^^^^^^
 
 The SurfaceTool allows the creation of Meshes using an OpenGL 1.x immediate mode style interface.
 
-For more information about the SurfaceTool, please see the `SurfaceTool tutorial <doc_surfacetool )`.
+For more information about the SurfaceTool, please see the `SurfaceTool tutorial ( doc_surfacetool )`.
 
 ImmediateGeometry
 ^^^^^^^^^^^^^^^^^
@@ -113,7 +113,7 @@ ImmediateGeometry is useful for prototyping because of its straightforward API,
 is rebuilt every frame. It is most useful for adding simple geometry for visual debugging (e.g. by drawing lines to
 visualize physics raycasts etc.).
 
-For more information about ImmediateGeometry, please see the `ImmediateGeometry tutorial <doc_immediategeometry )`.
+For more information about ImmediateGeometry, please see the `ImmediateGeometry tutorial ( doc_immediategeometry )`.
 
 Which one should I use?
 -----------------------
diff --git a/tutorials/3d/procedural_geometry/meshdatatool.md b/tutorials/3d/procedural_geometry/meshdatatool.md
index 2190438..785a890 100644
--- a/tutorials/3d/procedural_geometry/meshdatatool.md
+++ b/tutorials/3d/procedural_geometry/meshdatatool.md
@@ -16,7 +16,7 @@ for certain mesh algorithms. If you do not need this extra information then it m
 We initialize the MeshDataTool from an ArrayMesh by calling `create_from_surface()`. If there is already data initialized in the MeshDataTool,
 calling `create_from_surface()` will clear it for you. Alternatively, you can call `clear()` yourself before re-using the MeshDataTool.
 
-In the examples below, assume an ArrayMesh called `mesh` has already been created. See `ArrayMesh tutorial <doc_arraymesh )` for an example of mesh generation.
+In the examples below, assume an ArrayMesh called `mesh` has already been created. See `ArrayMesh tutorial ( doc_arraymesh )` for an example of mesh generation.
 
 gdscript GDScript
 
@@ -71,7 +71,7 @@ gdscript GDScript
 ```
 
 Below is a complete example that turns a spherical mesh called `mesh` into a randomly deformed blob complete with updated normals and vertex colors.
-See `ArrayMesh tutorial <doc_arraymesh )` for how to generate the base mesh.
+See `ArrayMesh tutorial ( doc_arraymesh )` for how to generate the base mesh.
 
 gdscript GDScript
 
diff --git a/tutorials/3d/using_gridmaps.md b/tutorials/3d/using_gridmaps.md
index 7c44371..1c04099 100644
--- a/tutorials/3d/using_gridmaps.md
+++ b/tutorials/3d/using_gridmaps.md
@@ -7,7 +7,7 @@ Introduction
 ------------
 
 `Gridmaps` are a tool for creating 3D
-game levels, similar to the way `TileMap <doc_using_tilemaps )`
+game levels, similar to the way `TileMap ( doc_using_tilemaps )`
 works in 2D. You start with a predefined collection of 3D meshes (a
 `MeshLibrary`) that can be placed on a grid,
 as if you were building a level with an unlimited amount of Lego blocks.
@@ -19,7 +19,7 @@ Example project
 ---------------
 
 To learn how GridMaps work, start by downloading the sample project:
-:download:`gridmap_demo.zip <files/gridmap_demo.zip )`.
+:download:`gridmap_demo.zip ( files/gridmap_demo.zip )`.
 
 Unzip this project and add it to the Project Manager using the "Import"
 button.
diff --git a/tutorials/animation/cutout_animation.md b/tutorials/animation/cutout_animation.md
index f42fd83..16b820e 100644
--- a/tutorials/animation/cutout_animation.md
+++ b/tutorials/animation/cutout_animation.md
@@ -368,4 +368,4 @@ To apply the same easing curve to multiple keyframes at once:
 Skeletal deform can be used to augment a cutout rig, allowing single pieces to
 deform organically (e.g. antennae that wobble as an insect character walks).
 
-This process is described in a `separate tutorial <doc_2d_skeletons )`.
+This process is described in a `separate tutorial ( doc_2d_skeletons )`.
diff --git a/tutorials/animation/playing_videos.md b/tutorials/animation/playing_videos.md
index 7b6adad..cfe2fe4 100644
--- a/tutorials/animation/playing_videos.md
+++ b/tutorials/animation/playing_videos.md
@@ -142,7 +142,7 @@ There are several limitations with the current implementation of video playback
 
 - Seeking a video to a certain point is not supported.
 - Changing playback speed is not supported. VideoPlayer also won't follow
-  `Engine.time_scale<class_Engine_property_time_scale )`.
+  `Engine.time_scale( Engine_property_time_scale )`.
 - Looping is not supported, but you can connect a VideoPlayer's
   `finished` signal to a function
   that plays the video again. However, this will cause a black frame to be
diff --git a/tutorials/assets_pipeline/import_process.md b/tutorials/assets_pipeline/import_process.md
index 525abf2..3edc829 100644
--- a/tutorials/assets_pipeline/import_process.md
+++ b/tutorials/assets_pipeline/import_process.md
@@ -18,12 +18,12 @@ Godot will automatically import these files internally
 and keep the imported resources hidden in a `res://.import` folder.
 
 This means that when trying to access imported assets through code you
-need to use the `Resource Loader<class_ResourceLoader )` as it will
+need to use the `Resource Loader( ResourceLoader )` as it will
 automatically take into account where the internal files are saved. If you
 try and access an imported asset using the `File` class
 it will work in the editor, but break in the exported project.
 
-However, the `Resource Loader<class_ResourceLoader )` cannot access
+However, the `Resource Loader( ResourceLoader )` cannot access
 non imported files, only the `File` class can.
 
 Changing import parameters
diff --git a/tutorials/assets_pipeline/importing_audio_samples.md b/tutorials/assets_pipeline/importing_audio_samples.md
index 480463f..6549efd 100644
--- a/tutorials/assets_pipeline/importing_audio_samples.md
+++ b/tutorials/assets_pipeline/importing_audio_samples.md
@@ -49,7 +49,7 @@ for music, speech, and long sound effects.
 Best practices
 --------------
 
-Godot has an `extensive bus system <doc_audio_buses )` with built-in effects.
+Godot has an `extensive bus system ( doc_audio_buses )` with built-in effects.
 This saves SFX artists the need to add reverb to the sound effects,
 reducing their size greatly and ensuring correct trimming. Say no to SFX
 with baked reverb!
diff --git a/tutorials/assets_pipeline/importing_translations.md b/tutorials/assets_pipeline/importing_translations.md
index fa24362..3906fea 100644
--- a/tutorials/assets_pipeline/importing_translations.md
+++ b/tutorials/assets_pipeline/importing_translations.md
@@ -64,7 +64,7 @@ CSV files must be formatted as follows:
 +--------+----------+----------+----------+
 
 The "lang" tags must represent a language, which must be one of the `valid
-locales <doc_locales )` supported by the engine. The "KEY" tags must be
+locales ( doc_locales )` supported by the engine. The "KEY" tags must be
 unique and represent a string universally (they are usually in
 uppercase, to differentiate from other strings). These keys will be replaced at
 runtime by the matching translated string. Note that the case is important,
diff --git a/tutorials/audio/audio_buses.md b/tutorials/audio/audio_buses.md
index 556d452..5239f7a 100644
--- a/tutorials/audio/audio_buses.md
+++ b/tutorials/audio/audio_buses.md
@@ -151,7 +151,7 @@ The compressor has many uses. For example:
 
     If your goal is to prevent a signal from exceeding a given amplitude
     altogether, rather than to reduce the dynamic range of the signal,
-    a `limiter <doc_audio_buses_limiter )` is likely a better choice
+    a `limiter ( doc_audio_buses_limiter )` is likely a better choice
     than a compressor.
 
 
@@ -259,7 +259,7 @@ Reverb
 Reverb simulates rooms of different sizes. It has adjustable parameters that can
 be tweaked to obtain the sound of a specific room. Reverb is commonly outputted
 from `Areas`
-(see `Reverb buses <doc_audio_streams_reverb_buses )`), or to apply
+(see `Reverb buses ( doc_audio_streams_reverb_buses )`), or to apply
 a "chamber" feel to all sounds.
 
 SpectrumAnalyzer
diff --git a/tutorials/audio/sync_with_audio.md b/tutorials/audio/sync_with_audio.md
index a8b9fbd..856fe23 100644
--- a/tutorials/audio/sync_with_audio.md
+++ b/tutorials/audio/sync_with_audio.md
@@ -26,11 +26,11 @@ The problem, in the end, is not this slight delay but synchronizing graphics and
 Using the system clock to sync
 ------------------------------
 
-As mentioned before, If you call `AudioStreamPlayer.play()<class_AudioStreamPlayer_method_play )`, sound will not begin immediately, but when the audio thread processes the next chunk.
+As mentioned before, If you call `AudioStreamPlayer.play()( AudioStreamPlayer_method_play )`, sound will not begin immediately, but when the audio thread processes the next chunk.
 
-This delay can't be avoided but it can be estimated by calling `AudioServer.get_time_to_next_mix()<class_AudioServer_method_get_time_to_next_mix )`.
+This delay can't be avoided but it can be estimated by calling `AudioServer.get_time_to_next_mix()( AudioServer_method_get_time_to_next_mix )`.
 
-The output latency (what happens after the mix) can also be estimated by calling `AudioServer.get_output_latency()<class_AudioServer_method_get_output_latency )`.
+The output latency (what happens after the mix) can also be estimated by calling `AudioServer.get_output_latency()( AudioServer_method_get_output_latency )`.
 
 Add these two and it's possible to guess almost exactly when sound or music will begin playing in the speakers during *_process()*:
 
@@ -65,9 +65,9 @@ For a rhythm game where a song begins and ends after a few minutes, this approac
 Using the sound hardware clock to sync
 --------------------------------------
 
-Using `AudioStreamPlayer.get_playback_position()<class_AudioStreamPlayer_method_get_playback_position )` to obtain the current position for the song sounds ideal, but it's not that useful as-is. This value will increment in chunks (every time the audio callback mixed a block of sound), so many calls can return the same value. Added to this, the value will be out of sync with the speakers too because of the previously mentioned reasons.
+Using `AudioStreamPlayer.get_playback_position()( AudioStreamPlayer_method_get_playback_position )` to obtain the current position for the song sounds ideal, but it's not that useful as-is. This value will increment in chunks (every time the audio callback mixed a block of sound), so many calls can return the same value. Added to this, the value will be out of sync with the speakers too because of the previously mentioned reasons.
 
-To compensate for the "chunked" output, there is a function that can help: `AudioServer.get_time_since_last_mix()<class_AudioServer_method_get_time_since_last_mix )`.
+To compensate for the "chunked" output, there is a function that can help: `AudioServer.get_time_since_last_mix()( AudioServer_method_get_time_since_last_mix )`.
 
 
 Adding the return value from this function to *get_playback_position()* increases precision:
diff --git a/tutorials/best_practices/autoloads_versus_internal_nodes.md b/tutorials/best_practices/autoloads_versus_internal_nodes.md
index c39fa87..5473e69 100644
--- a/tutorials/best_practices/autoloads_versus_internal_nodes.md
+++ b/tutorials/best_practices/autoloads_versus_internal_nodes.md
@@ -20,7 +20,7 @@ many ways to avoid global state thanks to the node tree and signals.
 
 For example, let's say we are building a platformer and want to collect coins
 that play a sound effect. There's a node for that: the `AudioStreamPlayer
-<class_AudioStreamPlayer )`. But if we call the `AudioStreamPlayer` while it is
+( AudioStreamPlayer )`. But if we call the `AudioStreamPlayer` while it is
 already playing a sound, the new sound interrupts the first.
 
 A solution is to code a global, auto-loaded sound manager class. It generates a
@@ -68,7 +68,7 @@ or data across many scenes.
 
 In the case of functions, you can create a new type of `Node` that provides
 that feature for an individual scene using the `name
-<doc_gdscript_basics_class_name )` keyword in GDScript.
+( doc_gdscript_basics_class_name )` keyword in GDScript.
 
 When it comes to data, you can either:
 
diff --git a/tutorials/best_practices/data_preferences.md b/tutorials/best_practices/data_preferences.md
index 2217d33..d4c9e76 100644
--- a/tutorials/best_practices/data_preferences.md
+++ b/tutorials/best_practices/data_preferences.md
@@ -334,4 +334,4 @@ for blending, i.e. enabling smooth transitions between these animations. There
 may also be a hierarchical structure between animations that one plans out for
 their object. These are the cases where the `AnimationTree`
 shines. One can find an in-depth guide on using the AnimationTree
-`here <doc_animation_tree )`.
+`here ( doc_animation_tree )`.
diff --git a/tutorials/best_practices/godot_interfaces.md b/tutorials/best_practices/godot_interfaces.md
index a07bfb9..d1c1bbf 100644
--- a/tutorials/best_practices/godot_interfaces.md
+++ b/tutorials/best_practices/godot_interfaces.md
@@ -155,7 +155,7 @@ following checks, in order:
   the ClassDB for the "visible" property against the CanvasItem class and all
   of its inherited types. If found, it will call the bound setter or getter.
   For more information about HashMaps, see the
-  `data preferences <doc_data_preferences )` docs.
+  `data preferences ( doc_data_preferences )` docs.
 
 - If not found, it does an explicit check to see if the user wants to access
   the "script" or "meta" properties.
diff --git a/tutorials/best_practices/logic_preferences.md b/tutorials/best_practices/logic_preferences.md
index 619201a..4ffe5fb 100644
--- a/tutorials/best_practices/logic_preferences.md
+++ b/tutorials/best_practices/logic_preferences.md
@@ -140,5 +140,5 @@ As such, the best options would be...
    into a plugin.
 
 For an example of the various ways one can swap scenes around at runtime,
-please see the `"Change scenes manually" <doc_change_scenes_manually )`
+please see the `"Change scenes manually" ( doc_change_scenes_manually )`
 documentation.
diff --git a/tutorials/best_practices/node_alternatives.md b/tutorials/best_practices/node_alternatives.md
index 875ecec..d5de7c8 100644
--- a/tutorials/best_practices/node_alternatives.md
+++ b/tutorials/best_practices/node_alternatives.md
@@ -52,7 +52,7 @@ your project's features.
      can be save and loaded, therefore they extend from Resource.
 
    - **Advantages:** Much has
-     `already been said <doc_resources )`
+     `already been said ( doc_resources )`
      on `Resource`'s advantages over traditional data
      storage methods. In the context of using Resources over Nodes though,
      their main advantage is in Inspector-compatibility. While nearly as
diff --git a/tutorials/best_practices/scene_organization.md b/tutorials/best_practices/scene_organization.md
index 258b24f..1a21789 100644
--- a/tutorials/best_practices/scene_organization.md
+++ b/tutorials/best_practices/scene_organization.md
@@ -218,7 +218,7 @@ the various menus and widgets the project needs.
         - Control "GUI" (gui.gd)
 
 When changing levels, one can then swap out the children of the "World" node.
-`Changing scenes manually <doc_change_scenes_manually )` gives users full
+`Changing scenes manually ( doc_change_scenes_manually )` gives users full
 control over how their game world transitions.
 
 The next step is to consider what gameplay systems one's project requires.
@@ -228,7 +228,7 @@ If one has a system that...
 2. should be globally accessible
 3. should exist in isolation
 
-... then one should create an `autoload 'singleton' node <doc_singletons_autoload )`.
+... then one should create an `autoload 'singleton' node ( doc_singletons_autoload )`.
 
 .. note::
 
@@ -246,7 +246,7 @@ If one has a system that...
 If one has systems that modify other systems' data, one should define those as
 their own scripts or scenes rather than autoloads. For more information on the
 reasons, please see the
-`Autoloads versus regular nodes <doc_autoloads_versus_internal_nodes )`
+`Autoloads versus regular nodes ( doc_autoloads_versus_internal_nodes )`
 documentation.
 
 Each subsystem within one's game should have its own section within the
diff --git a/tutorials/best_practices/scenes_versus_scripts.md b/tutorials/best_practices/scenes_versus_scripts.md
index 0d1fd5c..5496942 100644
--- a/tutorials/best_practices/scenes_versus_scripts.md
+++ b/tutorials/best_practices/scenes_versus_scripts.md
@@ -73,7 +73,7 @@ name.
 
 There are two systems for registering types...
 
-- `Custom Types <doc_making_plugins )`
+- `Custom Types ( doc_making_plugins )`
 
    - Editor-only. Typenames are not accessible at runtime.
 
@@ -90,7 +90,7 @@ There are two systems for registering types...
 
    - Set up using `EditorPlugin.add_custom_type`.
 
-- `Script Classes <doc_gdscript_basics_class_name )`
+- `Script Classes ( doc_gdscript_basics_class_name )`
 
    - Editor and runtime accessible.
 
@@ -157,7 +157,7 @@ makes a call to the scripting API which leads to many "lookups" on the back-end
 to find the logic to execute.
 
 Scenes help to avoid this performance issue. `PackedScene
-<class_PackedScene )`, the base type that scenes inherit from, defines resources
+( PackedScene )`, the base type that scenes inherit from, defines resources
 that use serialized data to create objects. The engine can process scenes in
 batches on the back-end and provide much better performance than scripts.
 
diff --git a/tutorials/best_practices/what_are_godot_classes.md b/tutorials/best_practices/what_are_godot_classes.md
index 81f4a58..1a60d1e 100644
--- a/tutorials/best_practices/what_are_godot_classes.md
+++ b/tutorials/best_practices/what_are_godot_classes.md
@@ -23,7 +23,7 @@ These scripts are not technically classes. Instead, they are resources that tell
 sequence of initializations to perform on one of the engine's built-in classes.
 
 Godot's internal classes have methods that register a class's data with a `ClassDB
-<class_ClassDB )`. This database provides runtime access to class information. `ClassDB` contains
+( ClassDB )`. This database provides runtime access to class information. `ClassDB` contains
 information about classes like:
 
 - Properties.
diff --git a/tutorials/editor/command_line_tutorial.md b/tutorials/editor/command_line_tutorial.md
index 9ff4162..9c4280a 100644
--- a/tutorials/editor/command_line_tutorial.md
+++ b/tutorials/editor/command_line_tutorial.md
@@ -45,9 +45,9 @@ Command line reference
 +------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | Command                                  | Description                                                                                                                                                  |
 +------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| `-e`, `--editor`                     | Start the editor instead of running the scene (`tools <doc_introduction_to_the_buildsystem_tools )` must be enabled).                                    |
+| `-e`, `--editor`                     | Start the editor instead of running the scene (`tools ( doc_introduction_to_the_buildsystem_tools )` must be enabled).                                    |
 +------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| `-p`, `--project-manager`            | Start the project manager, even if a project is auto-detected (`tools <doc_introduction_to_the_buildsystem_tools )` must be enabled).                    |
+| `-p`, `--project-manager`            | Start the project manager, even if a project is auto-detected (`tools ( doc_introduction_to_the_buildsystem_tools )` must be enabled).                    |
 +------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | `-q`, `--quit`                       | Quit after the first iteration.                                                                                                                              |
 +------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
@@ -135,22 +135,22 @@ Command line reference
 +----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | `--check-only`                       | Only parse for errors and quit (use with `--script`).                                                                                                                            |
 +----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| `--export <target )`                  | Export the project using the given export target. Export only main pack if path ends with .pck or .zip (`tools <doc_introduction_to_the_buildsystem_tools )` must be enabled). |
+| `--export <target )`                  | Export the project using the given export target. Export only main pack if path ends with .pck or .zip (`tools ( doc_introduction_to_the_buildsystem_tools )` must be enabled). |
 +----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| `--export-debug <target )`            | Like `--export`, but use debug template (`tools <doc_introduction_to_the_buildsystem_tools )` must be enabled).                                                              |
+| `--export-debug <target )`            | Like `--export`, but use debug template (`tools ( doc_introduction_to_the_buildsystem_tools )` must be enabled).                                                              |
 +----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| `--doctool <path )`                   | Dump the engine API reference to the given <path> in XML format, merging if existing files are found (`tools <doc_introduction_to_the_buildsystem_tools )` must be enabled).   |
+| `--doctool <path )`                   | Dump the engine API reference to the given <path> in XML format, merging if existing files are found (`tools ( doc_introduction_to_the_buildsystem_tools )` must be enabled).   |
 +----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| `--no-docbase`                       | Disallow dumping the base types (used with `--doctool`, `tools <doc_introduction_to_the_buildsystem_tools )` must be enabled).                                               |
+| `--no-docbase`                       | Disallow dumping the base types (used with `--doctool`, `tools ( doc_introduction_to_the_buildsystem_tools )` must be enabled).                                               |
 +----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| `--build-solutions`                  | Build the scripting solutions (e.g. for C# projects, `tools <doc_introduction_to_the_buildsystem_tools )` must be enabled).                                                    |
+| `--build-solutions`                  | Build the scripting solutions (e.g. for C# projects, `tools ( doc_introduction_to_the_buildsystem_tools )` must be enabled).                                                    |
 +----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| `--gdnative-generate-json-api`       | Generate JSON dump of the Godot API for GDNative bindings (`tools <doc_introduction_to_the_buildsystem_tools )` must be enabled).                                              |
+| `--gdnative-generate-json-api`       | Generate JSON dump of the Godot API for GDNative bindings (`tools ( doc_introduction_to_the_buildsystem_tools )` must be enabled).                                              |
 +----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| `--test <test )`                      | Run a unit test. Use `--help` first to display the list of tests. (`tools <doc_introduction_to_the_buildsystem_tools )` must be enabled).                                    |
+| `--test <test )`                      | Run a unit test. Use `--help` first to display the list of tests. (`tools ( doc_introduction_to_the_buildsystem_tools )` must be enabled).                                    |
 +----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | `--export-pack <preset> <path )`      | Like `--export`, but only export the game pack for the given preset. The <path> extension determines whether it will be in PCK or ZIP format.                                    |
-|                                        | (`tools <doc_introduction_to_the_buildsystem_tools )` must be enabled).                                                                                                        |
+|                                        | (`tools ( doc_introduction_to_the_buildsystem_tools )` must be enabled).                                                                                                        |
 +----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 Path
diff --git a/tutorials/editor/index.md b/tutorials/editor/index.md
index 5f050f3..07ea7ef 100644
--- a/tutorials/editor/index.md
+++ b/tutorials/editor/index.md
@@ -4,7 +4,7 @@ Editor manual
 In this section, we cover the Godot editor in general, from its interface to
 using it with the command line. We cover some specific editors' interface in
 other sections where appropriate. For example, the `animation editor
-<doc_introduction_animation )`.
+( doc_introduction_animation )`.
 
 .. toctree::
    :maxdepth: 1
diff --git a/tutorials/export/android_custom_build.md b/tutorials/export/android_custom_build.md
index 88cb61c..d0aa121 100644
--- a/tutorials/export/android_custom_build.md
+++ b/tutorials/export/android_custom_build.md
@@ -14,7 +14,7 @@ There are some reasons why you may want to do this:
 * Add external SDKs that build with your project.
 
 Configuring the custom build is a fairly straightforward process. But first
-you need to follow the steps in `exporting for android<doc_exporting_for_android )`
+you need to follow the steps in `exporting for android( doc_exporting_for_android )`
 up to **Setting it up in Godot**. After doing that, follow the steps below.
 
 Set up the custom build environment
@@ -29,7 +29,7 @@ download them.
 
 A Gradle-based Android project will be created under `res://android/build`.
 Editing these files is not needed unless you want to `create
-your own add-ons<doc_android_plugin )`, or you really need to modify the project.
+your own add-ons( doc_android_plugin )`, or you really need to modify the project.
 
 
 Enabling the custom build and exporting
diff --git a/tutorials/export/changing_application_icon_for_windows.md b/tutorials/export/changing_application_icon_for_windows.md
index 833e0bc..63239b9 100644
--- a/tutorials/export/changing_application_icon_for_windows.md
+++ b/tutorials/export/changing_application_icon_for_windows.md
@@ -106,7 +106,7 @@ the **Application → Icon** field.
 .. note::
 
     If rcedit fails to change the icon, you can instead
-    `compile your own Windows export templates <doc_compiling_for_windows )`
+    `compile your own Windows export templates ( doc_compiling_for_windows )`
     with the icon changed. To do so, replace
     `platform/windows/godot.ico ( https://github.com/godotengine/godot/blob/master/platform/windows/godot.ico )`
     with your own ICO file *before* compiling export templates.
diff --git a/tutorials/export/exporting_for_dedicated_servers.md b/tutorials/export/exporting_for_dedicated_servers.md
index f8e76e0..efab3e7 100644
--- a/tutorials/export/exporting_for_dedicated_servers.md
+++ b/tutorials/export/exporting_for_dedicated_servers.md
@@ -12,7 +12,7 @@ Platform support
 - **Linux:** `Download an official Linux server binary ( https://godotengine.org/download/server )`.
   To compile a server binary from source, follow instructions in
   `doc_compiling_for_x11`.
-- **macOS:** `Compile a server binary from source for macOS <doc_compiling_for_osx )`.
+- **macOS:** `Compile a server binary from source for macOS ( doc_compiling_for_osx )`.
 - **Windows:** There is no dedicated server build for Windows yet. As an alternative,
   you can use the `--no-window` command-line argument to prevent Godot from
   spawning a window. Note that even with the `--no-window` command-line argument,
diff --git a/tutorials/export/exporting_for_macos.md b/tutorials/export/exporting_for_macos.md
index 375f48e..1131691 100644
--- a/tutorials/export/exporting_for_macos.md
+++ b/tutorials/export/exporting_for_macos.md
@@ -22,12 +22,12 @@ Requirements
 
 .. warning::
 
-    Projects exported without code signing and notarization will be blocked by Gatekeeper if they are downloaded from unknown sources, see the `Running Godot apps on macOS <doc_running_on_macos )` page for more information.
+    Projects exported without code signing and notarization will be blocked by Gatekeeper if they are downloaded from unknown sources, see the `Running Godot apps on macOS ( doc_running_on_macos )` page for more information.
 
 Code signing and notarization
 -----------------------------
 
-By default, macOS will run only applications that are signed and notarized. If you use any other signing configuration, see `Running Godot apps on macOS <doc_running_on_macos )` for workarounds.
+By default, macOS will run only applications that are signed and notarized. If you use any other signing configuration, see `Running Godot apps on macOS ( doc_running_on_macos )` for workarounds.
 
 To notarize an app, you **must** have a valid `Apple Developer ID Certificate ( https://developer.apple.com/ )`.
 
@@ -50,7 +50,7 @@ If you do not have an Apple Developer ID Certificate
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Keep `Code Signing` enabled and leave the `Identity` option empty (when exporting from a computer running macOS, on other platforms this option is hidden).
-In this case Godot will use a ad-hoc signature, which will make running an exported app easier for the end users, see the `Running Godot apps on macOS <doc_running_on_macos )` page for more information.
+In this case Godot will use a ad-hoc signature, which will make running an exported app easier for the end users, see the `Running Godot apps on macOS ( doc_running_on_macos )` page for more information.
 
 Signing Options
 ~~~~~~~~~~~~~~~
diff --git a/tutorials/export/exporting_for_web.md b/tutorials/export/exporting_for_web.md
index 8d2c97c..a91c64e 100644
--- a/tutorials/export/exporting_for_web.md
+++ b/tutorials/export/exporting_for_web.md
@@ -21,7 +21,7 @@ in the user's browser.
 .. attention:: `There are significant bugs when running HTML5 projects on iOS
                ( https://github.com/godotengine/godot/issues?q=is:issue+is:open+label:platform:html5+ios )`
                (regardless of the browser). We recommend using
-               `iOS' native export functionality <doc_exporting_for_ios )`
+               `iOS' native export functionality ( doc_exporting_for_ios )`
                instead, as it will also result in better performance.
 
 WebGL version
@@ -62,7 +62,7 @@ You can choose the **Export Type** to select which features will be available:
 - *GDNative*: enables GDNative support but makes the binary bigger and slower
   to load.
 
-If you plan to use `VRAM compression <doc_import_images )` make sure that
+If you plan to use `VRAM compression ( doc_import_images )` make sure that
 **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).
@@ -70,7 +70,7 @@ compatible export).
 If a path to a **Custom HTML shell** file is given, it will be used instead of
 the default HTML page. See `doc_customizing_html5_shell`.
 
-**Head Include** is appended into the `<head )` element of the generated
+**Head Include** is appended into the `( head )` element of the generated
 HTML page. This allows to, for example, load webfonts and third-party
 JavaScript APIs, include CSS, or run JavaScript code.
 
@@ -132,18 +132,18 @@ user's side, this can be worked around by running the project in a separate
 Threads
 ~~~~~~~
 
-As mentioned `above <doc_javascript_export_options )` multi-threading is
+As mentioned `above ( doc_javascript_export_options )` multi-threading is
 only available if the appropriate **Export Type** is set and support for it
 across browsers is still limited.
 
-.. warning:: Requires a `secure context <doc_javascript_secure_contexts )`.
+.. warning:: Requires a `secure context ( doc_javascript_secure_contexts )`.
              Browsers also require that the web page is served with specific
              `cross-origin isolation headers ( https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cross-Origin-Embedder-Policy )`.
 
 GDNative
 ~~~~~~~~
 
-As mentioned `above <doc_javascript_export_options )` GDNative is only
+As mentioned `above ( doc_javascript_export_options )` GDNative is only
 available if the appropriate **Export Type** is set.
 
 The export will also copy the required GDNative `.wasm` files to the output
@@ -161,7 +161,7 @@ input event must currently be active.
 
 For the same reason, the full screen project setting doesn't work unless the
 engine is started from within a valid input event handler. This requires
-`customization of the HTML page <doc_customizing_html5_shell )`.
+`customization of the HTML page ( doc_customizing_html5_shell )`.
 
 Audio
 ~~~~~
@@ -173,16 +173,16 @@ player to click or tap or press a key to enable audio.
              policies ( https://sites.google.com/a/chromium.org/dev/audio-video/autoplay )`.
 
 .. warning:: Access to microphone requires a
-             `secure context <doc_javascript_secure_contexts )`.
+             `secure context ( doc_javascript_secure_contexts )`.
 
 Networking
 ~~~~~~~~~~
 
 Low level networking is not implemented due to lacking support in browsers.
 
-Currently, only `HTTP client <doc_http_client_class )`,
-`HTTP requests <doc_http_request_class )`,
-`WebSocket (client) <doc_websocket )` and `WebRTC <doc_webrtc )` are
+Currently, only `HTTP client ( doc_http_client_class )`,
+`HTTP requests ( doc_http_request_class )`,
+`WebSocket (client) ( doc_websocket )` and `WebRTC ( doc_webrtc )` are
 supported.
 
 The HTTP classes also have several restrictions on the HTML5 platform:
@@ -202,7 +202,7 @@ browser supporting the `Clipboard API ( https://developer.mozilla.org/en-US/docs
 additionally, due to the API asynchronous nature might not be reliable when
 accessed from GDScript.
 
-.. warning:: Requires a `secure context <doc_javascript_secure_contexts )`.
+.. warning:: Requires a `secure context ( doc_javascript_secure_contexts )`.
 
 Gamepads
 ~~~~~~~~
@@ -213,13 +213,13 @@ sadly the `Gamepad API ( https://developer.mozilla.org/en-US/docs/Web/API/Gamepa
 does not provide a reliable way to detect the gamepad information necessary
 to remap them based on model/vendor/OS due to privacy considerations.
 
-.. warning:: Requires a `secure context <doc_javascript_secure_contexts )`.
+.. warning:: Requires a `secure context ( doc_javascript_secure_contexts )`.
 
 Boot splash is not displayed
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The default HTML page does not display the boot splash while loading. However,
-the image is exported as a PNG file, so `custom HTML pages <doc_customizing_html5_shell )`
+the image is exported as a PNG file, so `custom HTML pages ( doc_customizing_html5_shell )`
 can display it.
 
 Shader language limitations
@@ -240,7 +240,7 @@ servers and can be renamed to e.g. `index.html` at any time, its name is
 never depended on by default.
 
 The HTML page draws the game at maximum size within the browser window.
-This way it can be inserted into an `<iframe )` with the game's size, as is
+This way it can be inserted into an `( iframe )` with the game's size, as is
 common on most web game hosting sites.
 
 The other exported files are served as they are, next to the `.html` file,
@@ -249,7 +249,7 @@ the engine. The `.pck` file is the Godot main pack containing your game. The
 `.js` file contains start-up code and is used by the `.html` file to access
 the engine. The `.png)` file contains the boot splash image. It is not used in
 the default HTML page, but is included for
-`custom HTML pages <doc_customizing_html5_shell )`.
+`custom HTML pages ( doc_customizing_html5_shell )`.
 
 The `.pck` file is binary, usually delivered with the MIME-type
 :mimetype:`application/octet-stream`. The `.wasm` file is delivered as
@@ -302,11 +302,11 @@ returned by `eval()` under certain circumstances:
 
 Any other JavaScript value is returned as `null`.
 
-HTML5 export templates may be `built <doc_compiling_for_web )` without
+HTML5 export templates may be `built ( doc_compiling_for_web )` without
 support for the singleton to improve security. With such templates, and on
 platforms other than HTML5, calling `JavaScript.eval` will also return
 `null`. The availability of the singleton can be checked with the
-`JavaScript` `feature tag <doc_feature_tags )`::
+`JavaScript` `feature tag ( doc_feature_tags )`::
 
     func my_func3():
         if OS.has_feature('JavaScript'):
diff --git a/tutorials/export/exporting_pcks.md b/tutorials/export/exporting_pcks.md
index 0fbf4bb..a13af24 100644
--- a/tutorials/export/exporting_pcks.md
+++ b/tutorials/export/exporting_pcks.md
@@ -60,7 +60,7 @@ an export template selected while doing so.
 
 ![](img/export_pck.png)
 
-Another method would be to `export from the command line <doc_command_line_tutorial_exporting )`.
+Another method would be to `export from the command line ( doc_command_line_tutorial_exporting )`.
 If the output file ends with a PCK or ZIP file extension, then the export
 process will build that type of file for the chosen platform.
 
diff --git a/tutorials/export/exporting_projects.md b/tutorials/export/exporting_projects.md
index 6be8956..5a35c25 100644
--- a/tutorials/export/exporting_projects.md
+++ b/tutorials/export/exporting_projects.md
@@ -32,7 +32,7 @@ binary, which is smaller in size, more optimized and does not include
 tools like the editor and debugger.
 
 Finally, Godot has a simple but efficient system for
-`creating DLCs as extra package files <doc_exporting_pcks )`.
+`creating DLCs as extra package files ( doc_exporting_pcks )`.
 
 On mobile
 ~~~~~~~~~
diff --git a/tutorials/export/feature_tags.md b/tutorials/export/feature_tags.md
index d3c1cec..8dd8255 100644
--- a/tutorials/export/feature_tags.md
+++ b/tutorials/export/feature_tags.md
@@ -36,7 +36,7 @@ Here is a list of most feature tags in Godot. Keep in mind they are **case-sensi
 +-----------------+--------------------------------------------------------+
 | **HTML5**       | Running on HTML5                                       |
 +-----------------+--------------------------------------------------------+
-| **JavaScript**  | `JavaScript singleton <doc_javascript_eval )` is   |
+| **JavaScript**  | `JavaScript singleton ( doc_javascript_eval )` is   |
 |                 | available                                              |
 +-----------------+--------------------------------------------------------+
 | **OSX**         | Running on macOS                                       |
@@ -94,7 +94,7 @@ Here is a list of most feature tags in Godot. Keep in mind they are **case-sensi
     `false` when running a project exported to HTML5 on a mobile device.
 
     To check whether a project exported to HTML5 is running on a mobile device,
-    `call JavaScript code <doc_javascript_eval )` that reads the browser's
+    `call JavaScript code ( doc_javascript_eval )` that reads the browser's
     user agent.
 
 Custom features
diff --git a/tutorials/i18n/internationalizing_games.md b/tutorials/i18n/internationalizing_games.md
index db74450..ad70170 100644
--- a/tutorials/i18n/internationalizing_games.md
+++ b/tutorials/i18n/internationalizing_games.md
@@ -60,8 +60,8 @@ This automatic translation behavior may be undesirable in certain cases. For
 instance, when using a Label to display a player's name, you most likely don't
 want the player's name to be translated if it matches a translation key. To
 disable automatic translation on a specific node, use
-`Object.set_message_translation<class_Object_method_set_message_translation )`
-and send a `Object.notification<class_Object_method_notification )` to update the
+`Object.set_message_translation( Object_method_set_message_translation )`
+and send a `Object.notification( Object_method_notification )` to update the
 translation::
 
     func _ready():
@@ -143,4 +143,4 @@ For instance, for Spanish, this would be `application/name_es`:
 ![](img/localized_name.png)
 
 If you are unsure about the language code to use, refer to the
-`list of locale codes <doc_locales )`.
+`list of locale codes ( doc_locales )`.
diff --git a/tutorials/i18n/localization_using_gettext.md b/tutorials/i18n/localization_using_gettext.md
index 78efaf7..dca23f1 100644
--- a/tutorials/i18n/localization_using_gettext.md
+++ b/tutorials/i18n/localization_using_gettext.md
@@ -145,7 +145,7 @@ To register a messages file as a translation in a project, open the
 **Project Settings**, then go to the **Localization** tab.
 In **Translations**, click **Add…** then choose the `.po` or `.mo` file
 in the file dialog. The locale will be inferred from the
-`"Language: <code>\n"` property in the messages file.
+`"Language: ( code>\n"` property in the messages file.
 
 .. note:: See `doc_internationalizing_games` for more information on
           importing and testing translations in Godot.
diff --git a/tutorials/inputs/input_examples.md b/tutorials/inputs/input_examples.md
index 9f5730b..089dde6 100644
--- a/tutorials/inputs/input_examples.md
+++ b/tutorials/inputs/input_examples.md
@@ -150,7 +150,7 @@ gdscript GDScript
                 print("T was pressed")
 ```
 
-.. tip:: See `@GlobalScope_KeyList <enum_@GlobalScope_KeyList )` for a list of scancode
+.. tip:: See `@GlobalScope_KeyList ( enum_@GlobalScope_KeyList )` for a list of scancode
         constants.
 
 .. warning::
@@ -187,7 +187,7 @@ gdscript GDScript
                     print("T was pressed")
 ```
 
-.. tip:: See `@GlobalScope_KeyList <enum_@GlobalScope_KeyList )` for a list of scancode
+.. tip:: See `@GlobalScope_KeyList ( enum_@GlobalScope_KeyList )` for a list of scancode
         constants.
 
 Mouse events
@@ -201,7 +201,7 @@ means that all mouse events will contain a `position` property.
 Mouse buttons
 ~~~~~~~~~~~~~
 
-Capturing mouse buttons is very similar to handling key events. `@GlobalScope_ButtonList <enum_@GlobalScope_ButtonList )`
+Capturing mouse buttons is very similar to handling key events. `@GlobalScope_ButtonList ( enum_@GlobalScope_ButtonList )`
 contains a list of `BUTTON_*` constants for each possible button, which will
 be reported in the event's `button_index` property. Note that the scrollwheel
 also counts as a button - two buttons, to be precise, with both
@@ -240,7 +240,7 @@ gdscript GDScript
 
     func _input(event):
         if event is InputEventMouseButton and event.button_index == BUTTON_LEFT:
-            if (event.position - $Sprite.position).length() < click_radius:
+            if (event.position - $Sprite.position).length() (  click_radius:
                 # Start dragging if the click is on the sprite.
                 if not dragging and event.pressed:
                     dragging = true
diff --git a/tutorials/io/background_loading.md b/tutorials/io/background_loading.md
index 64dae2e..eafb494 100644
--- a/tutorials/io/background_loading.md
+++ b/tutorials/io/background_loading.md
@@ -30,7 +30,7 @@ Obtaining a ResourceInteractiveLoader
 
 .. code-block:: cpp
 
-    Ref<ResourceInteractiveLoader> ResourceLoader::load_interactive(String p_path);
+    Ref( ResourceInteractiveLoader> ResourceLoader::load_interactive(String p_path);
 
 This method will give you a ResourceInteractiveLoader that you will use
 to manage the load operation.
@@ -78,7 +78,7 @@ Obtaining the resource
 
 .. code-block:: cpp
 
-    Ref<Resource> ResourceInteractiveLoader::get_resource();
+    Ref( Resource> ResourceInteractiveLoader::get_resource();
 
 If everything goes well, use this method to retrieve your loaded
 resource.
@@ -153,7 +153,7 @@ precise control over the timings.
 
         var t = OS.get_ticks_msec()
         # Use "time_max" to control for how long we block this thread.
-        while OS.get_ticks_msec() < t + time_max:
+        while OS.get_ticks_msec() (  t + time_max:
             # Poll your loader.
             var err = loader.poll()
 
@@ -222,7 +222,7 @@ Example class
 -------------
 
 You can find an example class for loading resources in threads here:
-:download:`resource_queue.gd <files/resource_queue.gd )`. Usage is as follows:
+:download:`resource_queue.gd ( files/resource_queue.gd )`. Usage is as follows:
 
 ::
 
diff --git a/tutorials/io/binary_serialization_api.md b/tutorials/io/binary_serialization_api.md
index 7963519..11f69ff 100644
--- a/tutorials/io/binary_serialization_api.md
+++ b/tutorials/io/binary_serialization_api.md
@@ -95,7 +95,7 @@ precision.
 0: null
 ~~~~~~~
 
-1: `bool<class_bool )`
+1: `bool( bool )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+-----------+---------------------------+
@@ -104,7 +104,7 @@ precision.
 | 4        | 4     | Integer   | 0 for False, 1 for True   |
 +----------+-------+-----------+---------------------------+
 
-2: `int<class_int )`
+2: `int( int )`
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
 If no flags are set (flags == 0), the integer is sent as a 32 bit integer:
@@ -124,7 +124,7 @@ a 64-bit integer:
 | 4        | 8     | Integer   | 64-bit signed integer    |
 +----------+-------+-----------+--------------------------+
 
-3: `float<class_float )`
+3: `float( float )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 If no flags are set (flags == 0), the float is sent as a 32 bit single precision:
@@ -144,7 +144,7 @@ a 64-bit double precision number:
 | 4        | 8     | Float   | IEEE 754 double-precision float   |
 +----------+-------+---------+-----------------------------------+
 
-4: `String<class_string )`
+4: `String( string )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+-----------+----------------------------+
@@ -157,7 +157,7 @@ a 64-bit double precision number:
 
 This field is padded to 4 bytes.
 
-5: `Vector2<class_vector2 )`
+5: `Vector2( vector2 )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+---------+----------------+
@@ -168,7 +168,7 @@ This field is padded to 4 bytes.
 | 8        | 4     | Float   | Y coordinate   |
 +----------+-------+---------+----------------+
 
-6: `Rect2<class_rect2 )`
+6: `Rect2( rect2 )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+---------+----------------+
@@ -183,7 +183,7 @@ This field is padded to 4 bytes.
 | 16       | 4     | Float   | Y size         |
 +----------+-------+---------+----------------+
 
-7: `Vector3<class_vector3 )`
+7: `Vector3( vector3 )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+---------+----------------+
@@ -196,7 +196,7 @@ This field is padded to 4 bytes.
 | 12       | 4     | Float   | Z coordinate   |
 +----------+-------+---------+----------------+
 
-8: `Transform2D<class_transform2d )`
+8: `Transform2D( transform2d )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+---------+---------------------------------------------------------------+
@@ -215,7 +215,7 @@ This field is padded to 4 bytes.
 | 24       | 4     | Float   | The Y component of the origin vector, accessed via [2][1]     |
 +----------+-------+---------+---------------------------------------------------------------+
 
-9: `Plane<class_plane )`
+9: `Plane( plane )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+---------+---------------+
@@ -230,7 +230,7 @@ This field is padded to 4 bytes.
 | 16       | 4     | Float   | Distance      |
 +----------+-------+---------+---------------+
 
-10: `Quat<class_quat )`
+10: `Quat( quat )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+---------+---------------+
@@ -245,7 +245,7 @@ This field is padded to 4 bytes.
 | 16       | 4     | Float   | Real W        |
 +----------+-------+---------+---------------+
 
-11: `AABB<class_aabb )`
+11: `AABB( aabb )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+---------+----------------+
@@ -264,7 +264,7 @@ This field is padded to 4 bytes.
 | 24       | 4     | Float   | Z size         |
 +----------+-------+---------+----------------+
 
-12: `Basis<class_basis )`
+12: `Basis( basis )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+---------+---------------------------------------------------------------+
@@ -289,7 +289,7 @@ This field is padded to 4 bytes.
 | 36       | 4     | Float   | The Z component of the Z column vector, accessed via [2][2]   |
 +----------+-------+---------+---------------------------------------------------------------+
 
-13: `Transform<class_transform )`
+13: `Transform( transform )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+---------+---------------------------------------------------------------+
@@ -320,7 +320,7 @@ This field is padded to 4 bytes.
 | 48       | 4     | Float   | The Z component of the origin vector, accessed via [3][2]     |
 +----------+-------+---------+---------------------------------------------------------------+
 
-14: `Color<class_color )`
+14: `Color( color )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+---------+--------------------------------------------------------------+
@@ -335,7 +335,7 @@ This field is padded to 4 bytes.
 | 16       | 4     | Float   | Alpha (0..1)                                                 |
 +----------+-------+---------+--------------------------------------------------------------+
 
-15: `NodePath<class_nodepath )`
+15: `NodePath( nodepath )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+-----------+-----------------------------------------------------------------------------------------+
@@ -378,13 +378,13 @@ For each Name and Sub-Name
 
 Every name string is padded to 4 bytes.
 
-16: `RID<class_rid )` (unsupported)
+16: `RID( rid )` (unsupported)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-17: `Object<class_object )` (unsupported)
+17: `Object( object )` (unsupported)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-18: `Dictionary<class_dictionary )`
+18: `Dictionary( dictionary )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+-----------+---------------------------------------------------------------------+
@@ -396,7 +396,7 @@ Every name string is padded to 4 bytes.
 Then what follows is, for amount of "elements", pairs of key and value,
 one after the other, using this same format.
 
-19: `Array<class_array )`
+19: `Array( array )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+-----------+---------------------------------------------------------------------+
@@ -408,7 +408,7 @@ one after the other, using this same format.
 Then what follows is, for amount of "elements", values one after the
 other, using this same format.
 
-20: `PoolByteArray<class_poolbytearray )`
+20: `PoolByteArray( poolbytearray )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +---------------+-------+-----------+------------------------+
@@ -421,7 +421,7 @@ other, using this same format.
 
 The array data is padded to 4 bytes.
 
-21: `PoolIntArray<class_poolintarray )`
+21: `PoolIntArray( poolintarray )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +------------------+-------+-----------+---------------------------+
@@ -432,7 +432,7 @@ The array data is padded to 4 bytes.
 | 8..8+length\*4   | 4     | Integer   | 32-bit signed integer     |
 +------------------+-------+-----------+---------------------------+
 
-22: `PoolRealArray<class_poolrealarray )`
+22: `PoolRealArray( poolrealarray )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +------------------+-------+-----------+---------------------------+
@@ -443,7 +443,7 @@ The array data is padded to 4 bytes.
 | 8..8+length\*4   | 4     | Integer   | 32-bits IEEE 754 float    |
 +------------------+-------+-----------+---------------------------+
 
-23: `PoolStringArray<class_poolstringarray )`
+23: `PoolStringArray( poolstringarray )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +----------+-------+-----------+--------------------------+
@@ -464,7 +464,7 @@ For each String:
 
 Every string is padded to 4 bytes.
 
-24: `PoolVector2Array<class_poolvector2array )`
+24: `PoolVector2Array( poolvector2array )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +-------------------+-------+-----------+----------------+
@@ -477,7 +477,7 @@ Every string is padded to 4 bytes.
 | 8..12+length\*8   | 4     | Float     | Y coordinate   |
 +-------------------+-------+-----------+----------------+
 
-25: `PoolVector3Array<class_poolvector3array )`
+25: `PoolVector3Array( poolvector3array )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +--------------------+-------+-----------+----------------+
@@ -492,7 +492,7 @@ Every string is padded to 4 bytes.
 | 8..16+length\*12   | 4     | Float     | Z coordinate   |
 +--------------------+-------+-----------+----------------+
 
-26: `PoolColorArray<class_poolcolorarray )`
+26: `PoolColorArray( poolcolorarray )`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 +--------------------+-------+-----------+--------------------------------------------------------------+
diff --git a/tutorials/io/data_paths.md b/tutorials/io/data_paths.md
index 8786503..88e0716 100644
--- a/tutorials/io/data_paths.md
+++ b/tutorials/io/data_paths.md
@@ -52,7 +52,7 @@ The location of the `user://` folder depends on what is configured in the
 Project Settings:
 
 - By default, the `user://` folder is created within Godot's
-  `editor data path <doc_data_paths_editor_data_paths )` in the
+  `editor data path ( doc_data_paths_editor_data_paths )` in the
   `app_userdata/[project_name]` folder. This is the default so that prototypes
   and test projects stay self-contained within Godot's data folder.
 - If `application/config/use_custom_user_dir`
@@ -85,7 +85,7 @@ On desktop platforms, the actual directory paths for `user://` are:
 +---------------------+------------------------------------------------------------------------------+
 
 `[project_name]` is based on the application name defined in the Project Settings, but
-you can override it on a per-platform basis using `feature tags <doc_feature_tags )`.
+you can override it on a per-platform basis using `feature tags ( doc_feature_tags )`.
 
 On mobile platforms, this path is unique to the project and is not accessible
 by other applications for security reasons.
diff --git a/tutorials/io/saving_games.md b/tutorials/io/saving_games.md
index 27b6be1..3bf2b1a 100644
--- a/tutorials/io/saving_games.md
+++ b/tutorials/io/saving_games.md
@@ -49,8 +49,8 @@ The next step is to serialize the data. This makes it much easier to
 read from and store to disk. In this case, we're assuming each member of
 group Persist is an instanced node and thus has a path. GDScript
 has helper functions for this, such as `to_json()
-<class_@GDScript_method_to_json )` and `parse_json()
-<class_@GDScript_method_parse_json )`, so we will use a dictionary. Our node needs to
+( @GDScript_method_to_json )` and `parse_json()
+( @GDScript_method_parse_json )`, so we will use a dictionary. Our node needs to
 contain a save function that returns this data. The save function will look
 like this:
 
@@ -92,7 +92,7 @@ Saving and reading data
 As covered in the `doc_filesystem` tutorial, we'll need to open a file
 so we can write to it or read from it. Now that we have a way to
 call our groups and get their relevant data, let's use `to_json()
-<class_@GDScript_method_to_json )` to
+( @GDScript_method_to_json )` to
 convert it into an easily stored string and store them in a file. Doing
 it this way ensures that each line is its own object, so we have an easy
 way to pull the data out of the file as well.
@@ -189,7 +189,7 @@ Additionally, our implementation assumes no Persist objects are children of othe
 Persist objects. Otherwise, invalid paths would be created. To
 accommodate nested Persist objects, consider saving objects in stages.
 Load parent objects first so they are available for the `add_child()
-<class_node_method_add_child )`
+( node_method_add_child )`
 call when child objects are loaded. You will also need a way to link
 children to parents as the `NodePath
-<class_nodepath )` will likely be invalid.
+( nodepath )` will likely be invalid.
diff --git a/tutorials/math/beziers_and_curves.md b/tutorials/math/beziers_and_curves.md
index e934839..54fe54b 100644
--- a/tutorials/math/beziers_and_curves.md
+++ b/tutorials/math/beziers_and_curves.md
@@ -10,7 +10,7 @@ high level of flexibility.
 Unlike more abstract mathematical concepts, Bezier curves were created for
 industrial design. They are a popular tool in the graphics software industry.
 
-They rely on `interpolation<doc_interpolation )`, which we saw in the
+They rely on `interpolation( doc_interpolation )`, which we saw in the
 previous article, combining multiple steps to create smooth curves. To better
 understand how Bezier curves work, let's start from its simplest form: Quadratic
 Bezier.
@@ -197,8 +197,8 @@ Traversal
 
 The last common use case for the curves is to traverse them. Because of what was mentioned before regarding constant speed, this is also difficult.
 
-To make this easier, the curves need to be *baked* into equidistant points. This way, they can be approximated with regular interpolation (which can be improved further with a cubic option). To do this, just use the `Curve.interpolate_baked()<class_Curve_method_interpolate_baked )` method together with
-`Curve2D.get_baked_length()<class_Curve2D_method_get_baked_length )`. The first call to either of them will bake the curve internally.
+To make this easier, the curves need to be *baked* into equidistant points. This way, they can be approximated with regular interpolation (which can be improved further with a cubic option). To do this, just use the `Curve.interpolate_baked()( Curve_method_interpolate_baked )` method together with
+`Curve2D.get_baked_length()( Curve2D_method_get_baked_length )`. The first call to either of them will bake the curve internally.
 
 Traversal at constant speed, then, can be done with the following pseudo-code:
 
diff --git a/tutorials/math/interpolation.md b/tutorials/math/interpolation.md
index 052c828..fc8eaa1 100644
--- a/tutorials/math/interpolation.md
+++ b/tutorials/math/interpolation.md
@@ -23,7 +23,7 @@ And often simplified to:
 
 The name of this type of interpolation, which transforms a value into another at *constant speed* is *"linear"*. So, when you hear about *Linear Interpolation*, you know they are referring to this simple formula.
 
-There are other types of interpolations, which will not be covered here. A recommended read afterwards is the `Bezier <doc_beziers_and_curves )` page.
+There are other types of interpolations, which will not be covered here. A recommended read afterwards is the `Bezier ( doc_beziers_and_curves )` page.
 
 Vector interpolation
 --------------------
diff --git a/tutorials/math/random_number_generation.md b/tutorials/math/random_number_generation.md
index 9f72715..0a81563 100644
--- a/tutorials/math/random_number_generation.md
+++ b/tutorials/math/random_number_generation.md
@@ -27,8 +27,8 @@ Global scope methods are easier to set up, but they don't offer as much control.
 
 RandomNumberGenerator requires more code to use, but exposes many methods not
 found in global scope such as `randi_range()
-<class_RandomNumberGenerator_method_randi_range )` and `randfn()
-<class_RandomNumberGenerator_method_randfn )`. On top of that, it allows creating
+( RandomNumberGenerator_method_randi_range )` and `randfn()
+( RandomNumberGenerator_method_randfn )`. On top of that, it allows creating
 multiple instances each with their own seed.
 
 This tutorial uses global scope methods, except when the method only exists in
@@ -38,7 +38,7 @@ The randomize() method
 ----------------------
 
 In global scope, you can find a `randomize()
-<class_@GDScript_method_randomize )` method. **This method should be called only
+( @GDScript_method_randomize )` method. **This method should be called only
 once when your project starts to initialize the random seed.** Calling it
 multiple times is unnecessary and may impact performance negatively.
 
@@ -52,7 +52,7 @@ gdscript GDScript
 ```
 
 You can also set a fixed random seed instead using `seed()
-<class_@GDScript_method_seed )`. Doing so will give you *deterministic* results
+( @GDScript_method_seed )`. Doing so will give you *deterministic* results
 across runs:
 
 gdscript GDScript
@@ -129,7 +129,7 @@ gdscript GDScript
 ```
 
 `RandomNumberGenerator.randi_range()
-<class_RandomNumberGenerator_method_randi_range )` takes two arguments `from`
+( RandomNumberGenerator_method_randi_range )` takes two arguments `from`
 and `to`, and returns a random integer between `from` and `to`:
 
 gdscript GDScript
@@ -203,7 +203,7 @@ gdscript GDScript
 This approach can be useful to make random number generation feel less
 repetitive. Still, it doesn't prevent results from "ping-ponging" between a
 limited set of values. To prevent this, use the `shuffle bag
-<doc_random_number_generation_shuffle_bags )` pattern instead.
+( doc_random_number_generation_shuffle_bags )` pattern instead.
 
 Get a random dictionary value
 -----------------------------
diff --git a/tutorials/navigation/real_time_navigation_3d.md b/tutorials/navigation/real_time_navigation_3d.md
index f384e9f..3d256e8 100644
--- a/tutorials/navigation/real_time_navigation_3d.md
+++ b/tutorials/navigation/real_time_navigation_3d.md
@@ -10,10 +10,10 @@ Pathfinding in a 3D environment is crucial for many games, it's commonly
 how non directly controlled characters or entities find their way around
 an environment. Godot provides several nodes for this purpose:
 
--  `Navigation<class_Navigation )` (deprecated)
--  `NavigationMeshInstance<class_NavigationMeshInstance )`
--  `NavigationAgent<class_NavigationAgent )`
--  `NavigationObstacle<class_NavigationObstacle )`
+-  `Navigation( Navigation )` (deprecated)
+-  `NavigationMeshInstance( NavigationMeshInstance )`
+-  `NavigationAgent( NavigationAgent )`
+-  `NavigationObstacle( NavigationObstacle )`
 
 The map and navigation regions
 ------------------------------
@@ -23,12 +23,12 @@ the physics engine. It's comprised of navigation regions, these regions
 define parts of the world that can be navigated around by navigation
 agents.
 
-To create a navigation region add the `NavigationMeshInstance<class_NavigationMeshInstance )`
+To create a navigation region add the `NavigationMeshInstance( NavigationMeshInstance )`
 node to a 3D scene. Next in the inspector for that mesh create or add a
-`NavigationMesh<class_NavigationMesh )`. The navmesh contains options
+`NavigationMesh( NavigationMesh )`. The navmesh contains options
 for how it will be generated when it's baked. The geometry options control
 which nodes, and types of nodes, are used to bake the mesh. A full
-description of each setting and how it works can be found in the `NavigationMesh class reference<class_NavigationMesh )`.
+description of each setting and how it works can be found in the `NavigationMesh class reference( NavigationMesh )`.
 
 Once the settings have been properly configured press the "Bake NavMesh"
 button at the top of the inspector to generate it.
@@ -79,7 +79,7 @@ with `set_velocity`. Then a new velocity that takes into account other
 agents and obstacles is generated and emitted with the signal `velocity_computed`.
 
 However agents can only take into account a set number of other nearby
-agents, this is the `max neighbors<class_NavigationAgent_property_max_neighbors )`
+agents, this is the `max neighbors( NavigationAgent_property_max_neighbors )`
 property of an agent and can be adjusted. This is **not** a limit for
 how many agents can use a navigation region at the same time.
 
diff --git a/tutorials/networking/high_level_multiplayer.md b/tutorials/networking/high_level_multiplayer.md
index 60d2eea..72c1385 100644
--- a/tutorials/networking/high_level_multiplayer.md
+++ b/tutorials/networking/high_level_multiplayer.md
@@ -262,7 +262,7 @@ If `sync` is included, the call can also be made locally. For example, to allow
 
 .. tip:: You can also use `SceneTree.get_rpc_sender_id()` to have more advanced rules on how an rpc can be called.
 
-These keywords are further explained in `Synchronizing the game <doc_high_level_multiplayer_synchronizing )`.
+These keywords are further explained in `Synchronizing the game ( doc_high_level_multiplayer_synchronizing )`.
 
 With this, lobby management should be more or less explained. Once you have your game going, you will most likely want to add some
 extra security to make sure clients don't do anything funny (just validate the info they send from time to time, or before
diff --git a/tutorials/networking/http_client_class.md b/tutorials/networking/http_client_class.md
index c2794d1..6c2f6e0 100644
--- a/tutorials/networking/http_client_class.md
+++ b/tutorials/networking/http_client_class.md
@@ -5,7 +5,7 @@ HTTP client class
 
 `HTTPClient` provides low-level access to HTTP communication.
 For a higher-level interface, you may want to take a look at `HTTPRequest` first,
-which has a tutorial available `here <doc_http_request_class )`.
+which has a tutorial available `here ( doc_http_request_class )`.
 
 .. warning::
 
diff --git a/tutorials/networking/http_request_class.md b/tutorials/networking/http_request_class.md
index 20bc8e5..4bd2d96 100644
--- a/tutorials/networking/http_request_class.md
+++ b/tutorials/networking/http_request_class.md
@@ -61,7 +61,7 @@ gdscript GDScript
         $HTTPRequest.request("http://www.mocky.io/v2/5185415ba171ea3a00704eed", ["user-agent: YourCustomUserAgent"])
 ```
 
-Please note that, for SSL/TLS encryption and thus HTTPS URLs to work, you may need to take some steps as described `here <doc_ssl_certificates )`.
+Please note that, for SSL/TLS encryption and thus HTTPS URLs to work, you may need to take some steps as described `here ( doc_ssl_certificates )`.
 
 Also, when calling APIs using authorization, be aware that someone might analyse and decompile your released application and thus may gain access to any embedded authorization information like tokens, usernames or passwords.
 That means it is usually not a good idea to embed things such as database access credentials inside your game. Avoid providing information useful to an attacker whenever possible.
diff --git a/tutorials/networking/webrtc.md b/tutorials/networking/webrtc.md
index a16d4f5..cc23c23 100644
--- a/tutorials/networking/webrtc.md
+++ b/tutorials/networking/webrtc.md
@@ -105,7 +105,7 @@ This will print:
 Local signaling example
 ^^^^^^^^^^^^^^^^^^^^^^^
 
-This example expands on the previous one, separating the peers in two different scenes, and using a `singleton <doc_singletons_autoload )` as a signaling server.
+This example expands on the previous one, separating the peers in two different scenes, and using a `singleton ( doc_singletons_autoload )` as a signaling server.
 
 ::
 
@@ -147,7 +147,7 @@ This example expands on the previous one, separating the peers in two different
 
 And now for the local signaling server:
 
-.. note:: This local signaling server is supposed to be used as a `singleton <doc_singletons_autoload )` to connect two peers in the same scene.
+.. note:: This local signaling server is supposed to be used as a `singleton ( doc_singletons_autoload )` to connect two peers in the same scene.
 
 ::
 
diff --git a/tutorials/networking/websocket.md b/tutorials/networking/websocket.md
index f82dd40..0af12d4 100644
--- a/tutorials/networking/websocket.md
+++ b/tutorials/networking/websocket.md
@@ -9,7 +9,7 @@ HTML5 and WebSocket
 The WebSocket protocol was standardized in 2011 with the original goal of allowing browsers to create stable and bidirectional connections with a server.
 Before that, browsers used to only support HTTPRequests, which is not well-suited for bidirectional communication.
 
-The protocol is quite simple, message based, and a very powerful tool to send push notifications to browsers, and has been used to implement chats, turn-based games, etc. It still uses a TCP connection, which is good for reliability but not for latency, so not good for real-time applications like VoIP and fast-paced games (see `WebRTC <doc_webrtc )` for those use cases).
+The protocol is quite simple, message based, and a very powerful tool to send push notifications to browsers, and has been used to implement chats, turn-based games, etc. It still uses a TCP connection, which is good for reliability but not for latency, so not good for real-time applications like VoIP and fast-paced games (see `WebRTC ( doc_webrtc )` for those use cases).
 
 Due to its simplicity, its wide compatibility, and being easier to use than a raw TCP connection, WebSocket soon started to spread outside the browsers, in native applications as a mean to communicate with network servers.
 
diff --git a/tutorials/performance/batching.md b/tutorials/performance/batching.md
index edf6725..6dbccfc 100644
--- a/tutorials/performance/batching.md
+++ b/tutorials/performance/batching.md
@@ -231,7 +231,7 @@ area between a light and a primitive, and limit rendering the light to
 *that area only*.
 
 Light scissoring is controlled with the `scissor_area_threshold
-<class_ProjectSettings_property_rendering/batching/lights/scissor_area_threshold )`
+( ProjectSettings_property_rendering/batching/lights/scissor_area_threshold )`
 project setting. This value is between 1.0 and 0.0, with 1.0 being off (no
 scissoring), and 0.0 being scissoring in every circumstance. The reason for the
 setting is that there may be some small cost to scissoring on some hardware.
@@ -537,7 +537,7 @@ Light scissoring threshold calculation
 
 The actual proportion of screen pixel area used as the threshold is the
 `scissor_area_threshold
-<class_ProjectSettings_property_rendering/batching/lights/scissor_area_threshold )`
+( ProjectSettings_property_rendering/batching/lights/scissor_area_threshold )`
 value to the power of 4.
 
 For example, on a screen size of 1920×1080, there are 2,073,600 pixels.
@@ -548,11 +548,11 @@ At a threshold of 1,000 pixels, the proportion would be::
     0.00048225 ^ (1/4) = 0.14819
 
 So a `scissor_area_threshold
-<class_ProjectSettings_property_rendering/batching/lights/scissor_area_threshold )`
+( ProjectSettings_property_rendering/batching/lights/scissor_area_threshold )`
 of `0.15` would be a reasonable value to try.
 
 Going the other way, for instance with a `scissor_area_threshold
-<class_ProjectSettings_property_rendering/batching/lights/scissor_area_threshold )`
+( ProjectSettings_property_rendering/batching/lights/scissor_area_threshold )`
 of `0.5`::
 
     0.5 ^ 4 = 0.0625
diff --git a/tutorials/performance/cpu_optimization.md b/tutorials/performance/cpu_optimization.md
index 3319a02..067758f 100644
--- a/tutorials/performance/cpu_optimization.md
+++ b/tutorials/performance/cpu_optimization.md
@@ -199,7 +199,7 @@ Godot is written in C++. Using C++ will usually result in the fastest code.
 However, on a practical level, it is the most difficult to deploy to end users'
 machines on different platforms. Options for using C++ include
 `GDNative <toc-tutorials-gdnative )` and
-`custom modules <doc_custom_modules_in_c++ )`.
+`custom modules ( doc_custom_modules_in_c++ )`.
 
 Threads
 =======
diff --git a/tutorials/performance/gpu_optimization.md b/tutorials/performance/gpu_optimization.md
index 2d9331a..1c40da9 100644
--- a/tutorials/performance/gpu_optimization.md
+++ b/tutorials/performance/gpu_optimization.md
@@ -80,7 +80,7 @@ Reuse Shaders and Materials
 
 The Godot renderer is a little different to what is out there. It's designed to
 minimize GPU state changes as much as possible. `SpatialMaterial
-<class_SpatialMaterial )` does a good job at reusing materials that need similar
+( SpatialMaterial )` does a good job at reusing materials that need similar
 shaders. If custom shaders are used, make sure to reuse them as much as
 possible. Godot's priorities are:
 
@@ -176,7 +176,7 @@ elsewhere.
 You can increase performance in a fill rate-limited project by reducing the
 amount of work the GPU has to do. You can do this by simplifying the shader
 (perhaps turn off expensive options if you are using a `SpatialMaterial
-<class_SpatialMaterial )`), or reducing the number and size of textures used.
+( SpatialMaterial )`), or reducing the number and size of textures used.
 
 **When targeting mobile devices, consider using the simplest possible shaders
 you can reasonably afford to use.**
diff --git a/tutorials/performance/optimizing_3d_performance.md b/tutorials/performance/optimizing_3d_performance.md
index a73bad2..c305491 100644
--- a/tutorials/performance/optimizing_3d_performance.md
+++ b/tutorials/performance/optimizing_3d_performance.md
@@ -72,14 +72,14 @@ Transparent objects
 ~~~~~~~~~~~~~~~~~~~
 
 Godot sorts objects by `Material` and `Shader
-<class_Shader )` to improve performance. This, however, can not be done with
+( Shader )` to improve performance. This, however, can not be done with
 transparent objects. Transparent objects are rendered from back to front to make
 blending with what is behind work. As a result,
 **try to use as few transparent objects as possible**. If an object has a
 small section with transparency, try to make that section a separate surface
 with its own material.
 
-For more information, see the `GPU optimizations <doc_gpu_optimization )`
+For more information, see the `GPU optimizations ( doc_gpu_optimization )`
 doc.
 
 Level of detail (LOD)
@@ -121,7 +121,7 @@ of many thousands of objects at very little performance cost, making it ideal
 for flocks, grass, particles, and anything else where you have thousands of
 identical objects.
 
-Also see the `Using MultiMesh <doc_using_multimesh )` doc.
+Also see the `Using MultiMesh ( doc_using_multimesh )` doc.
 
 Bake lighting
 =============
diff --git a/tutorials/performance/threads/thread_safe_apis.md b/tutorials/performance/threads/thread_safe_apis.md
index 44d1804..22cbe38 100644
--- a/tutorials/performance/threads/thread_safe_apis.md
+++ b/tutorials/performance/threads/thread_safe_apis.md
@@ -14,7 +14,7 @@ Below is a list of ways multithreading can be used in different areas of Godot.
 Global scope
 ------------
 
-`Global Scope<class_@GlobalScope )` singletons are all thread-safe. Accessing servers from threads is supported (for VisualServer and Physics servers, ensure threaded or thread-safe operation is enabled in the project settings!).
+`Global Scope( @GlobalScope )` singletons are all thread-safe. Accessing servers from threads is supported (for VisualServer and Physics servers, ensure threaded or thread-safe operation is enabled in the project settings!).
 
 This makes them ideal for code that creates dozens of thousands of instances in servers and controls them from threads. Of course, it requires a bit more code, as this is used directly and not within the scene tree.
 
diff --git a/tutorials/performance/threads/using_multiple_threads.md b/tutorials/performance/threads/using_multiple_threads.md
index bb8fbd3..a4dd299 100644
--- a/tutorials/performance/threads/using_multiple_threads.md
+++ b/tutorials/performance/threads/using_multiple_threads.md
@@ -51,7 +51,7 @@ gdscript GDScript
 
 Your function will, then, run in a separate thread until it returns.
 Even if the function has returned already, the thread must collect it, so call
-`Thread.wait_to_finish()<class_Thread_method_wait_to_finish )`, which will
+`Thread.wait_to_finish()( Thread_method_wait_to_finish )`, which will
 wait until the thread is done (if not done yet), then properly dispose of it.
 
 Mutexes
@@ -65,13 +65,13 @@ support multiple thread access.
 When processing your own data or calling your own functions, as a rule, try to
 avoid accessing the same data directly from different threads. You may run into
 synchronization problems, as the data is not always updated between CPU cores
-when modified. Always use a `Mutex<class_Mutex )` when accessing
+when modified. Always use a `Mutex( Mutex )` when accessing
 a piece of data from different threads.
 
-When calling `Mutex.lock()<class_Mutex_method_lock )`, a thread ensures that
+When calling `Mutex.lock()( Mutex_method_lock )`, a thread ensures that
 all other threads will be blocked (put on suspended state) if they try to *lock*
 the same mutex. When the mutex is unlocked by calling
-`Mutex.unlock()<class_Mutex_method_unlock )`, the other threads will be
+`Mutex.unlock()( Mutex_method_unlock )`, the other threads will be
 allowed to proceed with the lock (but only one at a time).
 
 Here is an example of using a Mutex:
@@ -114,12 +114,12 @@ Semaphores
 
 Sometimes you want your thread to work *"on demand"*. In other words, tell it
 when to work and let it suspend when it isn't doing anything.
-For this, `Semaphores<class_Semaphore )` are used. The function
-`Semaphore.wait()<class_Semaphore_method_wait )` is used in the thread to
+For this, `Semaphores( Semaphore )` are used. The function
+`Semaphore.wait()( Semaphore_method_wait )` is used in the thread to
 suspend it until some data arrives.
 
 The main thread, instead, uses
-`Semaphore.post()<class_Semaphore_method_post )` to signal that data is
+`Semaphore.post()( Semaphore_method_post )` to signal that data is
 ready to be processed:
 
 gdscript GDScript
diff --git a/tutorials/performance/using_multimesh.md b/tutorials/performance/using_multimesh.md
index 81e5c9b..6801593 100644
--- a/tutorials/performance/using_multimesh.md
+++ b/tutorials/performance/using_multimesh.md
@@ -5,7 +5,7 @@ Optimization using MultiMeshes
 
 For large amount of instances (in the thousands), that need to be constantly processed
 (and certain amount of control needs to be retained),
-`using servers directly <doc_using_servers )` is the recommended optimization.
+`using servers directly ( doc_using_servers )` is the recommended optimization.
 
 When the amount of objects reach the hundreds of thousands or millions,
 none of these approaches are efficient anymore. Still, depending on the requirements, there
@@ -14,7 +14,7 @@ is one more optimization possible.
 MultiMeshes
 -----------
 
-A `MultiMesh<class_MultiMesh )` is a single draw primitive that can draw up to millions
+A `MultiMesh( MultiMesh )` is a single draw primitive that can draw up to millions
 of objects in one go. It's extremely efficient because it uses the GPU hardware to do this
 (in OpenGL ES 2.0, it's less efficient because there is no hardware support for it, though).
 
@@ -29,8 +29,8 @@ for different areas of the world.
 
 It is also possible to execute some logic inside the vertex shader (using the `INSTANCE_ID` or
 `INSTANCE_CUSTOM` built-in constants). For an example of animating thousands of objects in a MultiMesh,
-see the `Animating thousands of fish <doc_animating_thousands_of_fish )` tutorial. Information
-to the shader can be provided via textures (there are floating-point `Image<class_Image )` formats
+see the `Animating thousands of fish ( doc_animating_thousands_of_fish )` tutorial. Information
+to the shader can be provided via textures (there are floating-point `Image( Image )` formats
 which are ideal for this).
 
 Another alternative is to use GDNative and C++, which should be extremely efficient (it's possible
diff --git a/tutorials/performance/using_servers.md b/tutorials/performance/using_servers.md
index 1d6ac5a..2471dcd 100644
--- a/tutorials/performance/using_servers.md
+++ b/tutorials/performance/using_servers.md
@@ -4,7 +4,7 @@ Optimization using Servers
 ==========================
 
 Engines like Godot provide increased ease of use thanks to their high level constructs and features.
-Most of them are accessed and used via the `Scene System<doc_scene_tree )`. Using nodes and
+Most of them are accessed and used via the `Scene System( doc_scene_tree )`. Using nodes and
 resources simplifies project organization and asset management in complex games.
 
 There are, of course, always drawbacks:
@@ -73,7 +73,7 @@ For nodes, there are many functions available:
   and `CanvasItem` nodes)
   contains functions to get the *VisualServer Canvas*, and the *Physics2DServer Space*. This
   allows creating 2D objects directly with the server API and using them.
-* The `VisualInstance<class_VisualInstance )` class, allows getting the scenario *instance* and
+* The `VisualInstance( VisualInstance )` class, allows getting the scenario *instance* and
   *instance base* via the `VisualInstance.get_instance()`
   and `VisualInstance.get_base()` respectively.
 
diff --git a/tutorials/performance/vertex_animation/animating_thousands_of_fish.md b/tutorials/performance/vertex_animation/animating_thousands_of_fish.md
index 81b6b8f..1af8f99 100644
--- a/tutorials/performance/vertex_animation/animating_thousands_of_fish.md
+++ b/tutorials/performance/vertex_animation/animating_thousands_of_fish.md
@@ -212,7 +212,7 @@ Now, set `instance_count` to the number of fish you want to have.
 Next we need to set the per-instance transforms.
 
 There are two ways to set per-instance transforms for MultiMeshes. The first is entirely in editor
-and is described in the `MultiMeshInstance tutorial <doc_using_multi_mesh_instance )`.
+and is described in the `MultiMeshInstance tutorial ( doc_using_multi_mesh_instance )`.
 
 The second is to loop over all the instances and set their transforms in code. Below, we use GDScript
 to loop over all the instances and set their transform to a random position.
diff --git a/tutorials/performance/vertex_animation/controlling_thousands_of_fish.md b/tutorials/performance/vertex_animation/controlling_thousands_of_fish.md
index 82ea6bd..17ac297 100644
--- a/tutorials/performance/vertex_animation/controlling_thousands_of_fish.md
+++ b/tutorials/performance/vertex_animation/controlling_thousands_of_fish.md
@@ -140,5 +140,5 @@ This code gives you the following behavior:
 
 Using a ParticlesMaterial you can make the fish behavior as simple or complex as you like. In this
 tutorial we only set Velocity, but in your own Shaders you can also set `COLOR`, rotation, scale
-(through `TRANSFORM`). Please refer to the `Particles Shader Reference <doc_particle_shader )`
+(through `TRANSFORM`). Please refer to the `Particles Shader Reference ( doc_particle_shader )`
 for more information on particle shaders.
diff --git a/tutorials/physics/interpolation/advanced_physics_interpolation.md b/tutorials/physics/interpolation/advanced_physics_interpolation.md
index 6ab4a25..eaa22c8 100644
--- a/tutorials/physics/interpolation/advanced_physics_interpolation.md
+++ b/tutorials/physics/interpolation/advanced_physics_interpolation.md
@@ -8,16 +8,16 @@ Although the previous instructions will give satisfactory results in a lot of ga
 Exceptions to automatic physics interpolation
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Even with physics interpolation active, there may be some local situations where you would benefit from disabling automatic interpolation for a `Node<class_Node )` (or branch of the `SceneTree<class_SceneTree )`), and have the finer control of performing interpolation manually.
+Even with physics interpolation active, there may be some local situations where you would benefit from disabling automatic interpolation for a `Node( Node )` (or branch of the `SceneTree( SceneTree )`), and have the finer control of performing interpolation manually.
 
-This is possible using the `Node.physics_interpolation_mode<class_Node_property_physics_interpolation_mode )` property which is present in all Nodes. If you for example, turn off interpolation for a Node, the children will recursively also be affected (as they default to inheriting the parent setting). This means you can easily disable interpolation for an entire subscene.
+This is possible using the `Node.physics_interpolation_mode( Node_property_physics_interpolation_mode )` property which is present in all Nodes. If you for example, turn off interpolation for a Node, the children will recursively also be affected (as they default to inheriting the parent setting). This means you can easily disable interpolation for an entire subscene.
 
 The most common situation where you may want to perform your own interpolation is Cameras.
 
 Cameras
 ^^^^^^^
 
-In many cases, a `Camera<class_Camera )` can use automatic interpolation just like any other node. However, for best results, especially at low physics tick rates, it is recommended that you take a manual approach to Camera interpolation.
+In many cases, a `Camera( Camera )` can use automatic interpolation just like any other node. However, for best results, especially at low physics tick rates, it is recommended that you take a manual approach to Camera interpolation.
 
 This is because viewers are very sensitive to Camera movement. For instance, a Camera that realigns slightly every 1/10th of a second (at 10tps tick rate) will often be noticeable. You can get a much smoother result by moving the Camera each frame in `_process`, and following an interpolated target manually.
 
@@ -34,7 +34,7 @@ There are two ways of doing this:
 
 ![](img/fti_camera_worldspace.png)
 
-2) Call `Spatial.set_as_toplevel<class_Spatial_method_set_as_toplevel )` and set this to `true`, which will make the Camera ignore the transform of its parent.
+2) Call `Spatial.set_as_toplevel( Spatial_method_set_as_toplevel )` and set this to `true`, which will make the Camera ignore the transform of its parent.
 
 Typical example
 ^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ get_global_transform_interpolated()
 
 What we really want to focus the Camera on, is not the position of the target on the physics tick, but the *interpolated* position, i.e. the position at which the target will be rendered.
 
-We can do this using the `Spatial.get_global_transform_interpolated<class_Spatial_method_get_global_transform_interpolated )` function. This acts exactly like getting `Spatial.global_transform<class_Spatial_property_global_transform )` but it gives you the *interpolated* transform (during a `_process()` call).
+We can do this using the `Spatial.get_global_transform_interpolated( Spatial_method_get_global_transform_interpolated )` function. This acts exactly like getting `Spatial.global_transform( Spatial_property_global_transform )` but it gives you the *interpolated* transform (during a `_process()` call).
 
 .. important:: `get_global_transform_interpolated()` should only be used once or twice for special cases such as Cameras. It should **not** be used all over the place in your code (both for performance reasons, and to give correct gameplay).
 
@@ -93,12 +93,12 @@ Mouse look
 
 Mouse look is a very common way of controlling Cameras. But there is a problem. Unlike keyboard input which can be sampled periodically on the physics tick, mouse move events can come in continuously. The Camera will be expected to react and follow these mouse movements on the next frame, rather than waiting until the next physics tick.
 
-In this situation, it can be better to disable physics interpolation for the Camera node (using `Node.physics_interpolation_mode<class_Node_property_physics_interpolation_mode )`) and directly apply the mouse input to the Camera rotation, rather than apply it in `_physics_process`.
+In this situation, it can be better to disable physics interpolation for the Camera node (using `Node.physics_interpolation_mode( Node_property_physics_interpolation_mode )`) and directly apply the mouse input to the Camera rotation, rather than apply it in `_physics_process`.
 
 Sometimes, especially with Cameras, you will want to use a combination of interpolation and non-interpolation:
 
-* A first person camera may position the camera at a player location (perhaps using `Spatial.get_global_transform_interpolated<class_Spatial_method_get_global_transform_interpolated )`), but control the Camera rotation from mouse look *without* interpolation.
-* A third person camera may similarly determine the look at (target location) of the camera using `Spatial.get_global_transform_interpolated<class_Spatial_method_get_global_transform_interpolated )`, but position the camera using mouse look *without* interpolation.
+* A first person camera may position the camera at a player location (perhaps using `Spatial.get_global_transform_interpolated( Spatial_method_get_global_transform_interpolated )`), but control the Camera rotation from mouse look *without* interpolation.
+* A third person camera may similarly determine the look at (target location) of the camera using `Spatial.get_global_transform_interpolated( Spatial_method_get_global_transform_interpolated )`, but position the camera using mouse look *without* interpolation.
 
 There are many permutations and variations of Camera types, but it should be clear that in many cases, disabling automatic physics interpolation and handling this yourself can give a better result.
 
@@ -113,7 +113,7 @@ MultiMeshes
 
 Although most visual Nodes follow the single Node single visual instance paradigm, MultiMeshes can control several instances from the same Node. Therefore, they have some extra functions for controlling interpolation functionality on a *per-instance* basis. You should explore these functions if you are using interpolated MultiMeshes.
 
-- `MultiMesh.reset_instance_physics_interpolation<class_MultiMesh_method_reset_instance_physics_interpolation )`
-- `MultiMesh.set_as_bulk_array_interpolated<class_MultiMesh_method_set_as_bulk_array_interpolated )`
+- `MultiMesh.reset_instance_physics_interpolation( MultiMesh_method_reset_instance_physics_interpolation )`
+- `MultiMesh.set_as_bulk_array_interpolated( MultiMesh_method_set_as_bulk_array_interpolated )`
 
-Full details are in the `MultiMesh<class_MultiMesh )` documentation.
+Full details are in the `MultiMesh( MultiMesh )` documentation.
diff --git a/tutorials/physics/interpolation/physics_interpolation_introduction.md b/tutorials/physics/interpolation/physics_interpolation_introduction.md
index f3d588d..8af03ec 100644
--- a/tutorials/physics/interpolation/physics_interpolation_introduction.md
+++ b/tutorials/physics/interpolation/physics_interpolation_introduction.md
@@ -6,7 +6,7 @@ Introduction
 Physics ticks and rendered frames
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-One key concept to understand in Godot is the distinction between physics ticks (sometimes referred to as iterations or physics frames), and rendered frames. The physics proceeds at a fixed tick rate (set in `ProjectSettings.physics/common/physics_fps<class_ProjectSettings_property_physics/common/physics_fps )`), which defaults to 60 ticks per second.
+One key concept to understand in Godot is the distinction between physics ticks (sometimes referred to as iterations or physics frames), and rendered frames. The physics proceeds at a fixed tick rate (set in `ProjectSettings.physics/common/physics_fps( ProjectSettings_property_physics/common/physics_fps )`), which defaults to 60 ticks per second.
 
 However, the engine does not necessarily **render** at the same rate. Although many monitors refresh at 60 Hz (cycles per second), many refresh at completely different frequencies (e.g. 75 Hz, 144 Hz, 240 Hz or more). Even though a monitor may be able to show a new frame e.g. 60 times a second, there is no guarantee that the CPU and GPU will be able to *supply* frames at this rate. For instance, when running with V-Sync, the computer may be too slow for 60 and only reach the deadlines for 30 FPS, in which case the frames you see will change at 30 FPS (resulting in stuttering).
 
@@ -73,7 +73,7 @@ First of all, we have to calculate how far through the physics tick we want the
 	fraction = 0.02 / 0.10
 	fraction = 0.2
 
-This is called the **physics interpolation fraction**, and is handily calculated for you by Godot. It can be retrieved on any frame by calling `Engine.get_physics_interpolation_fraction<class_Engine_method_get_physics_interpolation_fraction )`.
+This is called the **physics interpolation fraction**, and is handily calculated for you by Godot. It can be retrieved on any frame by calling `Engine.get_physics_interpolation_fraction( Engine_method_get_physics_interpolation_fraction )`.
 
 Calculating the interpolated position
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tutorials/physics/interpolation/physics_interpolation_quick_start_guide.md b/tutorials/physics/interpolation/physics_interpolation_quick_start_guide.md
index 2e5bee8..aebb297 100644
--- a/tutorials/physics/interpolation/physics_interpolation_quick_start_guide.md
+++ b/tutorials/physics/interpolation/physics_interpolation_quick_start_guide.md
@@ -3,7 +3,7 @@
 Quick start guide
 =================
 
-- Turn on physics interpolation: `ProjectSettings.physics/common/physics_interpolation<class_ProjectSettings_property_physics/common/physics_interpolation )`
+- Turn on physics interpolation: `ProjectSettings.physics/common/physics_interpolation( ProjectSettings_property_physics/common/physics_interpolation )`
 - Make sure you move objects and run your game logic in `_physics_process()` rather than `_process()`. This includes moving objects directly *and indirectly* (by e.g. moving a parent, or using another mechanism to automatically move nodes).
-- Be sure to call `Node.reset_physics_interpolation<class_Node_method_reset_physics_interpolation )` on nodes *after* you first position or teleport them, to prevent "streaking"
-- Temporarily try setting `ProjectSettings.physics/common/physics_fps<class_ProjectSettings_property_physics/common/physics_fps )` to 10 to see the difference with and without interpolation.
+- Be sure to call `Node.reset_physics_interpolation( Node_method_reset_physics_interpolation )` on nodes *after* you first position or teleport them, to prevent "streaking"
+- Temporarily try setting `ProjectSettings.physics/common/physics_fps( ProjectSettings_property_physics/common/physics_fps )` to 10 to see the difference with and without interpolation.
diff --git a/tutorials/physics/interpolation/using_physics_interpolation.md b/tutorials/physics/interpolation/using_physics_interpolation.md
index df722c7..602fe5e 100644
--- a/tutorials/physics/interpolation/using_physics_interpolation.md
+++ b/tutorials/physics/interpolation/using_physics_interpolation.md
@@ -9,13 +9,13 @@ We have tried to make the system as easy to use as possible, and many existing g
 Turn on the physics interpolation setting
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-The first step is to turn on physics interpolation in `ProjectSettings.physics/common/physics_interpolation<class_ProjectSettings_property_physics/common/physics_interpolation )`. You can now run your game.
+The first step is to turn on physics interpolation in `ProjectSettings.physics/common/physics_interpolation( ProjectSettings_property_physics/common/physics_interpolation )`. You can now run your game.
 
 It is likely that nothing looks hugely different, particularly if you are running physics at 60 TPS or a multiple of it. However, quite a bit more is happening behind the scenes.
 
 .. tip::
 
-	To convert an existing game to use interpolation, it is highly recommended that you temporarily set `ProjectSettings.physics/common/physics_fps<class_ProjectSettings_property_physics/common/physics_fps )` to a low value such as 10, which will make interpolation problems more obvious.
+	To convert an existing game to use interpolation, it is highly recommended that you temporarily set `ProjectSettings.physics/common/physics_fps( ProjectSettings_property_physics/common/physics_fps )` to a low value such as 10, which will make interpolation problems more obvious.
 
 Move (almost) all game logic from _process to _physics_process
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,7 +34,7 @@ Ensure that all indirect movement happens during physics ticks
 
 Consider that in Godot, Nodes can be moved not just directly in your own scripts, but also by automatic methods such as tweening, animation, and navigation. All these methods should also have their timing set to operate on the physics tick rather than each frame ("idle"), **if** you are using them to move objects (*these methods can also be used to control properties that are not interpolated*).
 
-.. note:: Also consider that nodes can be moved not just by moving themselves, but also by moving parent nodes in the `SceneTree<class_SceneTree )`. The movement of parents should therefore also only occur during physics ticks.
+.. note:: Also consider that nodes can be moved not just by moving themselves, but also by moving parent nodes in the `SceneTree( SceneTree )`. The movement of parents should therefore also only occur during physics ticks.
 
 Choose a physics tick rate
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -58,7 +58,7 @@ Call reset_physics_interpolation() when teleporting objects
 
 Most of the time, interpolation is what you want between two physics ticks. However, there is one situation in which it may *not* be what you want. That is when you are initially placing objects, or moving them to a new location. Here, you don't want a smooth motion between the two - you want an instantaneous move.
 
-The solution to this is to call the `Node.reset_physics_interpolation<class_Node_method_reset_physics_interpolation )` function. You should call this function on a Node *after* setting the position/transform. The rest is done for you automatically.
+The solution to this is to call the `Node.reset_physics_interpolation( Node_method_reset_physics_interpolation )` function. You should call this function on a Node *after* setting the position/transform. The rest is done for you automatically.
 
 Even if you forget to call this, it is not usually a problem in most situations (especially at high tick rates). This is something you can easily leave to the polishing phase of your game. The worst that will happen is seeing a streaking motion for a frame or so when you move them - you will know when you need it!
 
@@ -69,6 +69,6 @@ Testing and debugging tips
 
 Even if you intend to run physics at 60 TPS, in order to thoroughly test your interpolation and get the smoothest gameplay, it is highly recommended to temporarily set the physics tick rate to a low value such as 10 TPS.
 
-The gameplay may not work perfectly, but it should enable you to more easily see cases where you should be calling `Node.reset_physics_interpolation<class_Node_method_reset_physics_interpolation )`, or where you should be using your own custom interpolation on e.g. a `Camera<class_Camera )`. Once you have these cases fixed, you can set the physics tick rate back to the desired setting.
+The gameplay may not work perfectly, but it should enable you to more easily see cases where you should be calling `Node.reset_physics_interpolation( Node_method_reset_physics_interpolation )`, or where you should be using your own custom interpolation on e.g. a `Camera( Camera )`. Once you have these cases fixed, you can set the physics tick rate back to the desired setting.
 
 The other great advantage to testing at a low tick rate is you can often notice other game systems that are synchronized to the physics tick and creating glitches which you may want to work around. Typical examples include setting animation blend values, which you may decide to set in `_process()` and interpolate manually.
diff --git a/tutorials/physics/physics_introduction.md b/tutorials/physics/physics_introduction.md
index 74fbbf2..a214c2b 100644
--- a/tutorials/physics/physics_introduction.md
+++ b/tutorials/physics/physics_introduction.md
@@ -45,7 +45,7 @@ The other three bodies extend `PhysicsBody2D`:
 - `RigidBody2D`
     This is the node that implements simulated 2D physics. You do not control a
     `RigidBody2D` directly, but instead you apply forces to it (gravity, impulses,
-    etc.) and the physics engine calculates the resulting movement. `Read more about using rigid bodies. <doc_rigid_body )`
+    etc.) and the physics engine calculates the resulting movement. `Read more about using rigid bodies. ( doc_rigid_body )`
 
 - `KinematicBody2D`
     A body that provides collision detection, but no physics. All movement and
@@ -55,7 +55,7 @@ Physics material
 ~~~~~~~~~~~~~~~~
 
 Static bodies and rigid bodies can be configured to use a `physics material
-<class_PhysicsMaterial )`. This allows adjusting the friction and bounce of an object,
+( PhysicsMaterial )`. This allows adjusting the friction and bounce of an object,
 and set if it's absorbent and/or rough.
 
 Collision shapes
diff --git a/tutorials/platform/android/android_in_app_purchases.md b/tutorials/platform/android/android_in_app_purchases.md
index a57209b..fb36a48 100644
--- a/tutorials/platform/android/android_in_app_purchases.md
+++ b/tutorials/platform/android/android_in_app_purchases.md
@@ -34,7 +34,7 @@ Usage
 Getting started
 ***************
 
-If not already done, make sure you have enabled and successfully set up `Android Custom Builds <doc_android_custom_build )`.
+If not already done, make sure you have enabled and successfully set up `Android Custom Builds ( doc_android_custom_build )`.
 Grab the`GodotGooglePlayBilling` plugin binary and config from the `releases page ( https://github.com/godotengine/godot-google-play-billing/releases )`
 and put both into `res://android/plugins`.
 The plugin should now show up in the Android export settings, where you can enable it.
diff --git a/tutorials/platform/android/android_plugin.md b/tutorials/platform/android/android_plugin.md
index 0fa1376..1d7d041 100644
--- a/tutorials/platform/android/android_plugin.md
+++ b/tutorials/platform/android/android_plugin.md
@@ -38,7 +38,7 @@ Since we previously did not version the Android plugin systems, the new one is n
 
 **Note:** In Godot 4.0, the previous system will be fully deprecated and removed.
 
-As a prerequisite, make sure you understand how to set up a `custom build environment<doc_android_custom_build )` for Android.
+As a prerequisite, make sure you understand how to set up a `custom build environment( doc_android_custom_build )` for Android.
 
 At its core, a Godot Android plugin is a `Android archive library ( https://developer.android.com/studio/projects/android-library#aar-contents )`_ (*aar* archive file)
 with the following caveats:
diff --git a/tutorials/platform/customizing_html5_shell.md b/tutorials/platform/customizing_html5_shell.md
index d24bad8..a5ef9a6 100644
--- a/tutorials/platform/customizing_html5_shell.md
+++ b/tutorials/platform/customizing_html5_shell.md
@@ -80,7 +80,7 @@ To be able to start the game, you need to write a script that initializes the en
 code. This process consists of three steps, though as shown most of them can be skipped depending on
 how much customization is needed (or be left to a default behavior).
 
-See the `HTML5 shell class reference <doc_html5_shell_classref )`, for the full list of methods and options available.
+See the `HTML5 shell class reference ( doc_html5_shell_classref )`, for the full list of methods and options available.
 
 First, the engine must be loaded, then it needs to be initialized, and after this the project
 can finally be started. You can perform every of these steps manually and with great control.
diff --git a/tutorials/platform/html5_shell_classref.md b/tutorials/platform/html5_shell_classref.md
index c9258ee..4ca5185 100644
--- a/tutorials/platform/html5_shell_classref.md
+++ b/tutorials/platform/html5_shell_classref.md
@@ -14,7 +14,7 @@ Engine
 
 The `Engine` class provides methods for loading and starting exported projects on the Web. For default export
 settings, this is already part of the exported HTML page. To understand practical use of the `Engine` class,
-see `Custom HTML page for Web export <doc_customizing_html5_shell )`.
+see `Custom HTML page for Web export ( doc_customizing_html5_shell )`.
 
 Static Methods
 ^^^^^^^^^^^^^^
@@ -258,7 +258,7 @@ Properties
       Specify a language code to select the proper localization for the game.
 
       The browser locale will be used if none is specified. See complete list of
-      `supported locales <doc_locales )`.
+      `supported locales ( doc_locales )`.
 
       :type: string
 
@@ -283,7 +283,7 @@ Properties
 
       The arguments to be passed as command line arguments on startup.
 
-      See `command line tutorial <doc_command_line_tutorial )`.
+      See `command line tutorial ( doc_command_line_tutorial )`.
 
       **Note**: :js:meth:`startGame <Engine.prototype.startGame )` will always add the `--main-pack` argument.
 
diff --git a/tutorials/platform/mobile_rendering_limitations.md b/tutorials/platform/mobile_rendering_limitations.md
index b0343d0..f6ee5a0 100644
--- a/tutorials/platform/mobile_rendering_limitations.md
+++ b/tutorials/platform/mobile_rendering_limitations.md
@@ -9,7 +9,7 @@ Mobile rendering limitations
 
 To improve out-of-the-box performance on mobile devices, Godot automatically uses
 low-end-friendly settings by default on both Android and iOS. These are configured
-by project settings with a `.mobile` `feature tag <doc_feature_tags )` suffix.
+by project settings with a `.mobile` `feature tag ( doc_feature_tags )` suffix.
 
 One of the most notable changes on mobile that will affect 3D projects is that
 lighting is done per-vertex instead of per-pixel. This improves performance a
diff --git a/tutorials/plugins/editor/import_plugins.md b/tutorials/plugins/editor/import_plugins.md
index f936d5e..0e49085 100644
--- a/tutorials/plugins/editor/import_plugins.md
+++ b/tutorials/plugins/editor/import_plugins.md
@@ -98,7 +98,7 @@ Let's begin to code our plugin, one method at time:
         return "demos.sillymaterial"
 
 The first method is the
-`get_importer_name()<class_EditorImportPlugin_method_get_importer_name )`. This is a
+`get_importer_name()( EditorImportPlugin_method_get_importer_name )`. This is a
 unique name for your plugin that is used by Godot to know which import was used
 in a certain file. When the files needs to be reimported, the editor will know
 which plugin to call.
@@ -108,7 +108,7 @@ which plugin to call.
     func get_visible_name():
         return "Silly Material"
 
-The `get_visible_name()<class_EditorImportPlugin_method_get_visible_name )` method is
+The `get_visible_name()( EditorImportPlugin_method_get_visible_name )` method is
 responsible for returning the name of the type it imports and it will be shown to the
 user in the Import dock.
 
@@ -122,7 +122,7 @@ descriptive name for your plugin.
         return ["mtxt"]
 
 Godot's import system detects file types by their extension. In the
-`get_recognized_extensions()<class_EditorImportPlugin_method_get_recognized_extensions )`
+`get_recognized_extensions()( EditorImportPlugin_method_get_recognized_extensions )`
 method you return an array of strings to represent each extension that this
 plugin can understand. If an extension is recognized by more than one plugin,
 the user can select which one to use when importing the files.
@@ -344,7 +344,7 @@ as the value we got before.
 This is the last part and quite an important one, because here we save the made
 resource to the disk. The path of the saved file is generated and informed by
 the editor via the `save_path` parameter. Note that this comes **without** the
-extension, so we add it using `string formatting <doc_gdscript_printf )`. For
+extension, so we add it using `string formatting ( doc_gdscript_printf )`. For
 this we call the `get_save_extension` method that we defined earlier, so we
 can be sure that they won't get out of sync.
 
@@ -362,7 +362,7 @@ method. Both of them are arrays that you can fill with information.
 
 The `r_platform_variants` argument is used if you need to import the resource
 differently depending on the target platform. While it's called *platform*
-variants, it is based on the presence of `feature tags <doc_feature_tags )`,
+variants, it is based on the presence of `feature tags ( doc_feature_tags )`,
 so even the same platform can have multiple variants depending on the setup.
 
 To import a platform variant, you need to save it with the feature tag before
diff --git a/tutorials/plugins/editor/making_plugins.md b/tutorials/plugins/editor/making_plugins.md
index d194720..75d0616 100644
--- a/tutorials/plugins/editor/making_plugins.md
+++ b/tutorials/plugins/editor/making_plugins.md
@@ -130,7 +130,7 @@ custom behavior.
 
   Nodes added via an EditorPlugin are "CustomType" nodes. While they work
   with any scripting language, they have fewer features than
-  `the Script Class system <doc_gdscript_basics_class_name )`. If you
+  `the Script Class system ( doc_gdscript_basics_class_name )`. If you
   are writing GDScript or NativeScript, we recommend using Script Classes instead.
 
 To create a new node type, you can use the function
@@ -227,7 +227,7 @@ gdscript GDScript
 ```
 
 Then create the script `custom_dock.gd` in the same folder. Fill it with the
-`template we've seen before <doc_making_plugins_template_code )` to get a
+`template we've seen before ( doc_making_plugins_template_code )` to get a
 good start.
 
 Since we're trying to add a new custom dock, we need to create the contents of
@@ -318,7 +318,7 @@ Registering autoloads/singletons in plugins
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 It is possible for editor plugins to automatically register
-`autoloads <doc_singletons_autoload )` when the plugin is enabled.
+`autoloads ( doc_singletons_autoload )` when the plugin is enabled.
 This also includes unregistering the autoload when the plugin is disabled.
 
 This makes setting up plugins faster for users, as they no longer have to manually
diff --git a/tutorials/plugins/editor/spatial_gizmos.md b/tutorials/plugins/editor/spatial_gizmos.md
index c21cbd8..c249e30 100644
--- a/tutorials/plugins/editor/spatial_gizmos.md
+++ b/tutorials/plugins/editor/spatial_gizmos.md
@@ -64,7 +64,7 @@ to 3.1+, you should go with the second approach.
 Simple approach
 ---------------
 
-The first step is to, in our custom gizmo plugin, override the `has_gizmo()<class_EditorSpatialGizmoPlugin_method_has_gizmo )`
+The first step is to, in our custom gizmo plugin, override the `has_gizmo()( EditorSpatialGizmoPlugin_method_has_gizmo )`
 method so that it returns `true` when the spatial parameter is of our target type.
 
 ::
@@ -78,7 +78,7 @@ method so that it returns `true` when the spatial parameter is of our target typ
 
     # ...
 
-Then we can override methods like `redraw()<class_EditorSpatialGizmoPlugin_method_redraw )`
+Then we can override methods like `redraw()( EditorSpatialGizmoPlugin_method_redraw )`
 or all the handle related ones.
 
 ::
@@ -113,7 +113,7 @@ or all the handle related ones.
     # ...
 
 Note that we created a material in the `_init` method, and retrieved it in the `redraw`
-method using `get_material()<class_EditorSpatialGizmoPlugin_method_get_material )`. This
+method using `get_material()( EditorSpatialGizmoPlugin_method_get_material )`. This
 method retrieves one of the material's variants depending on the state of the gizmo
 (selected and/or editable).
 
@@ -165,12 +165,12 @@ to get properly working handles.
 Alternative approach
 --------------------
 
-In some cases we want to provide our own implementation of `EditorSpatialGizmo<class_EditorSpatialGizmo )`,
+In some cases we want to provide our own implementation of `EditorSpatialGizmo( EditorSpatialGizmo )`,
 maybe because we want to have some state stored in each gizmo or because we are porting
 an old gizmo plugin and we don't want to go through the rewriting process.
 
 In these cases all we need to do is, in our new gizmo plugin, override
-`create_gizmo()<class_EditorSpatialGizmoPlugin_method_create_gizmo )`, so it returns our custom gizmo implementation
+`create_gizmo()( EditorSpatialGizmoPlugin_method_create_gizmo )`, so it returns our custom gizmo implementation
 for the Spatial nodes we want to target.
 
 ::
@@ -195,7 +195,7 @@ for the Spatial nodes we want to target.
             return null
 
 This way all the gizmo logic and drawing methods can be implemented in a new class extending
-`EditorSpatialGizmo<class_EditorSpatialGizmo )`, like so:
+`EditorSpatialGizmo( EditorSpatialGizmo )`, like so:
 
 ::
 
@@ -233,5 +233,5 @@ This way all the gizmo logic and drawing methods can be implemented in a new cla
     # (get_handle_name(), get_handle_value(), commit_handle()...).
 
 Note that we just added some handles in the redraw method, but we still need to implement
-the rest of handle-related callbacks in `EditorSpatialGizmo<class_EditorSpatialGizmo )`
+the rest of handle-related callbacks in `EditorSpatialGizmo( EditorSpatialGizmo )`
 to get properly working handles.
diff --git a/tutorials/plugins/running_code_in_the_editor.md b/tutorials/plugins/running_code_in_the_editor.md
index 9b5ff25..f10b84d 100644
--- a/tutorials/plugins/running_code_in_the_editor.md
+++ b/tutorials/plugins/running_code_in_the_editor.md
@@ -21,7 +21,7 @@ You can use it for doing many things, but it is mostly useful in level design fo
     with caveats, as the editor does not include protections for potential
     misuse of `tool` scripts.
     Be **extremely** cautious when manipulating the scene tree, especially via
-    `Node.queue_free<class_Node_method_queue_free )`, as it can cause
+    `Node.queue_free( Node_method_queue_free )`, as it can cause
     crashes if you free a node while the editor runs logic involving it.
 
 How to use it
@@ -156,7 +156,7 @@ gdscript GDScript
         node.set_owner(get_tree().edited_scene_root)
 ```
 
-If you are using `EditorScript<class_EditorScript )`:
+If you are using `EditorScript( EditorScript )`:
 
 gdscript GDScript
 
diff --git a/tutorials/rendering/multiple_resolutions.md b/tutorials/rendering/multiple_resolutions.md
index 1144003..49678fb 100644
--- a/tutorials/rendering/multiple_resolutions.md
+++ b/tutorials/rendering/multiple_resolutions.md
@@ -407,8 +407,8 @@ Handling aspect ratios
 
 Once scaling for different resolutions is accounted for, make sure that
 your *user interface* also scales for different aspect ratios. This can be
-done using `anchors <doc_size_and_anchors )` and/or `containers
-<doc_gui_containers )`.
+done using `anchors ( doc_size_and_anchors )` and/or `containers
+( doc_gui_containers )`.
 
 Field of view scaling
 ---------------------
diff --git a/tutorials/rendering/viewports.md b/tutorials/rendering/viewports.md
index 3189d5b..2181275 100644
--- a/tutorials/rendering/viewports.md
+++ b/tutorials/rendering/viewports.md
@@ -45,13 +45,13 @@ the input.
 
 ![](img/input.png)
 
-For more information on how Godot handles input, please read the `Input Event Tutorial<doc_inputevent )`.
+For more information on how Godot handles input, please read the `Input Event Tutorial( doc_inputevent )`.
 
 Listener
 --------
 
 Godot supports 3D sound (in both 2D and 3D nodes); more on this can be
-found in the `Audio Streams Tutorial<doc_audio_streams )`. For this type of sound to be
+found in the `Audio Streams Tutorial( doc_audio_streams )`. For this type of sound to be
 audible, the `Viewport` needs to be enabled as a listener (for 2D or 3D).
 If you are using a custom `Viewport`, don't forget
 to enable this!
@@ -101,7 +101,7 @@ different from the one specified in size, by calling:
     viewport.set_size_override_stretch(true) # Enable stretch for custom size.
 
 The root `Viewport` uses this for the stretch options in the project
-settings. For more information on scaling and stretching visit the `Multiple Resolutions Tutorial <doc_multiple_resolutions )`
+settings. For more information on scaling and stretching visit the `Multiple Resolutions Tutorial ( doc_multiple_resolutions )`
 
 Worlds
 ------
@@ -167,7 +167,7 @@ If the `Viewport`, it will become active and display anything it has inside. The
 ![](img/container.png)
 
 The `Viewport` completely
-if `Stretch<class_viewportcontainer_property_stretch )` is set to `true` in `ViewportContainer`.
+if `Stretch( viewportcontainer_property_stretch )` is set to `true` in `ViewportContainer`.
 Note: The size of the `ViewportContainer`.
 
 Rendering
@@ -237,7 +237,7 @@ and then selecting the `Viewport` you want to use.
 ![](img/texturepath.png)
 
 Every frame, the `Viewport`'s texture is cleared away with the default clear color (or a transparent
-color if `Transparent Bg<class_Viewport_property_transparent_bg )` is set to `true`). This can be changed by setting `Clear Mode<class_Viewport_property_render_target_clear_mode )` to Never or Next Frame.
+color if `Transparent Bg( Viewport_property_transparent_bg )` is set to `true`). This can be changed by setting `Clear Mode( Viewport_property_render_target_clear_mode )` to Never or Next Frame.
 As the name implies, Never means the texture will never be cleared, while next frame will
 clear the texture on the next frame and then set itself to Never.
 
diff --git a/tutorials/scripting/debug/debugger_panel.md b/tutorials/scripting/debug/debugger_panel.md
index 12b6937..70300bc 100644
--- a/tutorials/scripting/debug/debugger_panel.md
+++ b/tutorials/scripting/debug/debugger_panel.md
@@ -35,7 +35,7 @@ You can use the buttons in the top-right corner to:
 .. warning::
 
     Breakpoints won't break on code if it's
-    `running in a thread <doc_using_multiple_threads )`.
+    `running in a thread ( doc_using_multiple_threads )`.
     This is a current limitation of the GDScript debugger.
 
 Errors
diff --git a/tutorials/scripting/debug/overview_of_debugging_tools.md b/tutorials/scripting/debug/overview_of_debugging_tools.md
index 20f5c89..613756b 100644
--- a/tutorials/scripting/debug/overview_of_debugging_tools.md
+++ b/tutorials/scripting/debug/overview_of_debugging_tools.md
@@ -93,7 +93,7 @@ debug your game with an external editor.
 .. warning::
 
     Breakpoints won't break on code if it's
-    `running in a thread <doc_using_multiple_threads )`.
+    `running in a thread ( doc_using_multiple_threads )`.
     This is a current limitation of the GDScript debugger.
 
 Debug project settings
diff --git a/tutorials/scripting/gdscript/gdscript_basics.md b/tutorials/scripting/gdscript/gdscript_basics.md
index 3b307fd..a454b38 100644
--- a/tutorials/scripting/gdscript/gdscript_basics.md
+++ b/tutorials/scripting/gdscript/gdscript_basics.md
@@ -19,7 +19,7 @@ History
 .. note::
 
     Documentation about GDScript's history has been moved to the
-    `Frequently Asked Questions <doc_faq_what_is_gdscript )`.
+    `Frequently Asked Questions ( doc_faq_what_is_gdscript )`.
 
 Example of GDScript
 ~~~~~~~~~~~~~~~~~~~
@@ -200,17 +200,17 @@ in case you want to take a look under the hood.
 +------------+---------------------------------------------------------------------------------------------------------------+
 | assert     | Asserts a condition, logs error on failure. Ignored in non-debug builds. See `Assert keyword`_.               |
 +------------+---------------------------------------------------------------------------------------------------------------+
-| remote     | Networking RPC annotation. See `high-level multiplayer docs <doc_high_level_multiplayer )`.               |
+| remote     | Networking RPC annotation. See `high-level multiplayer docs ( doc_high_level_multiplayer )`.               |
 +------------+---------------------------------------------------------------------------------------------------------------+
-| master     | Networking RPC annotation. See `high-level multiplayer docs <doc_high_level_multiplayer )`.               |
+| master     | Networking RPC annotation. See `high-level multiplayer docs ( doc_high_level_multiplayer )`.               |
 +------------+---------------------------------------------------------------------------------------------------------------+
-| puppet     | Networking RPC annotation. See `high-level multiplayer docs <doc_high_level_multiplayer )`.               |
+| puppet     | Networking RPC annotation. See `high-level multiplayer docs ( doc_high_level_multiplayer )`.               |
 +------------+---------------------------------------------------------------------------------------------------------------+
-| remotesync | Networking RPC annotation. See `high-level multiplayer docs <doc_high_level_multiplayer )`.               |
+| remotesync | Networking RPC annotation. See `high-level multiplayer docs ( doc_high_level_multiplayer )`.               |
 +------------+---------------------------------------------------------------------------------------------------------------+
-| mastersync | Networking RPC annotation. See `high-level multiplayer docs <doc_high_level_multiplayer )`.               |
+| mastersync | Networking RPC annotation. See `high-level multiplayer docs ( doc_high_level_multiplayer )`.               |
 +------------+---------------------------------------------------------------------------------------------------------------+
-| puppetsync | Networking RPC annotation. See `high-level multiplayer docs <doc_high_level_multiplayer )`.               |
+| puppetsync | Networking RPC annotation. See `high-level multiplayer docs ( doc_high_level_multiplayer )`.               |
 +------------+---------------------------------------------------------------------------------------------------------------+
 | PI         | PI constant.                                                                                                  |
 +------------+---------------------------------------------------------------------------------------------------------------+
@@ -1329,7 +1329,7 @@ Either of the *setter* or *getter* functions can be omitted::
     # Only a getter (note the comma).
     var my_var = 5 setget ,my_var_get
 
-Setters and getters are useful when `exporting variables <doc_gdscript_exports )`
+Setters and getters are useful when `exporting variables ( doc_gdscript_exports )`
 to the editor in tool scripts or plugins, for validating input.
 
 As said, *local* access will *not* trigger the setter and getter. Here is an
@@ -1563,7 +1563,7 @@ Coroutines with yield
 ~~~~~~~~~~~~~~~~~~~~~
 
 GDScript offers support for `coroutines ( https://en.wikipedia.org/wiki/Coroutine )`_
-via the `yield<class_@GDScript_method_yield )` built-in function. Calling `yield()` will
+via the `yield( @GDScript_method_yield )` built-in function. Calling `yield()` will
 immediately return from the current function, with the current frozen
 state of the same function as the return value. Calling `resume()` on
 this resulting object will continue execution and return whatever the
diff --git a/tutorials/scripting/gdscript/gdscript_exports.md b/tutorials/scripting/gdscript/gdscript_exports.md
index ace1cf7..3535ffd 100644
--- a/tutorials/scripting/gdscript/gdscript_exports.md
+++ b/tutorials/scripting/gdscript/gdscript_exports.md
@@ -138,7 +138,7 @@ Examples
 
 It must be noted that even if the script is not being run while in the
 editor, the exported properties are still editable. This can be used
-in conjunction with a `script in "tool" mode <doc_gdscript_tool_mode )`.
+in conjunction with a `script in "tool" mode ( doc_gdscript_tool_mode )`.
 
 Exporting bit flags
 -------------------
diff --git a/tutorials/scripting/gdscript/gdscript_styleguide.md b/tutorials/scripting/gdscript/gdscript_styleguide.md
index a11a849..76a987c 100644
--- a/tutorials/scripting/gdscript/gdscript_styleguide.md
+++ b/tutorials/scripting/gdscript/gdscript_styleguide.md
@@ -784,7 +784,7 @@ in that order.
 Static typing
 -------------
 
-Since Godot 3.1, GDScript supports `optional static typing<doc_gdscript_static_typing )`.
+Since Godot 3.1, GDScript supports `optional static typing( doc_gdscript_static_typing )`.
 
 Declared types
 ~~~~~~~~~~~~~~
@@ -831,7 +831,7 @@ that type will be used to infer the type of the var.
    onready var health_bar := get_node("UI/LifeBar") as ProgressBar
    # health_bar will be typed as ProgressBar
 
-This option is also considered more `type-safe<doc_gdscript_static_typing_safe_lines )` than the first.
+This option is also considered more `type-safe( doc_gdscript_static_typing_safe_lines )` than the first.
 
 **Bad**:
 
diff --git a/tutorials/scripting/gdscript/static_typing.md b/tutorials/scripting/gdscript/static_typing.md
index 7227d5d..6323be5 100644
--- a/tutorials/scripting/gdscript/static_typing.md
+++ b/tutorials/scripting/gdscript/static_typing.md
@@ -104,10 +104,10 @@ type:
 
 Currently you can use three types of… types:
 
-1. `Built-in <doc_gdscript_builtin_types )`
+1. `Built-in ( doc_gdscript_builtin_types )`
 2. Core classes and nodes (`Object`, `Node`, `Area2D`,
    `Camera2D`, etc.)
-3. Your own custom classes. Look at the new `name <doc_gdscript_basics_class_name )`
+3. Your own custom classes. Look at the new `name ( doc_gdscript_basics_class_name )`
    feature to register types in the editor.
 
 .. note::
diff --git a/tutorials/scripting/gdscript/warning_system.md b/tutorials/scripting/gdscript/warning_system.md
index ee5b511..fdf0e14 100644
--- a/tutorials/scripting/gdscript/warning_system.md
+++ b/tutorials/scripting/gdscript/warning_system.md
@@ -3,7 +3,7 @@
 GDScript warning system
 =======================
 
-The GDScript warning system complements `static typing <doc_gdscript_static_typing )`
+The GDScript warning system complements `static typing ( doc_gdscript_static_typing )`
 (but it can work without static typing too). It's here to help you avoid
 mistakes that are hard to spot during development, and that may lead
 to runtime errors.
diff --git a/tutorials/scripting/groups.md b/tutorials/scripting/groups.md
index 952b048..74f9cf7 100644
--- a/tutorials/scripting/groups.md
+++ b/tutorials/scripting/groups.md
@@ -99,7 +99,7 @@ group `guards`.
 
 To get the full list of nodes in the `guards` group as an array, you can call
 `SceneTree.get_nodes_in_group()
-<class_SceneTree_method_get_nodes_in_group )`:
+( SceneTree_method_get_nodes_in_group )`:
 
 gdscript GDScript
 
diff --git a/tutorials/scripting/idle_and_physics_processing.md b/tutorials/scripting/idle_and_physics_processing.md
index 36b8947..701e4aa 100644
--- a/tutorials/scripting/idle_and_physics_processing.md
+++ b/tutorials/scripting/idle_and_physics_processing.md
@@ -20,7 +20,7 @@ There are two types of processing available to you:
 
 You can activate idle processing by defining the `_process()` method in a
 script. You can turn it off and back on by calling `Node.set_process()
-<class_Node_method_set_process )`.
+( Node_method_set_process )`.
 
 The engine calls this method every time it draws a frame:
 
diff --git a/tutorials/scripting/nodes_and_scene_instances.md b/tutorials/scripting/nodes_and_scene_instances.md
index ad376ef..b11165c 100644
--- a/tutorials/scripting/nodes_and_scene_instances.md
+++ b/tutorials/scripting/nodes_and_scene_instances.md
@@ -10,7 +10,7 @@ Getting nodes
 -------------
 
 You can get a reference to a node by calling the `Node.get_node()
-<class_Node_method_get_node )` method. For this to work, the child node must be
+( Node_method_get_node )` method. For this to work, the child node must be
 present in the scene tree. Getting it in the parent node's `_ready()` function
 guarantees that.
 
@@ -167,7 +167,7 @@ gdscript GDScript
 
 At that point, `scene` is a packed scene resource, not a node. To create the
 actual node, you need to call `PackedScene.instance()
-<class_PackedScene_method_instance )`. It returns a tree of nodes that you can
+( PackedScene_method_instance )`. It returns a tree of nodes that you can
 as a child of your current node.
 
 gdscript GDScript
diff --git a/tutorials/scripting/overridable_functions.md b/tutorials/scripting/overridable_functions.md
index 118e60d..d9e1822 100644
--- a/tutorials/scripting/overridable_functions.md
+++ b/tutorials/scripting/overridable_functions.md
@@ -29,7 +29,7 @@ have entered the scene tree first, so you can safely call `get_node()` on it.
 
 Another related callback is `_exit_tree()`, which the engine calls every time
 a node exits the scene tree. This can be when you call `Node.remove_child()
-<class_Node_method_remove_child )` or when you free a node.
+( Node_method_remove_child )` or when you free a node.
 
 gdscript GDScript
 
@@ -91,7 +91,7 @@ gdscript GDScript
 
 There are some more overridable functions like
 `Node._get_configuration_warning()
-<class_Node_method__get_configuration_warning )`. Specialized node types provide
+( Node_method__get_configuration_warning )`. Specialized node types provide
 more callbacks like `CanvasItem._draw()` to
 draw programmatically or `Control._gui_input()
-<class_Control_method__gui_input )` to handle clicks and input on UI elements.
+( Control_method__gui_input )` to handle clicks and input on UI elements.
diff --git a/tutorials/scripting/resources.md b/tutorials/scripting/resources.md
index 7587a57..5bc1da4 100644
--- a/tutorials/scripting/resources.md
+++ b/tutorials/scripting/resources.md
@@ -19,9 +19,9 @@ do anything on their own: instead, nodes use the data contained in resources.
 Anything Godot saves or loads from disk is a resource. Be it a scene (a `.tscn`
 or an `.scn` file), an image, a script... Here are some `Resource` examples:
 `Texture`, `Mesh
-<class_Mesh )`, `Animation`, `AudioStream
-<class_AudioStream )`, `Font`, `Translation
-<class_Translation )`.
+( Mesh )`, `Animation`, `AudioStream
+( AudioStream )`, `Font`, `Translation
+( Translation )`.
 
 When the engine loads a resource from disk, **it only loads it once**. If a copy
 of that resource is already in memory, trying to load the resource again will
@@ -114,7 +114,7 @@ returns the root node of the scene. You can then add it as a child of any other
 node.
 
 The approach has several advantages. As the `PackedScene.instance()
-<class_PackedScene_method_instance )` function is fast, you can create new
+( PackedScene_method_instance )` function is fast, you can create new
 enemies, bullets, effects, etc. without having to load them again from disk each
 time. Remember that, as always, images, meshes, etc. are all shared between the
 scene instances.
@@ -169,7 +169,7 @@ those values and saves the resource, the Inspector serializes the custom propert
 too! To save a resource from the Inspector, click the Inspector's tools menu (top right),
 and select "Save" or "Save As...".
 
-If the script's language supports `script classes <doc_gdscript_basics_class_name )`,
+If the script's language supports `script classes ( doc_gdscript_basics_class_name )`,
 then it streamlines the process. Defining a name for your script alone will add it to
 the Inspector's creation dialog. This will auto-add your script to the Resource
 object you create.
diff --git a/tutorials/scripting/singletons_autoload.md b/tutorials/scripting/singletons_autoload.md
index b70172f..796cd4f 100644
--- a/tutorials/scripting/singletons_autoload.md
+++ b/tutorials/scripting/singletons_autoload.md
@@ -43,7 +43,7 @@ Autoloading nodes and scripts can give us these characteristics.
 .. tip::
 
     If you're creating an autoload as part of an editor plugin, consider
-    `registering it automatically in the Project Settings <doc_making_plugins_autoload )`
+    `registering it automatically in the Project Settings ( doc_making_plugins_autoload )`
     when the plugin is enabled.
 
 AutoLoad
diff --git a/tutorials/shaders/advanced_postprocessing.md b/tutorials/shaders/advanced_postprocessing.md
index d79fc67..78c533a 100644
--- a/tutorials/shaders/advanced_postprocessing.md
+++ b/tutorials/shaders/advanced_postprocessing.md
@@ -9,7 +9,7 @@ Introduction
 This tutorial describes an advanced method for post-processing in Godot.
 In particular, it will explain how to write a post-processing shader that
 uses the depth buffer. You should already be familiar with post-processing
-generally and, in particular, with the methods outlined in the `custom post-processing tutorial <doc_custom_postprocessing )`.
+generally and, in particular, with the methods outlined in the `custom post-processing tutorial ( doc_custom_postprocessing )`.
 
 In the previous post-processing tutorial, we rendered the scene to a `Viewport`
 and then rendered the Viewport in a `ViewportContainer`
@@ -20,7 +20,7 @@ Viewports do not maintain depth information.
 Full screen quad
 ----------------
 
-In the `custom post-processing tutorial <doc_custom_postprocessing )`, we
+In the `custom post-processing tutorial ( doc_custom_postprocessing )`, we
 covered how to use a Viewport to make custom post-processing effects. There are
 two main drawbacks of using a Viewport:
 
diff --git a/tutorials/shaders/converting_glsl_to_godot_shaders.md b/tutorials/shaders/converting_glsl_to_godot_shaders.md
index ea2ae5b..40260ca 100644
--- a/tutorials/shaders/converting_glsl_to_godot_shaders.md
+++ b/tutorials/shaders/converting_glsl_to_godot_shaders.md
@@ -8,7 +8,7 @@ and gives practical advice on how to migrate shaders from other sources, such as
 Shadertoy and The Book of Shaders, into Godot shaders.
 
 For detailed information on Godot's shading language, please refer to the
-`Shading Language <doc_shading_language )` reference.
+`Shading Language ( doc_shading_language )` reference.
 
 GLSL
 ----
@@ -36,7 +36,7 @@ In GLSL, you can pass in per-vertex information using attributes and have the
 flexibility to pass in as much or as little as you want. In Godot, you have a
 set number of input attributes, including `VERTEX` (position), `COLOR`,
 `UV`, `UV2`, `NORMAL`. For a complete list, see the `Shading language
-reference <doc_shading_language )`.
+reference ( doc_shading_language )`.
 
 gl_Position
 ^^^^^^^^^^^
@@ -126,7 +126,7 @@ In GLSL, you can define the precision of a given type (float or int) at the top
 of the shader with the `precision` keyword. In Godot, you can set the
 precision of individual variables as you need by placing precision qualifiers
 `lowp`, `mediump`, and `highp` before the type when defining the variable.
-For more information, see the `Shading Language <doc_shading_language )`
+For more information, see the `Shading Language ( doc_shading_language )`
 reference.
 
 Shadertoy
diff --git a/tutorials/shaders/custom_postprocessing.md b/tutorials/shaders/custom_postprocessing.md
index 5a19961..41fb44c 100644
--- a/tutorials/shaders/custom_postprocessing.md
+++ b/tutorials/shaders/custom_postprocessing.md
@@ -15,7 +15,7 @@ inside a `ViewportTexture` and show it on the screen.
 
 The easiest way to implement a custom post-processing shader is to use Godot's built-in ability to read from
 the screen texture. If you're not familiar with this, you should read the `Screen Reading Shaders
-Tutorial <doc_screen-reading_shaders )` first.
+Tutorial ( doc_screen-reading_shaders )` first.
 
 .. note::
 
@@ -28,7 +28,7 @@ Single pass post-processing
 
 You will need a `Viewport` to render your scene to, and a scene to render your
 `Viewport` on the screen. You can use a `ViewportContainer
-<class_ViewportContainer )` to display your `Viewport` on the entire screen or inside
+( ViewportContainer )` to display your `Viewport` on the entire screen or inside
 another `Control` node.
 
 .. note::
@@ -169,4 +169,4 @@ Using the above code, you should end up with a full screen blur effect like belo
 
 ![](img/post_blur.png)
 
-For more information on how `Viewport` nodes work, see the `Viewports Tutorial <doc_viewports )`.
+For more information on how `Viewport` nodes work, see the `Viewports Tutorial ( doc_viewports )`.
diff --git a/tutorials/shaders/introduction_to_shaders.md b/tutorials/shaders/introduction_to_shaders.md
index 1d0e483..2500d79 100644
--- a/tutorials/shaders/introduction_to_shaders.md
+++ b/tutorials/shaders/introduction_to_shaders.md
@@ -84,9 +84,9 @@ In Godot, all shaders need to specify their type in the first line, like so:
 
 Here are the available types:
 
-* `spatial <doc_spatial_shader )` for 3D rendering.
-* `canvas_item <doc_canvas_item_shader )` for 2D rendering.
-* `particles <doc_particle_shader )` for particle systems.
+* `spatial ( doc_spatial_shader )` for 3D rendering.
+* `canvas_item ( doc_canvas_item_shader )` for 2D rendering.
+* `particles ( doc_particle_shader )` for particle systems.
 
 Render modes
 ------------
@@ -126,7 +126,7 @@ can also use it to send extra data to the fragment function using varyings.
 
 By default, Godot transforms your vertex information for you, which is necessary
 to project geometry onto the screen. You can use render modes to transform the
-data yourself; see the `Spatial shader doc <doc_spatial_shader )` for an
+data yourself; see the `Spatial shader doc ( doc_spatial_shader )` for an
 example.
 
 Fragment processor
@@ -158,5 +158,5 @@ operates on the material properties setup inside the `fragment()` function.
 
 The `light()` processor works differently in 2D than it does in 3D; for a
 description of how it works in each, see their documentation, `CanvasItem
-shaders <doc_canvas_item_shader )` and `Spatial shaders
-<doc_spatial_shader )`, respectively.
+shaders ( doc_canvas_item_shader )` and `Spatial shaders
+( doc_spatial_shader )`, respectively.
diff --git a/tutorials/shaders/shader_reference/canvas_item_shader.md b/tutorials/shaders/shader_reference/canvas_item_shader.md
index ad486da..32f41f0 100644
--- a/tutorials/shaders/shader_reference/canvas_item_shader.md
+++ b/tutorials/shaders/shader_reference/canvas_item_shader.md
@@ -53,7 +53,7 @@ Global built-ins are available everywhere, including custom functions.
 +===================+=============================================================================+
 | in float **TIME** | Global time since the engine has started, in seconds (always positive).     |
 |                   | It's subject to the rollover setting (which is 3,600 seconds by default).   |
-|                   | It's not affected by `time_scale<class_Engine_property_time_scale )`    |
+|                   | It's not affected by `time_scale( Engine_property_time_scale )`    |
 |                   | or pausing, but you can override the `TIME` variable's time scale by      |
 |                   | calling `VisualServer.set_shader_time_scale()` with the desired           |
 |                   | time scale factor as parameter (`1.0` being the default).                 |
diff --git a/tutorials/shaders/shader_reference/shading_language.md b/tutorials/shaders/shader_reference/shading_language.md
index 951f615..ba59627 100644
--- a/tutorials/shaders/shader_reference/shading_language.md
+++ b/tutorials/shaders/shader_reference/shading_language.md
@@ -9,7 +9,7 @@ Introduction
 Godot uses a shading language similar to GLSL ES 3.0. Most datatypes and functions are supported,
 and the few remaining ones will likely be added over time.
 
-If you are already familiar with GLSL, the `Godot Shader Migration Guide<doc_converting_glsl_to_godot_shaders )`
+If you are already familiar with GLSL, the `Godot Shader Migration Guide( doc_converting_glsl_to_godot_shaders )`
 is a resource that will help you transition from regular GLSL to Godot's shading language.
 
 Data types
@@ -627,9 +627,9 @@ Built-in variables
 A large number of built-in variables are available, like `UV`, `COLOR` and `VERTEX`. What variables are available depends on the type of shader (`spatial`, `canvas_item` or `particle`) and the function used (`vertex`, `fragment` or `light`).
 For a list of the build-in variables that are available, please see the corresponding pages:
 
-- `Spatial shaders <doc_spatial_shader )`
-- `Canvas item shaders <doc_canvas_item_shader )`
-- `Particle shaders <doc_particle_shader )`
+- `Spatial shaders ( doc_spatial_shader )`
+- `Canvas item shaders ( doc_canvas_item_shader )`
+- `Particle shaders ( doc_particle_shader )`
 
 Built-in functions
 ------------------
@@ -638,7 +638,7 @@ A large number of built-in functions are supported, conforming to GLSL ES 3.0.
 When vec_type (float), vec_int_type, vec_uint_type, vec_bool_type nomenclature is used, it can be scalar or vector.
 
 .. note:: For a list of the functions that are not available in the GLES2 backend, please see the
-          `Differences between GLES2 and GLES3 doc <doc_gles2_gles3_differences )`.
+          `Differences between GLES2 and GLES3 doc ( doc_gles2_gles3_differences )`.
 
 +------------------------------------------------------------------------+---------------------------------------------------------------+
 | Function                                                               | Description                                                   |
diff --git a/tutorials/shaders/shader_reference/spatial_shader.md b/tutorials/shaders/shader_reference/spatial_shader.md
index f072eb2..babece9 100644
--- a/tutorials/shaders/shader_reference/spatial_shader.md
+++ b/tutorials/shaders/shader_reference/spatial_shader.md
@@ -298,7 +298,7 @@ these properties, and if you don't write to them, Godot will optimize away the c
 
     Shaders going through the transparent pipeline when `ALPHA` is written to
     may exhibit transparency sorting issues. Read the
-    `transparency sorting section in the 3D rendering limitations page <doc_3d_rendering_limitations_transparency_sorting )`
+    `transparency sorting section in the 3D rendering limitations page ( doc_3d_rendering_limitations_transparency_sorting )`
     for more information and ways to avoid issues.
 
 Light built-ins
@@ -393,5 +393,5 @@ If you want the lights to add together, add the light contribution to `DIFFUSE_L
 
     Shaders going through the transparent pipeline when `ALPHA` is written to
     may exhibit transparency sorting issues. Read the
-    `transparency sorting section in the 3D rendering limitations page <doc_3d_rendering_limitations_transparency_sorting )`
+    `transparency sorting section in the 3D rendering limitations page ( doc_3d_rendering_limitations_transparency_sorting )`
     for more information and ways to avoid issues.
diff --git a/tutorials/shaders/your_first_shader/your_first_2d_shader.md b/tutorials/shaders/your_first_shader/your_first_2d_shader.md
index 8cbb18f..e03d812 100644
--- a/tutorials/shaders/your_first_shader/your_first_2d_shader.md
+++ b/tutorials/shaders/your_first_shader/your_first_2d_shader.md
@@ -9,7 +9,7 @@ Introduction
 Shaders are special programs that execute on the GPU and are used for rendering
 graphics. All modern rendering is done with shaders. For a more detailed
 description of what shaders are please see `What are shaders
-<doc_introduction_to_shaders )`.
+( doc_introduction_to_shaders )`.
 
 This tutorial will focus on the practical aspects of writing shader programs by
 walking you through the process of writing a shader with both vertex and
@@ -22,19 +22,19 @@ fragment functions. This tutorial targets absolute beginners to shaders.
 Setup
 -----
 
-`CanvasItem <doc_canvas_item_shader )` shaders are used to draw all 2D
-     objects in Godot, while `Spatial <doc_spatial_shader )` shaders are
+`CanvasItem ( doc_canvas_item_shader )` shaders are used to draw all 2D
+     objects in Godot, while `Spatial ( doc_spatial_shader )` shaders are
      used to draw all 3D objects.
 
 In order to use a shader it must be attached inside a `Material
-<class_material )` which must be attached to an object. Materials are a type of
-`Resource <doc_resources )`. To draw multiple objects with the same
+( material )` which must be attached to an object. Materials are a type of
+`Resource ( doc_resources )`. To draw multiple objects with the same
 material, the material must be attached to each object.
 
 All objects derived from a `CanvasItem` have a material
 property. This includes all `GUI elements`, `Sprites
-<class_sprite )`, `TileMaps`, `MeshInstance2Ds
-<class_meshinstance2d )` etc. They also have an option to inherit their parent's
+( sprite )`, `TileMaps`, `MeshInstance2Ds
+( meshinstance2d )` etc. They also have an option to inherit their parent's
 material. This can be useful if you have a large number of nodes that you want
 to use the same material.
 
@@ -92,7 +92,7 @@ every pixel.
 
 We do so by writing a `vec4` to the built-in variable `COLOR`. `vec4` is
 shorthand for constructing a vector with 4 numbers. For more information about
-vectors see the `Vector math tutorial <doc_vector_math )` `COLOR` is both
+vectors see the `Vector math tutorial ( doc_vector_math )` `COLOR` is both
 an input variable to the fragment function and the final output from it.
 
 .. code-block:: glsl
@@ -170,7 +170,7 @@ You can use uniforms by defining them at the top of your shader like so:
   uniform float size;
 
 For more information about usage see the `Shading Language doc
-<doc_shading_language )`.
+( doc_shading_language )`.
 
 Add a uniform to change the amount of blue in our Sprite.
 
diff --git a/tutorials/shaders/your_first_shader/your_first_3d_shader.md b/tutorials/shaders/your_first_shader/your_first_3d_shader.md
index 8688457..75b2e8f 100644
--- a/tutorials/shaders/your_first_shader/your_first_3d_shader.md
+++ b/tutorials/shaders/your_first_shader/your_first_3d_shader.md
@@ -10,7 +10,7 @@ needs. Either way, you have decided to write your own and now you need to figure
 out where to start.
 
 This tutorial will explain how to write a Spatial shader and will cover more
-topics than the `CanvasItem <doc_your_first_canvasitem_shader )` tutorial.
+topics than the `CanvasItem ( doc_your_first_canvasitem_shader )` tutorial.
 
 Spatial shaders have more built-in functionality than CanvasItem shaders. The
 expectation with spatial shaders is that Godot has already provided the
@@ -20,7 +20,7 @@ rendering) workflow.
 
 This is a two-part tutorial. In this first part we are going to go through how
 to make a simple terrain using vertex displacement from a heightmap in the
-vertex function. In the `second part <doc_your_second_spatial_shader )` we
+vertex function. In the `second part ( doc_your_second_spatial_shader )` we
 are going to take the concepts from this tutorial and walk through how to set up
 custom materials in a fragment shader by writing an ocean water shader.
 
@@ -38,12 +38,12 @@ type that store geometry (the shape of your object) and materials (the color and
 how the object reacts to light) in units called "surfaces". A Mesh can have
 multiple surfaces, or just one. Typically, you would import a mesh from another
 program (e.g. Blender). But Godot also has a few `PrimitiveMeshes
-<class_primitivemesh )` that allow you to add basic geometry to a scene without
+( primitivemesh )` that allow you to add basic geometry to a scene without
 importing Meshes.
 
 There are multiple node types that you can use to draw a mesh. The main one is
 `MeshInstance`, but you can also use `Particles
-<class_particles )`, `MultiMeshes` (with a
+( particles )`, `MultiMeshes` (with a
 `MultiMeshInstance`), or others.
 
 Typically, a material is associated with a given surface in a mesh, but some
@@ -81,7 +81,7 @@ Now set `Subdivide Width` and `Subdivide Depth` to `32`.
 ![](img/plane-sub-set.png)
 
 You can see that there are now many more triangles in the
-`Mesh<class_MeshInstance )`. This will give us more vertices to work with
+`Mesh( MeshInstance )`. This will give us more vertices to work with
 and thus allow us to add more detail.
 
 ![](img/plane-sub.png)
@@ -111,7 +111,7 @@ because this is a spatial shader.
   shader_type spatial;
 
 Next we will define the `vertex()` function. The `vertex()` function
-determines where the vertices of your `Mesh<class_MeshInstance )` appear in
+determines where the vertices of your `Mesh( MeshInstance )` appear in
 the final scene. We will be using it to offset the height of each vertex and
 make our flat plane appear like a little terrain.
 
@@ -223,7 +223,7 @@ Uniforms
 Uniform variables allow you to pass data from the game into the shader. They are
 very useful for controlling shader effects. Uniforms can be almost any datatype
 that can be used in the shader. To use a uniform, you declare it in your
-`Shader<class_Shader )` using the keyword `uniform`.
+`Shader( Shader )` using the keyword `uniform`.
 
 Let's make a uniform that changes the height of the terrain.
 
@@ -251,8 +251,8 @@ the shader.
           `get_surface_material()` or `material_override`.
 
 Remember that the string passed into `set_shader_param()` must match the name
-of the uniform variable in the `Shader<class_Shader )`. You can use the
-uniform variable anywhere inside your `Shader<class_Shader )`. Here, we will
+of the uniform variable in the `Shader( Shader )`. You can use the
+uniform variable anywhere inside your `Shader( Shader )`. Here, we will
 use it to set the height value instead of arbitrarily multiplying by `0.5`.
 
 .. code-block:: glsl
@@ -278,7 +278,7 @@ again, where it says "Perspective", and select "Display Normal".
 Note how the mesh color goes flat. This is because the lighting on it is flat.
 Let's add a light!
 
-First, we will add an `OmniLight<class_OmniLight )` to the scene.
+First, we will add an `OmniLight( OmniLight )` to the scene.
 
 ![](img/light.png)
 
diff --git a/tutorials/shaders/your_first_shader/your_second_3d_shader.md b/tutorials/shaders/your_first_shader/your_second_3d_shader.md
index 0cd6dc2..2798f9f 100644
--- a/tutorials/shaders/your_first_shader/your_second_3d_shader.md
+++ b/tutorials/shaders/your_first_shader/your_second_3d_shader.md
@@ -13,12 +13,12 @@ shading, without writing complex shaders. Of course, Godot also allows you to
 ignore all these parameters and write a fully customized shader.
 
 For a full list of these parameters see the `spatial shader
-<doc_spatial_shader )` reference doc.
+( doc_spatial_shader )` reference doc.
 
 A difference between the vertex function and a fragment function is that the
 vertex function runs per vertex and sets properties such as `VERTEX`
 (position) and `NORMAL`, while the fragment shader runs per pixel and, most
-importantly, sets the `ALBEDO` color of the `Mesh<class_MeshInstance )`.
+importantly, sets the `ALBEDO` color of the `Mesh( MeshInstance )`.
 
 Your first spatial fragment function
 ------------------------------------
@@ -49,7 +49,7 @@ This model of built-in functionality allows you to write complex custom shaders
 by changing only a few parameters.
 
 For a full list of render modes see the `Spatial shader reference
-<doc_spatial_shader )`.
+( doc_spatial_shader )`.
 
 In this part of the tutorial, we will walk through how to take the bumpy terrain
 from the previous part and turn it into an ocean.
@@ -344,7 +344,7 @@ to do was add a bit of math!
 ![](img/wave3.png)
 
 For more information about Spatial shaders read the `Shading Language
-<doc_shading_language )` doc and the `Spatial Shaders <doc_spatial_shader )`
+( doc_shading_language )` doc and the `Spatial Shaders ( doc_spatial_shader )`
 doc. Also look at more advanced tutorials in the `Shading section
 <toc-learn-features-shading )` and the `3D <toc-learn-features-3d )`
 sections.
diff --git a/tutorials/ui/bbcode_in_richtextlabel.md b/tutorials/ui/bbcode_in_richtextlabel.md
index 1b8146e..d695fb4 100644
--- a/tutorials/ui/bbcode_in_richtextlabel.md
+++ b/tutorials/ui/bbcode_in_richtextlabel.md
@@ -16,7 +16,7 @@ a `RichTextLabel`.
 It has a built-in API for generating the markup, but can also parse a BBCode.
 
 Note that the BBCode tags can also be used, to some extent, in the
-`XML source of the class reference <doc_updating_the_class_reference )`.
+`XML source of the class reference ( doc_updating_the_class_reference )`.
 
 Using BBCode
 ------------
diff --git a/tutorials/ui/gui_containers.md b/tutorials/ui/gui_containers.md
index 84acc22..90d9fe6 100644
--- a/tutorials/ui/gui_containers.md
+++ b/tutorials/ui/gui_containers.md
@@ -3,7 +3,7 @@
 Using Containers
 ================
 
-`Anchors <doc_size_and_anchors )` are an efficient way to handle
+`Anchors doc_size_and_anchors )` are an efficient way to handle
 different aspect ratios for basic multiple resolution handling in GUIs,
 
 For more complex user interfaces, they can become difficult to use.
diff --git a/tutorials/ui/gui_navigation.md b/tutorials/ui/gui_navigation.md
index 722dcd6..151f115 100644
--- a/tutorials/ui/gui_navigation.md
+++ b/tutorials/ui/gui_navigation.md
@@ -7,7 +7,7 @@ It is a common requirement for a user interface to have full keyboard
 and controller support for navigation and interaction. There are two main
 reasons why this is beneficial for projects: improved accessibility (not everyone
 can use mouse or touch controls for interactions), and getting your project
-ready for `consoles <doc_consoles )` (or just for people who prefer
+ready for `consoles doc_consoles )` (or just for people who prefer
 to game with a controller on PC).
 
 Navigating between UI elements with keyboard or controller is done by
diff --git a/tutorials/ui/gui_skinning.md b/tutorials/ui/gui_skinning.md
index 25c68bb..07b0c4a 100644
--- a/tutorials/ui/gui_skinning.md
+++ b/tutorials/ui/gui_skinning.md
@@ -36,13 +36,13 @@ the built-in control nodes. This is what gives the controls their distinct look
 out of the box. A theme only describes the configuration, however, and it is still
 the job of each individual control to use that configuration in the way it requires
 to display itself. This is important to remember when implementing
-`your own custom controls <doc_custom_gui_controls )`.
+`your own custom controls doc_custom_gui_controls )`.
 
 .. note::
    Even the Godot editor itself relies on the default theme. But it doesn't look the
    same as a Godot project, because it applies its own heavily customized theme on top
    of the default one. In principle, this works exactly like it would in your game
-   as explained `below <doc_gui_theme_in_project )`.
+   as explained `below doc_gui_theme_in_project )`.
 
 Theme items
 ~~~~~~~~~~~
@@ -139,7 +139,7 @@ control node in the single `Theme` resource.
    two places, but it is recommended to keep all variations to the project theme.
 
 You can learn more about creating and using theme type variations in a
-`dedicated article <doc_gui_theme_type_variations )`.
+`dedicated article doc_gui_theme_type_variations )`.
 
 Customizing a control
 ---------------------
@@ -175,8 +175,8 @@ with a custom theme. Custom themes can be applied in two ways: as a project sett
 and as a node property throughout the tree of control nodes.
 
 There are two project settings that can be adjusted to affect your entire project:
-`gui/theme/custom<class_ProjectSettings_property_gui/theme/custom )` allows you to
-set a custom project-wide theme, and `gui/theme/custom_font<class_ProjectSettings_property_gui/theme/custom_font )`
+`gui/theme/customclass_ProjectSettings_property_gui/theme/custom )` allows you to
+set a custom project-wide theme, and `gui/theme/custom_fontclass_ProjectSettings_property_gui/theme/custom_font )`
 does the same to the default fallback font. When a theme item is requested by a control
 node the custom project theme, if present, is checked first. Only if it doesn't have
 the item the default theme is checked.
diff --git a/tutorials/ui/gui_theme_type_variations.md b/tutorials/ui/gui_theme_type_variations.md
index a62bb3e..6742598 100644
--- a/tutorials/ui/gui_theme_type_variations.md
+++ b/tutorials/ui/gui_theme_type_variations.md
@@ -16,7 +16,7 @@ between several controls. Imagine that you use gray, blue, and red variants of `
 throughout your project. Setting it up every time you add a new button element to your interface
 is a tedious task.
 
-To help with the organization and to better utilize the `power of themes <doc_gui_skinning )`
+To help with the organization and to better utilize the `power of themes doc_gui_skinning )`
 you can use theme type variations. These work like normal theme types, but instead
 of being self-sufficient and standalone they extend another, base type.
 
@@ -33,7 +33,7 @@ a combination of both types giving priority to the type variation.
 
 .. note::
    The way controls resolve what theme items they use from each type and each
-   theme is better described in the `Customizing a project <doc_gui_theme_in_project )`
+   theme is better described in the `Customizing a project doc_gui_theme_in_project )`
    section of the "Introduction to GUI skinning" article.
 
 Creating a type variation