Date written: June 25, 2026

Purpose

Record, based on the actual debugging state, how the make_md web UI delivered the Markdown file to Qwen 3.6 and what response was received.

The API key is not included in the request payload, and it is not recorded in this document.

Observation Timestamp State

state file: /Users/joyeongjin/make_md/work/web_state/state.json
status: converting
auto_continue: True
current_file: pages/classes__class___40gdscript__a254d64e.md
current_table: docs_chunks
file status counts: {'done': 5, 'deferred': 3, 'converting': 1, 'pending': 1561}
classification_debug count: 9
conversion_debug count: 7

Processing Log

▶️ pages/404__8fea2a72.md: started  
🏷️ Classifying Qwen tables...  
⏭️ pages/404__8fea2a72.md: Qwen returned no target tables; skipped (see Classification Decisions)  
✅ pages/404__8fea2a72.md: done (0 valid records)  
▶️ pages/about__complying_with_licenses__d36558dd.md: started  
🏷️ Classifying Qwen tables...  
📄 pages/about__complying_with_licenses__d36558dd.md → tables: ['docs_chunks']  
📡 Calling Qwen API...  
  [docs_chunks] valid=11, invalid=0  
✅ pages/about__complying_with_licenses__d36558dd.md: done (11 valid records)  
▶️ pages/about__docs_changelog__67dbc069.md: started  
⏭️ pages/about__docs_changelog__67dbc069.md: deferred after timeout; auto will continue with next file  
▶️ pages/about__faq__32bebcf7.md: started  
⏭️ pages/about__faq__32bebcf7.md: deferred after timeout; auto will continue with next file  
▶️ pages/about__introduction__344b3840.md: started  
🏷️ Classifying Qwen tables...  
📄 pages/about__introduction__344b3840.md → tables: ['docs_chunks']  
📡 Calling Qwen API...  
  [docs_chunks] valid=5, invalid=0  
✅ pages/about__introduction__344b3840.md: done (5 valid records)  
▶️ pages/about__list_of_features__273abdc4.md: started  
⏭️ pages/about__list_of_features__273abdc4.md: deferred after timeout; auto will continue with next file  
▶️ pages/about__release_policy__9f3af805.md: started  
🏷️ Classifying Qwen tables...  
📄 pages/about__release_policy__9f3af805.md → tables: ['docs_chunks']  
📡 Calling Qwen API...  
  [docs_chunks] valid=7, invalid=0  
✅ pages/about__release_policy__9f3af805.md: done (7 valid records)  
▶️ pages/about__system_requirements__6f1863c2.md: started  
🏷️ Classifying Qwen tables...  
📄 pages/about__system_requirements__6f1863c2.md → tables: ['docs_chunks']  
📡 Calling Qwen API...  
  [docs_chunks] valid=3, invalid=0  
✅ pages/about__system_requirements__6f1863c2.md: done (3 valid records)  
▶️ pages/classes__class___40gdscript__a254d64e.md: started

Classification Debug

1. pages/404__8fea2a72.md

stage: classification
api_url: [redacted]
model: [redacted]
markdown_length: 901
prompt_length: 1310
parsed_result: []
matched_tables: []
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 74
  },
  {
    "role": "user",
    "content_length": 1320
  }
]

Full Classification Prompt Sent To Qwen

Classify this Markdown into zero or more target tables.
Return exactly one JSON array. Valid values are:
["docs_chunks", "api_mapping", "label_prototypes"]

Rules:
- Use [] only if the file is not useful documentation content.
- Use one or more valid table names when conversion is needed.
- Do not include explanations, markdown fences, or any text outside JSON.

FILE: pages/404__8fea2a72.md
FULL MARKDOWN:
# Source: https://docs.godotengine.org/en/stable/404.html

# Page not found

- Godot Engine 4.6 documentation in English
  
  - Page not found
- - Edit on GitHub
  
  
Learn how to contribute!

# Page not found

Sorry, we couldn't find that page. It may have been renamed or removed
in the version of the documentation you're currently browsing.

If you're currently browsing the
latest version of the documentation, try browsing the
[stable version of the documentation](/en/stable/).

Alternatively, use the
Search docs
box on the left or [go to the homepage](/).

## User-contributed notes

Please read the [User-contributed notes policy](https://github.com/godotengine/godot-docs-user-notes/discussions/1) before submitting a comment.

© Copyright 2014-present Juan Linietsky, Ariel Manzur and the Godot community (CC BY 3.0).

  Built with Sphinx using a
    theme
    provided by Read the Docs.

Classification Response Finish Reason

stop

Classification Response Content

[]

Classification Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Input Text:** A Markdown file representing a 404 error page from the Godot Engine documentation.
   - **Task:** Classify into zero or more target tables: `["docs_chunks", "api_mapping", "label_prototypes"]`
   - **Rules:** Return exactly one JSON array. Use `[]` if not useful documentation content. Use one or more valid table names if conversion is needed. No markdown, no prose, no thinking text.

2.  **Evaluate Content against Target Tables:**
   - `docs_chunks`: Typically contains actual documentation content (tutorials, guides, reference pages). This is a 404 page ("Page not found"), which is generally considered boilerplate/error page content, not useful documentation chunks for training or reference.
   - `api_mapping`: Maps API classes/methods to documentation. This page doesn't contain API references.
   - `label_prototypes`: Contains labels or prototypes for UI/ML tasks. Not applicable here.
   - **Conclusion:** The content is a standard 404 error page. It's not useful documentation content. According to the rules: "Use [] only if the file is not useful documentation content."

3.  **Format Output:**
   - Must be exactly one JSON array.
   - Result: `[]`
   - Check constraints: No markdown, no prose, no thinking text.

   Output matches requirement.✅
   Proceed. 
   Self-Correction/Verification during thought: 
   Could it be `docs_chunks`? Sometimes 404 pages are kept as chunks, but the prompt explicitly says "Use [] only if the file is not useful documentation content." A 404 page is definitively not useful documentation content. So `[]` is correct.
   Output: `[]`
   Ready. 
   Generate. 
   [Output Generation] -> `[]` (as raw JSON)
   Check format: "Return only valid JSON. No markdown. No prose. No thinking text."
   All good. 
   Proceeds. 
   [Output] `[]`
   *(Self-Correction/Refinement during thought)*: Wait, sometimes 404 pages are classified as `docs_chunks` if they contain navigation or footer info, but the rule is strict: "Use [] only if the file is not useful documentation content." I'll stick with `[]`.
   Final answer: `[]`✅
   Output matches. 
   Proceeds. 
   [Output Generation] `[]`
   *(Done.)*

Raw Classification Response

{
  "finish_reason": "stop",
  "content": "[]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Input Text:** A Markdown file representing a 404 error page from the Godot Engine documentation.\n   - **Task:** Classify into zero or more target tables: `[\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]`\n   - **Rules:** Return exactly one JSON array. Use `[]` if not useful documentation content. Use one or more valid table names if conversion is needed. No markdown, no prose, no thinking text.\n\n2.  **Evaluate Content against Target Tables:**\n   - `docs_chunks`: Typically contains actual documentation content (tutorials, guides, reference pages). This is a 404 page (\"Page not found\"), which is generally considered boilerplate/error page content, not useful documentation chunks for training or reference.\n   - `api_mapping`: Maps API classes/methods to documentation. This page doesn't contain API references.\n   - `label_prototypes`: Contains labels or prototypes for UI/ML tasks. Not applicable here.\n   - **Conclusion:** The content is a standard 404 error page. It's not useful documentation content. According to the rules: \"Use [] only if the file is not useful documentation content.\"\n\n3.  **Format Output:**\n   - Must be exactly one JSON array.\n   - Result: `[]`\n   - Check constraints: No markdown, no prose, no thinking text.\n\n   Output matches requirement.✅\n   Proceed. \n   Self-Correction/Verification during thought: \n   Could it be `docs_chunks`? Sometimes 404 pages are kept as chunks, but the prompt explicitly says \"Use [] only if the file is not useful documentation content.\" A 404 page is definitively not useful documentation content. So `[]` is correct.\n   Output: `[]`\n   Ready. \n   Generate. \n   [Output Generation] -> `[]` (as raw JSON)\n   Check format: \"Return only valid JSON. No markdown. No prose. No thinking text.\"\n   All good. \n   Proceeds. \n   [Output] `[]`\n   *(Self-Correction/Refinement during thought)*: Wait, sometimes 404 pages are classified as `docs_chunks` if they contain navigation or footer info, but the rule is strict: \"Use [] only if the file is not useful documentation content.\" I'll stick with `[]`.\n   Final answer: `[]`✅\n   Output matches. \n   Proceeds. \n   [Output Generation] `[]`\n   *(Done.)*\n"
}

2. pages/about__complying_with_licenses__d36558dd.md

stage: classification
api_url: [redacted]
model: [redacted]
markdown_length: 5417
prompt_length: 5853
parsed_result: ['docs_chunks']
matched_tables: ['docs_chunks']
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 74
  },
  {
    "role": "user",
    "content_length": 5863
  }
]

Full Classification Prompt Sent To Qwen

Classify this Markdown into zero or more target tables.
Return exactly one JSON array. Valid values are:
["docs_chunks", "api_mapping", "label_prototypes"]

Rules:
- Use [] only if the file is not useful documentation content.
- Use one or more valid table names when conversion is needed.
- Do not include explanations, markdown fences, or any text outside JSON.

FILE: pages/about__complying_with_licenses__d36558dd.md
FULL MARKDOWN:
# Source: https://docs.godotengine.org/en/stable/about/complying_with_licenses.html

Godot Engine 4.6 documentation in English
Complying with licenses
Edit on GitHub
Learn how to contribute!
Complying with licenses

Warning
The recommendations in this page
are not legal advice.
They are provided
in good faith to help users navigate license attribution requirements.
What are licenses?

Godot is created and distributed under the
MIT License
.
It doesn't have a sole owner, as every contributor that submits code to
the project does it under this same license and keeps ownership of their
contribution.
The license is the legal requirement for you (or your company) to use and
distribute the software (and derivative projects, including games made with it).
Your game or project can have a different license, but it still needs to comply
with the original one.
Note
This section covers compliance with licenses from a user perspective.
If you are interested in licence compliance as a contributor, you can find
guidelines
here
.
Tip
Alongside the Godot license text, remember to also list third-party notices
for assets you're using, such as textures, models, sounds, music and fonts.
This includes free assets, which often come with licenses that require
attribution.
Requirements

In the case of the MIT license, the only requirement is to include the license
text somewhere in your game or derivative project.
This text reads as follows:
This game uses Godot Engine, available under the following license:

Copyright (c) 2014-present Godot Engine contributors.
Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Copy to clipboard
Beside its own MIT license, Godot includes code from a number of third-party
libraries. See
Third-party licenses
for details.
Note
Your games do not need to be under the same license. You are free to release
your Godot projects under any license and to create commercial games with
the engine.
Inclusion

The license text must be made available to the user. The license doesn't specify
how the text has to be included, but here are the most common approaches (you
only need to implement one of them, not all).
Credits screen

Include the above license text somewhere in the credits screen. It can be at the
bottom after showing the rest of the credits. Most large studios use this
approach with open source licenses.
Licenses screen

Some games have a special menu (often in the settings) to display licenses.
This menu is typically accessed with a button called
Third-party Licenses
or
Open Source Licenses
.
Output log

Printing the license text using the
print()
function may be enough on platforms where a global output log is readable.
This is the case on desktop platforms, Android and HTML5 (but not iOS).
Accompanying file

If the game is distributed on desktop platforms, a file containing the license
text can be added to the software that is installed to the user PC.
Printed manual

If the game includes a printed manual, the license text can be included there.
Link to the license

The Godot Engine developers consider that a link to
godotengine.org/license
in your game documentation or credits would be an acceptable way to satisfy
the license terms.
Tip
Godot provides several methods to get license information in the
Engine
singleton. This allows you to source the
license information directly from the engine binary, which prevents the
information from becoming outdated if you update engine versions.
For the engine itself:
Engine.get_license_text
For third-party components used by the engine:
Engine.get_license_info
Engine.get_copyright_info
Third-party licenses

Godot itself contains software written by
third parties
,
which is compatible with, but not covered by Godot's MIT license.
Many of these dependencies are distributed under permissive open source licenses
which require attribution by explicitly citing their copyright statement and
license text in the final product's documentation.
Given the scope of the Godot project, this is fairly difficult to do thoroughly.
For the Godot editor, the full documentation of third-party copyrights and
licenses is provided in the
COPYRIGHT.txt
file.
A good option for end users to document third-party licenses is to include this
file in your project's distribution, which you can e.g. rename to
GODOT_COPYRIGHT.txt
to prevent any confusion with your own code and assets.

Classification Response Finish Reason

stop

Classification Response Content

["docs_chunks"]

Classification Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Input File:** `pages/about__complying_with_licenses__d36558dd.md`
   - **Content:** Markdown documentation about complying with Godot Engine licenses. Covers MIT license, requirements, inclusion methods (credits screen, licenses screen, output log, etc.), third-party licenses, and engine methods for getting license info.
   - **Task:** Classify into zero or more target tables: `["docs_chunks", "api_mapping", "label_prototypes"]`
   - **Output Format:** Exactly one JSON array. Valid values are the table names. No markdown, no prose, no thinking text.

2.  **Understand Target Tables:**
   - `docs_chunks`: General documentation content, articles, guides, reference pages.
   - `api_mapping`: Maps API functions/classes to documentation or describes API usage/signatures.
   - `label_prototypes`: Defines UI labels, strings, or localization prototypes.

3.  **Evaluate Content against Tables:**
   - The content is clearly a documentation page about license compliance. It explains concepts, lists requirements, and mentions some API methods (`Engine.get_license_text`, etc.) but the primary focus is general documentation/guide.
   - It fits perfectly into `docs_chunks`.
   - Does it fit `api_mapping`? It mentions a couple of engine methods, but it's not primarily an API reference or mapping. It's a guide. So `docs_chunks` is sufficient.
   - Does it fit `label_prototypes`? No.
   - Therefore, the classification should be `["docs_chunks"]`.

4.  **Format Output:**
   - Must be exactly one JSON array.
   - `["docs_chunks"]`
   - Check constraints: No markdown fences, no prose, no thinking text.

   Output: `["docs_chunks"]`

   Double-check: The prompt says "Return only valid JSON. No markdown. No prose. No thinking text."
   I will output exactly `["docs_chunks"]`.✅
   All constraints met. Proceed. 
   Self-Correction/Refinement during thought: 
   Could it be `["docs_chunks", "api_mapping"]`? The prompt says "zero or more". The content is primarily docs. I'll stick with `["docs_chunks"]` as it's the most accurate. Even if it mentions APIs, it's a docs chunk. I'll output `["docs_chunks"]`.
   Final check of the prompt: "Valid values are: ["docs_chunks", "api_mapping", "label_prototypes"]"
   Output matches.✅
   Proceed. 
   Output Generation. 
   `["docs_chunks"]`
   (Note: I will ensure no backticks or markdown formatting around it as requested: "No markdown.")
   Actually, the prompt says "No markdown fences", but usually it's safer to just output raw JSON. I'll output raw JSON.
   `["docs_chunks"]` is correct.✅
   Done. 
   Output matches request. 
   [Proceeds]

Raw Classification Response

{
  "finish_reason": "stop",
  "content": "[\"docs_chunks\"]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Input File:** `pages/about__complying_with_licenses__d36558dd.md`\n   - **Content:** Markdown documentation about complying with Godot Engine licenses. Covers MIT license, requirements, inclusion methods (credits screen, licenses screen, output log, etc.), third-party licenses, and engine methods for getting license info.\n   - **Task:** Classify into zero or more target tables: `[\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]`\n   - **Output Format:** Exactly one JSON array. Valid values are the table names. No markdown, no prose, no thinking text.\n\n2.  **Understand Target Tables:**\n   - `docs_chunks`: General documentation content, articles, guides, reference pages.\n   - `api_mapping`: Maps API functions/classes to documentation or describes API usage/signatures.\n   - `label_prototypes`: Defines UI labels, strings, or localization prototypes.\n\n3.  **Evaluate Content against Tables:**\n   - The content is clearly a documentation page about license compliance. It explains concepts, lists requirements, and mentions some API methods (`Engine.get_license_text`, etc.) but the primary focus is general documentation/guide.\n   - It fits perfectly into `docs_chunks`.\n   - Does it fit `api_mapping`? It mentions a couple of engine methods, but it's not primarily an API reference or mapping. It's a guide. So `docs_chunks` is sufficient.\n   - Does it fit `label_prototypes`? No.\n   - Therefore, the classification should be `[\"docs_chunks\"]`.\n\n4.  **Format Output:**\n   - Must be exactly one JSON array.\n   - `[\"docs_chunks\"]`\n   - Check constraints: No markdown fences, no prose, no thinking text.\n\n   Output: `[\"docs_chunks\"]`\n\n   Double-check: The prompt says \"Return only valid JSON. No markdown. No prose. No thinking text.\"\n   I will output exactly `[\"docs_chunks\"]`.✅\n   All constraints met. Proceed. \n   Self-Correction/Refinement during thought: \n   Could it be `[\"docs_chunks\", \"api_mapping\"]`? The prompt says \"zero or more\". The content is primarily docs. I'll stick with `[\"docs_chunks\"]` as it's the most accurate. Even if it mentions APIs, it's a docs chunk. I'll output `[\"docs_chunks\"]`.\n   Final check of the prompt: \"Valid values are: [\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]\"\n   Output matches.✅\n   Proceed. \n   Output Generation. \n   `[\"docs_chunks\"]`\n   (Note: I will ensure no backticks or markdown formatting around it as requested: \"No markdown.\")\n   Actually, the prompt says \"No markdown fences\", but usually it's safer to just output raw JSON. I'll output raw JSON.\n   `[\"docs_chunks\"]` is correct.✅\n   Done. \n   Output matches request. \n   [Proceeds]\n"
}

3. pages/about__docs_changelog__67dbc069.md

stage: classification
api_url: [redacted]
model: [redacted]
markdown_length: 5972
prompt_length: 6399
parsed_result: ['docs_chunks']
matched_tables: ['docs_chunks']
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 74
  },
  {
    "role": "user",
    "content_length": 6409
  }
]

Full Classification Prompt Sent To Qwen

Classify this Markdown into zero or more target tables.
Return exactly one JSON array. Valid values are:
["docs_chunks", "api_mapping", "label_prototypes"]

Rules:
- Use [] only if the file is not useful documentation content.
- Use one or more valid table names when conversion is needed.
- Do not include explanations, markdown fences, or any text outside JSON.

FILE: pages/about__docs_changelog__67dbc069.md
FULL MARKDOWN:
# Source: https://docs.godotengine.org/en/stable/about/docs_changelog.html

Godot Engine 4.6 documentation in English
Documentation changelog
Edit on GitHub
Learn how to contribute!
Documentation changelog

The documentation is continually being improved. New releases
include new pages, fixes and updates to existing pages, and many updates
to the
class reference
. Below is a list of new pages
added since version 3.0.
Note
This document only contains new pages, so not all changes are reflected.
Many pages have been substantially updated but are not reflected in this document.
New pages since version 4.4

Editor

Using the engine compilation configuration editor
GDExtension

GDExtension C example
Migrating

Upgrading from Godot 4.4 to Godot 4.5
Scripting

Logging
New pages since version 4.3

2D

Introduction to 2D
3D

Third-person camera with spring arm
Debug

Output panel
Editor

Using the XR editor
Migrating

Upgrading from Godot 4.3 to Godot 4.4
Performance

Reducing stutter from shader (pipeline) compilations
Physics

Physics Interpolation
Quick start guide
Introduction
Using physics interpolation
Advanced physics interpolation
2D and 3D physics interpolation
Rendering

Overview of renderers
Shaders

Built-in functions
New pages since version 4.2

About

System requirements
2D

2D Parallax
Contributing

Handling compatibility breakages
GDExtension

The .gdextension file
Adding documentation
Migrating

Upgrading from Godot 4.2 to Godot 4.3
Rendering

The Compositor
XR

A better XR start script
AR / Passthrough
Where to go from here
OpenXR Settings
OpenXR composition layers
OpenXR body tracking
New pages since version 4.1

C#

C# diagnostics
Development

2D coordinate systems and 2D transforms
Migrating

Upgrading from Godot 4.1 to Godot 4.2
I/O

Runtime file loading and saving
Platform-specific

Godot Android library
New pages since version 4.0

Development

Internal rendering architecture
Using sanitizers
Migrating

Upgrading from Godot 4.0 to Godot 4.1
Physics

Troubleshooting physics issues
New pages since version 3.6

2D

2D antialiasing
3D

3D antialiasing
Faking global illumination
Introduction to global illumination
Mesh level of detail (LOD)
Occlusion culling
Signed distance field global illumination (SDFGI)
Using decals
Visibility ranges (HLOD)
Volumetric fog and fog volumes
Variable rate shading
Physical light and camera units
Animation

Creating movies
Assets pipeline

Retargeting 3D Skeletons
Development

Custom platform ports
Migrating

Upgrading from Godot 3 to Godot 4
Physics

Large world coordinates
Scripting

Custom performance monitors
C# collections
C# global classes
C# Variant
Shaders

Using compute shaders
XR

Introducing XR tools
The XR action map
Deploying to Android
New pages since version 3.5

None.
New pages since version 3.4

3D

3D text
Animation

Playing videos
Editor

Managing editor features
New pages since version 3.3

GDScript

GDScript documentation comments
New pages since version 3.2

3D

3D rendering limitations
About

Troubleshooting
List of features
Godot release policy
Best practices

Version control systems
Development

Error macros
Validation layers
GDScript grammar
Configuring an IDE:
Code::Blocks
Editor

Default editor shortcuts
Using the Web editor
Export

Exporting for dedicated servers
Input

Controllers, gamepads, and joysticks
Math

Random number generation
Platform-specific

Plugins for iOS
Creating iOS plugins
HTML5 shell class reference
Physics

Collision shapes (2D)
Collision shapes (3D)
Shaders

Shaders style guide
Scripting

Debugger panel
Creating script templates
Evaluating expressions
What is GDExtension?
GDScript warning system
(split from
Static typing in GDScript
)
User Interface (UI)

Control node gallery
New pages since version 3.1

Project workflow

Gradle builds for Android
2D

2D sprite animation
Audio

Recording with microphone
Sync the gameplay with audio and music
Math

Beziers, curves and paths
Interpolation
Inputs

Input examples
Internationalization

Localization using gettext (PO files)
Shading

Your First Shader Series:
Introduction to shaders
Your first 2D shader
Your first 3D shader
Your second 3D shader
Using VisualShaders
Networking

WebRTC
Plugins

Godot Android plugins
Inspector plugins
Visual Shader plugins
Multi-threading

Using multiple threads
Creating content

Procedural geometry series:
Procedural geometry
Using the ArrayMesh
Using the SurfaceTool
Using the MeshDataTool
Using ImmediateMesh
Optimization

Optimization using MultiMeshes
Optimization using Servers
Legal

Complying with licenses
New pages since version 3.0

Step by step

Using signals
Exporting
Scripting

Static typing in GDScript
Project workflow

Best Practices:
Introduction
Applying object-oriented principles in Godot
Scene organization
When to use scenes versus scripts
Autoloads versus regular nodes
When and how to avoid using nodes for everything
Godot interfaces
Godot notifications
Data preferences
Logic preferences
2D

2D lights and shadows
2D meshes
3D

Prototyping levels with CSG
Animating thousands of fish with MultiMeshInstance3D
Controlling thousands of fish with Particles
Physics

Ragdoll system
Using SoftBody3D
Animation

2D skeletons
Using AnimationTree
GUI

Using Containers
Viewports

Using a SubViewport as a texture
Custom post-processing
Shading

Converting GLSL to Godot shaders
Advanced post-processing
Shading Reference:
Introduction to shaders
Shading language
Spatial shaders
CanvasItem shaders
Particle shaders
Plugins

Making main screen plugins
3D gizmo plugins
Platform-specific

Custom HTML page for Web export
Multi-threading

Thread-safe APIs
Creating content

Making trees
Miscellaneous

Fixing jitter, stutter and input lag
Running code in the editor
Change scenes manually
Compiling

Optimizing a build for size
Compiling with PCK encryption key
Engine development

Binding to external libraries

Classification Response Finish Reason

stop

Classification Response Content

["docs_chunks"]

Classification Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Input Text:** A Markdown file titled "Source: https://docs.godotengine.org/en/stable/about/docs_changelog.html" containing a changelog of new documentation pages added to the Godot Engine documentation across various versions (3.0 to 4.6).
   - **Task:** Classify the Markdown into zero or more target tables from the list: `["docs_chunks", "api_mapping", "label_prototypes"]`.
   - **Output Format:** Exactly one JSON array. Valid values are the table names. Use `[]` if not useful. No markdown, no prose, no thinking text.
   - **Rules:** Return only valid JSON. No markdown fences. No prose. No thinking text.

2.  **Understand Target Tables:**
   - `docs_chunks`: Typically refers to documentation content split into logical chunks/sections, often used for RAG or documentation indexing. This file is clearly a documentation changelog listing new pages, which fits well as documentation content.
   - `api_mapping`: Maps API classes/methods to documentation or code. This file lists documentation page titles, not API mappings.
   - `label_prototypes`: Defines labels or tags for classification. This file doesn't define labels.
   - Conclusion: `docs_chunks` is the most appropriate classification.

3.  **Evaluate Content against `docs_chunks`:**
   - The content is a structured list of documentation pages added per version. It's pure documentation metadata/changelog. It fits the definition of documentation content that would be chunked or indexed.
   - Therefore, it should be classified as `["docs_chunks"]`.

4.  **Format Output:**
   - Must be exactly one JSON array.
   - `["docs_chunks"]`
   - Check constraints: No markdown, no prose, no thinking text. Just the JSON.

   Final check of the prompt: "Return only valid JSON. No markdown. No prose. No thinking text. /no_think"
   Output: `["docs_chunks"]`

   All constraints met. Proceed. 
   Self-Correction/Refinement during thought: 
   Could it be `[]`? The prompt says "Use [] only if the file is not useful documentation content." This is definitely useful documentation content (a changelog for docs). So `["docs_chunks"]` is correct.
   I will output exactly `["docs_chunks"]`.✅
   Proceed. 
   Output Generation. 
   `["docs_chunks"]` (no backticks, no newlines if possible, but standard JSON is fine)
   Wait, the prompt says "No markdown." So I won't use backticks.
   Final string: `["docs_chunks"]`
   Done. 
   Output matches requirement. 
   Proceeds. 
   [Output Generation] -> `["docs_chunks"]`
   *(Self-Correction/Verification during thought)*: 
   Let's double check the exact table names: `["docs_chunks", "api_mapping", "label_prototypes"]`.
   The content is a changelog of documentation pages. It's clearly documentation. So `docs_chunks` is correct.
   JSON array format: `["docs_chunks"]`
   All good. 
   Output matches. 
   Proceeds. 
   [Final Output Generation] -> `["docs_chunks"]` (exactly)
   *(Note: I will ensure no extra whitespace or newlines are added if possible, but standard JSON formatting is fine.)*
   Ready. 
   Output: `["docs_chunks"]`
   *(Done.)*

Raw Classification Response

{
  "finish_reason": "stop",
  "content": "[\"docs_chunks\"]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Input Text:** A Markdown file titled \"Source: https://docs.godotengine.org/en/stable/about/docs_changelog.html\" containing a changelog of new documentation pages added to the Godot Engine documentation across various versions (3.0 to 4.6).\n   - **Task:** Classify the Markdown into zero or more target tables from the list: `[\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]`.\n   - **Output Format:** Exactly one JSON array. Valid values are the table names. Use `[]` if not useful. No markdown, no prose, no thinking text.\n   - **Rules:** Return only valid JSON. No markdown fences. No prose. No thinking text.\n\n2.  **Understand Target Tables:**\n   - `docs_chunks`: Typically refers to documentation content split into logical chunks/sections, often used for RAG or documentation indexing. This file is clearly a documentation changelog listing new pages, which fits well as documentation content.\n   - `api_mapping`: Maps API classes/methods to documentation or code. This file lists documentation page titles, not API mappings.\n   - `label_prototypes`: Defines labels or tags for classification. This file doesn't define labels.\n   - Conclusion: `docs_chunks` is the most appropriate classification.\n\n3.  **Evaluate Content against `docs_chunks`:**\n   - The content is a structured list of documentation pages added per version. It's pure documentation metadata/changelog. It fits the definition of documentation content that would be chunked or indexed.\n   - Therefore, it should be classified as `[\"docs_chunks\"]`.\n\n4.  **Format Output:**\n   - Must be exactly one JSON array.\n   - `[\"docs_chunks\"]`\n   - Check constraints: No markdown, no prose, no thinking text. Just the JSON.\n\n   Final check of the prompt: \"Return only valid JSON. No markdown. No prose. No thinking text. /no_think\"\n   Output: `[\"docs_chunks\"]`\n\n   All constraints met. Proceed. \n   Self-Correction/Refinement during thought: \n   Could it be `[]`? The prompt says \"Use [] only if the file is not useful documentation content.\" This is definitely useful documentation content (a changelog for docs). So `[\"docs_chunks\"]` is correct.\n   I will output exactly `[\"docs_chunks\"]`.✅\n   Proceed. \n   Output Generation. \n   `[\"docs_chunks\"]` (no backticks, no newlines if possible, but standard JSON is fine)\n   Wait, the prompt says \"No markdown.\" So I won't use backticks.\n   Final string: `[\"docs_chunks\"]`\n   Done. \n   Output matches requirement. \n   Proceeds. \n   [Output Generation] -> `[\"docs_chunks\"]`\n   *(Self-Correction/Verification during thought)*: \n   Let's double check the exact table names: `[\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]`.\n   The content is a changelog of documentation pages. It's clearly documentation. So `docs_chunks` is correct.\n   JSON array format: `[\"docs_chunks\"]`\n   All good. \n   Output matches. \n   Proceeds. \n   [Final Output Generation] -> `[\"docs_chunks\"]` (exactly)\n   *(Note: I will ensure no extra whitespace or newlines are added if possible, but standard JSON formatting is fine.)*\n   Ready. \n   Output: `[\"docs_chunks\"]`\n   *(Done.)*\n"
}

4. pages/aboutfaq32bebcf7.md

stage: classification
api_url: [redacted]
model: [redacted]
markdown_length: 26639
prompt_length: 27055
parsed_result: ['docs_chunks']
matched_tables: ['docs_chunks']
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 74
  },
  {
    "role": "user",
    "content_length": 27065
  }
]

Full Classification Prompt Sent To Qwen

Classify this Markdown into zero or more target tables.
Return exactly one JSON array. Valid values are:
["docs_chunks", "api_mapping", "label_prototypes"]

Rules:
- Use [] only if the file is not useful documentation content.
- Use one or more valid table names when conversion is needed.
- Do not include explanations, markdown fences, or any text outside JSON.

FILE: pages/about__faq__32bebcf7.md
FULL MARKDOWN:
# Source: https://docs.godotengine.org/en/stable/about/faq.html

Godot Engine 4.6 documentation in English
Frequently asked questions
Edit on GitHub
Learn how to contribute!
Frequently asked questions

What can I do with Godot? How much does it cost? What are the license terms?

Godot is
Free and open source Software
available under the
OSI-approved
MIT license. This means it is
free as in "free speech" as well as in "free beer."
In short:
You are free to download and use Godot for any purpose: personal, non-profit, commercial, or otherwise.
You are free to modify, distribute, redistribute, and remix Godot to your heart's content, for any reason,
both non-commercially and commercially.
All the contents of this accompanying documentation are published under the permissive Creative Commons
Attribution 3.0 (
CC BY 3.0
) license, with attribution
to "Juan Linietsky, Ariel Manzur and the Godot Engine community."
Logos and icons are generally under the same Creative Commons license. Note
that some third-party libraries included with Godot's source code may have
different licenses.
For full details, look at the
COPYRIGHT.txt
as well as the
LICENSE.txt
and
logo LICENSE.txt
files
in the Godot repository.
Also, see
the license page on the Godot website
.
Which platforms are supported by Godot?

For the editor:
Windows
macOS
Linux, *BSD
Android (experimental)
Web
(experimental)
For exporting your games:
Windows
macOS
Linux, *BSD
Android
iOS
Web
Both 32- and 64-bit binaries are supported where it makes sense, with 64
being the default. Official macOS builds support Apple Silicon natively as well as x86_64.
Some users also report building and using Godot successfully on ARM-based
systems with Linux, like the Raspberry Pi.
For information about console support, see the
Godot website
.
For more on this, see the sections on
exporting
and
compiling Godot yourself
.
Note
Godot 3 also had support for Universal Windows Platform (UWP). This platform
port was removed in Godot 4 due to lack of maintenance, and it being
deprecated by Microsoft. It is still available in the current stable release
of Godot 3 for interested users.
Which programming languages are supported in Godot?

The officially supported languages for Godot are GDScript, C#, and C++.
See the subcategories for each language in the
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.
While scripting languages tend to be less performant than lower-level languages in
the long run, for prototyping, developing Minimum Viable Products (MVPs), and
focusing on Time-To-Market (TTM), GDScript will provide a fast, friendly, and capable
way of developing your games.
Note that C# support is still relatively new, and as such, you may encounter
some issues along the way. C# support is also currently missing on the web
platform. Our friendly and hard-working development community is always
ready to tackle new problems as they arise, but since this is an open source
project, we recommend that you first do some due diligence yourself. Searching
through discussions on
open issues
is a great way to start your troubleshooting.
As for new languages, support is possible via third parties with GDExtensions. (See the question
about plugins below). Work is currently underway, for example, on unofficial bindings for Godot
to
Python
and
Nim
.
What is GDScript and why should I use it?

GDScript is Godot's integrated scripting language. It was built from the ground
up to maximize Godot's potential in the least amount of code, affording both novice
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 and a complete overview of the power GDScript offers
you, check out the
GDScript scripting guide
.
There are several reasons to use GDScript, but the most salient reason is the overall
reduction of complexity
.
The original intent of creating a tightly integrated, custom scripting language for
Godot was two-fold: first, it reduces the amount of time necessary to get up and running
with Godot, giving developers a rapid way of exposing themselves to the engine with a
focus on productivity; second, it reduces the overall burden of maintenance, attenuates
the dimensionality of issues, and allows the developers of the engine to focus on squashing
bugs and improving features related to the engine core, rather than spending a lot of time
trying to get a small set of incremental features working across a large set of languages.
Since Godot is an open source project, it was imperative from the start to prioritize a
more integrated and seamless experience over attracting additional users by supporting
more familiar programming languages, especially when supporting those more familiar
languages would result in a worse experience. We understand if you would rather use
another language in Godot (see the list of supported options above). That being said, if
you haven't given GDScript a try, try it for
three days
. Just like Godot,
once you see how powerful it is and how rapid your development becomes, we think GDScript
will grow on you.
More information about getting comfortable with GDScript or dynamically typed
languages can be found in the
GDScript: An introduction to dynamic languages
tutorial.
What were the motivations behind creating GDScript?

In the early days, the engine used the
Lua
scripting
language. Lua can be fast thanks to LuaJIT, but creating bindings to an object-oriented
system (by using fallbacks) was complex and slow and took an enormous
amount of code. After some experiments with
Python
,
that also proved difficult to embed.
The main reasons for creating a custom scripting language for Godot were:
Poor threading support in most script VMs, and Godot uses threads
(Lua, Python, Squirrel, JavaScript, ActionScript, etc.).
Poor class-extending support in most script VMs, and adapting to
the way Godot works is highly inefficient (Lua, Python, JavaScript).
Many existing languages have horrible interfaces for binding to C++, resulting in a
large amount of code, bugs, bottlenecks, and general inefficiency (Lua, Python,
Squirrel, JavaScript, etc.). We wanted to focus on a great engine, not a great number
of integrations.
No native vector types (Vector3, Transform3D, etc.), resulting in highly
reduced performance when using custom types (Lua, Python, Squirrel,
JavaScript, ActionScript, etc.).
Garbage collector results in stalls or unnecessarily large memory
usage (Lua, Python, JavaScript, ActionScript, etc.).
Difficulty integrating with the code editor for providing code
completion, live editing, etc. (all of them).
GDScript was designed to curtail the issues above, and more.
Which programming language is fastest?

In most games, the
scripting language
itself is not the cause of performance
problems. Instead, performance is slowed by inefficient algorithms (which are
slow in all languages), by GPU performance, or by the common C++ engine code
like physics or navigation. All languages supported by Godot are fast enough for
general-purpose scripting. You should choose a language based on other factors,
like ease-of-use, familiarity, platform support, or language features.
In general, the performance of C# and GDScript is within the same order of
magnitude, and C++ is faster than both.
Comparing GDScript performance to C# is tricky, since C# can be faster in some
specific cases. The C#
language
itself tends to be faster than GDScript, which
means that C# can be faster in situations with few calls to Godot engine code.
However, C# can be slower than GDScript when making many Godot API calls, due
to the cost of
marshalling
. C#'s performance can also be brought down by garbage
collection which occurs at random and unpredictable moments. This can result in
stuttering issues in complex projects, and is not exclusive to Godot.
C++, using
GDExtension
, will almost always be
faster than either C# or GDScript. However, C++ is less easy to use than C# or
GDScript, and is slower to develop with.
You can also use multiple languages within a single project, with
cross-language scripting
, or by using
GDExtension and scripting languages together. Be aware that doing so comes with
its own complications.
What 3D model formats does Godot support?

You can find detailed information on supported formats, how to export them from
your 3D modeling software, and how to import them for Godot in the
Importing 3D scenes
documentation.
Will [insert closed SDK such as FMOD, GameWorks, etc.] be supported in Godot?

The aim of Godot is to create a free and open source MIT-licensed engine that
is modular and extendable. There are no plans for the core engine development
community to support any third-party, closed-source/proprietary SDKs, as integrating
with these would go against Godot's ethos.
That said, because Godot is open source and modular, nothing prevents you or
anyone else interested in adding those libraries as a module and shipping your
game with them, as either open- or closed-source.
To see how support for your SDK of choice could still be provided, look at the
Plugins question below.
If you know of a third-party SDK that is not supported by Godot but that offers
free and open source integration, consider starting the integration work yourself.
Godot is not owned by one person; it belongs to the community, and it grows along
with ambitious community contributors like you.
How can I extend Godot?

For extending Godot, like creating Godot Editor plugins or adding support
for additional languages, take a look at
EditorPlugins
and tool scripts.
Also, see the official blog post on GDExtension, a way to develop native extensions for Godot:
Introducing GDNative's successor, GDExtension
You can also take a look at the GDScript implementation, the Godot modules,
as well as the
Jolt physics engine integration
for Godot. This would be a good starting point to see how another
third-party library integrates with Godot.
How do I install the Godot editor on my system (for desktop integration)?

Since you don't need to actually install Godot on your system to run it,
this means desktop integration is not performed automatically.
There are two ways to overcome this. You can install Godot from
Steam
(all platforms),
Scoop
(Windows),
Homebrew
(macOS)
or
Flathub
(Linux).
This will automatically perform the required steps for desktop integration.
Alternatively, you can manually perform the steps that an installer would do for you:
Windows

Move the Godot executable to a stable location (i.e. outside of your Downloads folder),
so you don't accidentally move it and break the shortcut in the future.
Right-click the Godot executable and choose
Create Shortcut
.
Move the created shortcut to
%APPDATA%\Microsoft\Windows\Start
Menu\Programs
.
This is the user-wide location for shortcuts that will appear in the Start menu.
You can also pin Godot in the task bar by right-clicking the executable and choosing
Pin to Task Bar
.
macOS

Drag the extracted Godot application to
/Applications/Godot.app
, then drag it
to the Dock if desired. Spotlight will be able to find Godot as long as it's in
/Applications
or
~/Applications
.
Linux

Move the Godot binary to a stable location (i.e. outside of your Downloads folder),
so you don't accidentally move it and break the shortcut in the future.
Rename and move the Godot binary to a location present in your
PATH
environment variable.
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
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=
line in the
.desktop
file linked below to contain the full
absolute
path
to the Godot binary.
Save
this .desktop file
to
$HOME/.local/share/applications/
. If you have administrator privileges,
you can also save the
.desktop
file to
/usr/local/share/applications
to make the shortcut available for all users.
Is the Godot editor a portable application?

In its default configuration, Godot is
semi-portable
. Its executable can run
from any location (including non-writable locations) and never requires
administrator privileges.
However, configuration files will be written to the user-wide configuration or
data directory. This is usually a good approach, but this means configuration files
will not carry across machines if you copy the folder containing the Godot executable.
See
File paths in Godot projects
for more information.
If
true
portable operation is desired (e.g. for use on a USB stick),
follow the steps in
Self-contained mode
.
Why does Godot aim to keep its core feature set small?

Godot intentionally does not include features that can be implemented by add-ons
unless they are used very often. One example of something not used often is
advanced artificial intelligence functionality.
There are several reasons for this:
Code maintenance and surface for bugs.
Every time we accept new code in
the Godot repository, existing contributors often take the responsibility of
maintaining it. Some contributors don't always stick around after getting
their code merged, which can make it difficult for us to maintain the code in
question. This can lead to poorly maintained features with bugs that are never
fixed. On top of that, the "API surface" that needs to be tested and checked
for regressions keeps increasing over time.
Ease of contribution.
By keeping the codebase small and tidy, it can remain
fast and easy to compile from source. This makes it easier for new
contributors to get started with Godot, without requiring them to purchase
high-end hardware.
Keeping the binary size small for the editor.
Not everyone has a fast Internet
connection. Ensuring that everyone can download the Godot editor, extract it
and run it in less than 5 minutes makes Godot more accessible to developers in
all countries.
Keeping the binary size small for export templates.
This directly impacts the
size of projects exported with Godot. On mobile and web platforms, keeping
file sizes low is important to ensure fast installation and loading on
underpowered devices. Again, there are many countries where high-speed
Internet is not readily available. To add to this, strict data usage caps are
often in effect in those countries.
For all the reasons above, we have to be selective of what we can accept as core
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
to optimize the distribution size of your project.)
How should assets be created to handle multiple resolutions and aspect ratios?

This question pops up often and it's probably thanks to the misunderstanding
created by Apple when they originally doubled the resolution of their devices.
It made people think that having the same assets in different resolutions was a
good idea, so many continued towards that path. That originally worked to a
point and only for Apple devices, but then several Android and Apple devices
with different resolutions and aspect ratios were created, with a very wide
range of sizes and DPIs.
The most common and proper way to achieve this is to, instead, use a single base
resolution for the game and only handle different screen aspect ratios. This is
mostly needed for 2D, as in 3D, it's just a matter of camera vertical or
horizontal FOV.
Choose a single base resolution for your game. Even if there are
devices that go up to 1440p and devices that go down to 400p, regular
hardware scaling in your device will take care of this at little or
no performance cost. The most common choices are either near 1080p
(1920x1080) or 720p (1280x720). Keep in mind the higher the
resolution, the larger your assets, the more memory they will take
and the longer the time it will take for loading.
Use the stretch options in Godot; canvas items stretching while keeping
aspect ratios works best. Check the
Multiple resolutions
tutorial
on how to achieve this.
Determine a minimum resolution and then decide if you want your game
to stretch vertically or horizontally for different aspect ratios, or
if there is one aspect ratio and you want black bars to appear
instead. This is also explained in
Multiple resolutions
.
For user interfaces, use the
anchoring
to determine where controls should stay and move. If UIs are more
complex, consider learning about Containers.
And that's it! Your game should work in multiple resolutions.
When is the next release of Godot out?

When it's ready! See
When is the next release out?
for more
information.
Which Godot version should I use for a new project?

We recommend using Godot 4.x for new projects, but depending on the feature set
you need, it may be better to use 3.x instead. See
Which version should I use for a new project?
for more information.
Should I upgrade my project to use new Godot versions?

Some new versions are safer to upgrade to than others. In general, whether you
should upgrade depends on your project's circumstances. See
Should I upgrade my project to use new engine versions?
for more information.
Should I use the Forward+, Mobile, or Compatibility renderer?

You can find a detailed comparison of the renderers in
Overview of renderers
.
I would like to contribute! How can I get started?

Awesome! As an open source project, Godot thrives off of the innovation and
the ambition of developers like you.
The best way to start contributing to Godot is by using it and reporting
any
issues
that you might experience.
A good bug report with clear reproduction steps helps your fellow contributors
fix bugs quickly and efficiently. You can also report issues you find in the
online documentation
.
If you feel ready to submit your first PR, pick any issue that resonates with you from
one of the links above and try your hand at fixing it. You will need to learn how to
compile the engine from sources, or how to build the documentation. You also need to
get familiar with Git, a version control system that Godot developers use.
We explain how to work with the engine source, how to edit the documentation, and
what other ways to contribute are there in our
documentation for contributors
.
I have a great idea for Godot. How can I share it?

We are always looking for suggestions about how to improve the engine. User feedback
is the main driving force behind our decision-making process, and limitations that
you might face while working on your project are a great data point for us when considering
engine enhancements.
If you experience a usability problem or are missing a feature in the current version of
Godot, start by discussing it with our
community
.
There may be other, perhaps better, ways to achieve the desired result that community members
could suggest. And you can learn if other users experience the same issue, and figure out
a good solution together.
If you come up with a well-defined idea for the engine, feel free to open a
proposal issue
.
Try to be specific and concrete while describing your problem and your proposed
solution — only actionable proposals can be considered. It is not required, but
if you want to implement it yourself, that's always appreciated!
If you only have a general idea without specific details, you can open a
proposal discussion
.
These can be anything you want, and allow for a free-form discussion in search of
a solution. Once you find one, a proposal issue can be opened.
Please, read the
readme
document before creating a proposal to learn more about the process.
Is it possible to use Godot to create non-game applications?

Yes! Godot features an extensive built-in UI system, and its small distribution
size can make it a suitable alternative to frameworks like Electron or Qt.
See
Creating applications
for more information.
Is it possible to use Godot as a library?

If you are looking to make a game with Godot, keep in mind Godot is designed
to be used with its editor. We recommend you give it a try, as it
will most likely save you time in the long term.
For more specialized applications, it can make sense to look into using
Godot as a library. Since Godot 4.6, there is
experimental
support
for using Godot as a static or shared library in the form of LibGodot.
This is currently supported on Windows, macOS, and Linux. Support for
Android and iOS is planned for a future release.
You can find sample applications that use Godot as a library in the
migeran/libgodot_project GitHub repository
.
What user interface toolkit does Godot use?

Godot does not use a standard
GUI
toolkit
like GTK, Qt or wxWidgets. Instead, Godot uses its own user interface toolkit,
which is always rendered using hardware acceleration. There is no built-in software
fallback, although external solutions that emulate graphics APIs on the CPU can be used.
This toolkit is exposed in the form of Control nodes, which are used to render
the editor (which is written in C++). These Control nodes can also be used in projects
from any scripting language supported by Godot.
This custom toolkit makes it possible to benefit from hardware acceleration and
have a consistent appearance across all platforms. On top of that, it doesn't
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 be
embedded into other applications
(experimental). However, the preferred way to use it is to
use Godot to create non-game applications with the editor
.
Why does Godot use the SCons build system?

Godot uses the
SCons
build system. There are no
plans to switch to a different build system in the near future. There are many
reasons why we have chosen SCons over other alternatives. For example:
Godot can be compiled for a dozen different platforms: all PC
platforms, all mobile platforms, many consoles, and WebAssembly.
Developers often need to compile for several of the platforms
at
the same time
, or even different targets of the same platform. They
can't afford reconfiguring and rebuilding the project each time.
SCons can do this with no sweat, without breaking the builds.
SCons will
never
break a build no matter how many changes,
configurations, additions, removals etc.
Godot's build process is not simple. Several files are generated by
code (binders), others are parsed (shaders), and others need to offer
customization (
modules
). This requires
complex logic which is easier to write in an actual programming language (like Python)
rather than using a mostly macro-based language only meant for building.
Godot's build process makes heavy use of cross-compiling tools. Each
platform has a specific detection process, and all these must be
handled as specific cases with special code written for each.
Please try to keep an open mind and get at least a little familiar with SCons if
you are planning to build Godot yourself.
Why does Godot not use STL (Standard Template Library)?

Like many other libraries (Qt as an example), Godot does not make use of STL
(with a few exceptions such as threading primitives). We believe STL is a great
general-purpose library, but we had special requirements for Godot.
STL templates create very large symbols, which results in huge debug binaries. We use few
templates with very short names instead.
Most of our containers cater to special needs, like Vector, which uses copy on write and we
use to pass data around, or the RID system, which requires O(1) access time for performance.
Likewise, our hash map implementations are designed to integrate seamlessly with internal
engine types.
Our containers have memory tracking built-in, which helps better track memory usage.
For large arrays, we use pooled memory, which can be mapped to either a preallocated buffer
or virtual memory.
We use our custom String type, as the one provided by STL is too basic and lacks proper
internationalization support.
Check out
Godot's container types
for alternatives.
Why does Godot not use exceptions?

We believe games should not crash, no matter what. If an unexpected
situation happens, Godot will print an error (which can be traced even to
script), but then it will try to recover as gracefully as possible and keep
going.
Additionally, exceptions significantly increase the binary size for the
executable and result in increased compile times.
Does Godot use an ECS (Entity Component System)?

Godot does
not
use an ECS and relies on inheritance instead. While there
is no universally better approach, we found that using an inheritance-based approach
resulted in better usability while still being fast enough for most use cases.
That said, nothing prevents you from making use of composition in your project
by creating child Nodes with individual scripts. These nodes can then be added and
removed at runtime to dynamically add and remove behaviors.
More information about Godot's design choices can be found in
this article
.
Why does Godot not force users to implement DOD (Data-Oriented Design)?

While Godot internally attempts to use cache coherency as much as possible,
we believe users don't need to be forced to use DOD practices.
DOD is mostly a cache coherency optimization that can only provide
significant performance improvements when dealing with dozens of
thousands of objects which are processed every frame with little
modification. That is, if you are moving a few hundred sprites or enemies
per frame, DOD won't result in a meaningful improvement in performance. In
such a case, you should consider a different approach to optimization.
The vast majority of games do not need this and Godot provides handy helpers
to do the job for most cases when you do.
If a game needs to process such a large amount of objects, our recommendation
is to use C++ and GDExtensions for performance-heavy tasks and GDScript (or C#)
for the rest of the game.
How can I support Godot development or contribute?

See
How to contribute
.
Who is working on Godot? How can I contact you?

See the corresponding page on the
Godot website
.

Classification Response Finish Reason

stop

Classification Response Content

["docs_chunks"]

Classification Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Input Text:** A Markdown file containing an FAQ for Godot Engine 4.6.
   - **Task:** Classify the Markdown into zero or more target tables from a predefined list: `["docs_chunks", "api_mapping", "label_prototypes"]`.
   - **Output Format:** Exactly one JSON array. No markdown, no prose, no thinking text.
   - **Rules:** Use `[]` if not useful documentation content. Use one or more valid table names if conversion is needed.

2.  **Evaluate Content against Target Tables:**
   - `docs_chunks`: This typically refers to documentation content split into logical chunks for retrieval, indexing, or LLM processing. The input is a standard FAQ page from official documentation (`docs.godotengine.org`). It contains questions and answers, licensing info, platform support, language support, etc. This is clearly useful documentation content.
   - `api_mapping`: This usually refers to mappings between API names, functions, classes, or parameters. The FAQ mentions some APIs/classes (GDScript, C#, C++, GDExtension, Control nodes, Vector, RID, etc.), but it's not primarily an API reference or mapping table.
   - `label_prototypes`: This usually refers to datasets for classification, tagging, or labeling tasks (e.g., question-answer pairs with labels, or prototype labels for ML). The FAQ has a Q&A structure, but it's standard documentation, not explicitly a labeled dataset.

   Given the options, `docs_chunks` is the most appropriate. The content is clearly documentation that would be chunked for a documentation search system or RAG pipeline.

3.  **Determine Output:**
   - The content is useful documentation.
   - It fits `docs_chunks`.
   - Output should be `["docs_chunks"]`.

4.  **Format Output:**
   - JSON array only.
   - `["docs_chunks"]`

   Check constraints: "Return only valid JSON. No markdown. No prose. No thinking text."
   Matches perfectly.

   Final decision: `["docs_chunks"]`✅
   Proceed. 
   Self-Correction/Refinement during thought: 
   Could it be `["docs_chunks", "label_prototypes"]`? The prompt says "zero or more target tables". Usually, FAQ pages are just `docs_chunks`. I'll stick with `["docs_chunks"]`. It's the safest and most accurate.
   Output matches requirement.✅
   Generate. 
   `[ "docs_chunks" ]` (without spaces if preferred, but standard JSON is fine)
   I will output exactly `["docs_chunks"]`. 
   All constraints met.✅
   Proceeds. 
   Output Generation. 
   `["docs_chunks"]`
   *(Self-Correction/Verification during generation prep)*: 
   The prompt says "Classify this Markdown into zero or more target tables." The table names are just strings. I will output `["docs_chunks"]`.
   Ready. 
   Output matches.✅
   [Done] 
   `["docs_chunks"]`

Raw Classification Response

{
  "finish_reason": "stop",
  "content": "[\"docs_chunks\"]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Input Text:** A Markdown file containing an FAQ for Godot Engine 4.6.\n   - **Task:** Classify the Markdown into zero or more target tables from a predefined list: `[\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]`.\n   - **Output Format:** Exactly one JSON array. No markdown, no prose, no thinking text.\n   - **Rules:** Use `[]` if not useful documentation content. Use one or more valid table names if conversion is needed.\n\n2.  **Evaluate Content against Target Tables:**\n   - `docs_chunks`: This typically refers to documentation content split into logical chunks for retrieval, indexing, or LLM processing. The input is a standard FAQ page from official documentation (`docs.godotengine.org`). It contains questions and answers, licensing info, platform support, language support, etc. This is clearly useful documentation content.\n   - `api_mapping`: This usually refers to mappings between API names, functions, classes, or parameters. The FAQ mentions some APIs/classes (GDScript, C#, C++, GDExtension, Control nodes, Vector, RID, etc.), but it's not primarily an API reference or mapping table.\n   - `label_prototypes`: This usually refers to datasets for classification, tagging, or labeling tasks (e.g., question-answer pairs with labels, or prototype labels for ML). The FAQ has a Q&A structure, but it's standard documentation, not explicitly a labeled dataset.\n\n   Given the options, `docs_chunks` is the most appropriate. The content is clearly documentation that would be chunked for a documentation search system or RAG pipeline.\n\n3.  **Determine Output:**\n   - The content is useful documentation.\n   - It fits `docs_chunks`.\n   - Output should be `[\"docs_chunks\"]`.\n\n4.  **Format Output:**\n   - JSON array only.\n   - `[\"docs_chunks\"]`\n\n   Check constraints: \"Return only valid JSON. No markdown. No prose. No thinking text.\"\n   Matches perfectly.\n\n   Final decision: `[\"docs_chunks\"]`✅\n   Proceed. \n   Self-Correction/Refinement during thought: \n   Could it be `[\"docs_chunks\", \"label_prototypes\"]`? The prompt says \"zero or more target tables\". Usually, FAQ pages are just `docs_chunks`. I'll stick with `[\"docs_chunks\"]`. It's the safest and most accurate.\n   Output matches requirement.✅\n   Generate. \n   `[ \"docs_chunks\" ]` (without spaces if preferred, but standard JSON is fine)\n   I will output exactly `[\"docs_chunks\"]`. \n   All constraints met.✅\n   Proceeds. \n   Output Generation. \n   `[\"docs_chunks\"]`\n   *(Self-Correction/Verification during generation prep)*: \n   The prompt says \"Classify this Markdown into zero or more target tables.\" The table names are just strings. I will output `[\"docs_chunks\"]`.\n   Ready. \n   Output matches.✅\n   [Done] \n   `[\"docs_chunks\"]`\n"
}

5. pages/aboutintroduction344b3840.md

stage: classification
api_url: [redacted]
model: [redacted]
markdown_length: 4294
prompt_length: 4719
parsed_result: ['docs_chunks']
matched_tables: ['docs_chunks']
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 74
  },
  {
    "role": "user",
    "content_length": 4729
  }
]

Full Classification Prompt Sent To Qwen

Classify this Markdown into zero or more target tables.
Return exactly one JSON array. Valid values are:
["docs_chunks", "api_mapping", "label_prototypes"]

Rules:
- Use [] only if the file is not useful documentation content.
- Use one or more valid table names when conversion is needed.
- Do not include explanations, markdown fences, or any text outside JSON.

FILE: pages/about__introduction__344b3840.md
FULL MARKDOWN:
# Source: https://docs.godotengine.org/en/stable/about/introduction.html

Godot Engine 4.6 documentation in English
Introduction
Edit on GitHub
Learn how to contribute!
Introduction

GDScript
C#
func
_ready
():
print
(
"Hello world!"
)
Copy to clipboard
public
override
void
_Ready
()
{
GD
.
Print
(
"Hello world!"
);
}
Copy to clipboard
Welcome to the official documentation of
Godot Engine
, the free and open source
community-driven 2D and 3D game engine! Behind this mouthful, you will find a
powerful yet user-friendly tool that you can use to develop any kind of game,
for any platform and with no usage restriction whatsoever.
This page gives a broad overview of the engine and of this documentation,
so that you know where to start if you are a beginner or
where to look if you need information on a specific feature.
Before you start

The
Tutorials and resources
page lists
video tutorials contributed by the community. If you prefer video to text,
consider checking them out. Otherwise,
Getting Started
is a great starting point.
In case you have trouble with one of the tutorials or your project,
you can find help on the various
Community channels
,
especially the Godot
Discord
community and
Forum
.
About Godot Engine

A game engine is a complex tool and difficult to present in a few words.
Here's a quick synopsis, which you are free to reuse
if you need a quick write-up about Godot Engine:
Godot Engine is a feature-packed, cross-platform game engine to create 2D
and 3D games from a unified interface. It provides a comprehensive set of
common tools, so that users can focus on making games without having to
reinvent the wheel. Games can be exported with one click to a number of
platforms, including the major desktop platforms (Linux, macOS, Windows),
mobile platforms (Android, iOS), as well as Web-based platforms and consoles.
Godot is completely free and open source under the
permissive MIT
license
. No strings attached, no royalties,
nothing. Users' games are theirs, down to the last line of engine code.
Godot's development is fully independent and community-driven, empowering
users to help shape their engine to match their expectations.
It is supported by the
Godot Foundation
not-for-profit.
Organization of the documentation

This documentation is organized into several sections:
About
contains this introduction as well as
information about the engine, its history, its licensing, authors, etc. It
also contains the
Frequently asked questions
.
Getting Started
contains all necessary information on using the engine to
make games. It starts with the
Introduction
section which
should be the entry point for all new users.
This is the best place to start
if you're new!
The
Manual
can be read or referenced as needed,
in any order. It contains feature-specific tutorials and documentation.
Engine details
contains sections intended for advanced users and contributors,
with information on compiling the engine, working on the editor,
or developing C++ modules.
Community
is dedicated to the life of Godot's community and contains a list of
recommended third-party tutorials and materials outside of this documentation.
It also provides details on the Asset Library. It also used to list Godot
communities, which are now listed on the
Godot website
.
Finally, the
Class reference
documents the full Godot API,
also available directly within the engine's script editor.
You can find information on all classes, functions, signals and so on here.
In addition to this documentation, you may also want to take a look at the
various
Godot demo projects
.
About this documentation

Members of the Godot Engine community continuously write, correct, edit, and
improve this documentation. We are always looking for more help. You can also
contribute by opening Github issues or translating the documentation into your language.
If you are interested in helping, see
How to contribute
and
Writing documentation
,
or get in touch with the
Documentation team
on
Godot Contributors Chat
.
All documentation content is licensed under the permissive Creative Commons Attribution 3.0
(
CC BY 3.0
) license,
with attribution to "
Juan Linietsky, Ariel Manzur, and the Godot Engine community
"
unless otherwise noted.
Have fun reading and making games with Godot Engine!

Classification Response Finish Reason

stop

Classification Response Content

["docs_chunks"]

Classification Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Input Text:** A Markdown file from Godot Engine documentation (`pages/about__introduction__344b3840.md`).
   - **Content:** Introduction to Godot Engine, code snippets (GDScript/C#), overview of the engine, documentation organization, licensing, community info.
   - **Task:** Classify into zero or more target tables: `["docs_chunks", "api_mapping", "label_prototypes"]`.
   - **Output Format:** Exactly one JSON array. Valid values are the table names. No markdown, no prose, no thinking text.
   - **Rules:** Use `[]` if not useful documentation content. Use one or more valid table names when conversion is needed.

2.  **Evaluate Content against Target Tables:**
   - `docs_chunks`: This table typically stores chunks of documentation content (articles, guides, reference pages). The input is clearly a documentation page ("Introduction" from Godot docs). It contains headings, paragraphs, code blocks, and links. Highly suitable for `docs_chunks`.
   - `api_mapping`: This table typically maps API classes/methods to documentation or defines API structures. The input mentions "Class reference" and shows a `_Ready` function snippet, but it's primarily an introductory overview page, not a detailed API mapping or reference table. It could potentially be included if it maps to API docs, but `docs_chunks` is the primary fit. I'll stick with `docs_chunks` as the main classification. Sometimes introductory pages are just `docs_chunks`.
   - `label_prototypes`: This table typically stores UI/UX labels, button texts, or prototype definitions. Not present here.

   Conclusion: The content is standard documentation. It fits `docs_chunks`.

3.  **Format Output:**
   - Must be exactly one JSON array.
   - Valid values: `["docs_chunks"]`
   - No markdown fences, no extra text.

   Check rules: "Return only valid JSON. No markdown. No prose. No thinking text."
   Output: `["docs_chunks"]`

   Double-check: Is there any reason to include `api_mapping`? The snippet shows `_Ready` but it's just a code comparison block in an intro page. Not a mapping. `docs_chunks` is sufficient.
   The prompt says "Classify this Markdown into zero or more target tables."
   I will output `["docs_chunks"]`.

   All constraints met. Proceed. 
   Output matches exactly.✅
   Note: I'll make sure there's no markdown formatting like ```json ... ``` around it. Just the raw JSON string.
   `["docs_chunks"]` is correct. 
   Ready. 
   Output Generation. 
   `[ "docs_chunks" ]` (or without spaces, doesn't matter, but standard JSON is fine)
   I will output `["docs_chunks"]`. 
   Self-Correction/Verification during thought: 
   Could it be `[]`? No, it's clearly useful documentation content.
   Could it be `["docs_chunks", "api_mapping"]`? The intro page mentions the Class Reference, but doesn't map APIs itself. `docs_chunks` is the standard classification for this type of page.
   I'll stick with `["docs_chunks"]`.
   Output matches requirement.✅
   Proceeds. 
   `[ "docs_chunks" ]` -> `["docs_chunks"]` (compact)
   Done. 
   Output Generation. 
   `["docs_chunks"]`
   *(Self-Correction/Refinement during thought)*: Wait, the prompt says "Return exactly one JSON array. Valid values are: ["docs_chunks", "api_mapping", "label_prototypes"]". It implies the array should contain the table names. So `["docs_chunks"]` is correct.
   All good. 
   Output matches. 
   `[ "docs_chunks" ]` -> `["docs_chunks"]`
   Proceeds. 
   [Output Generation] -> `["docs_chunks"]`
   *(Final Check)*: The prompt says "Return only valid JSON. No markdown. No prose. No thinking text."
   I will output exactly `["docs_chunks"]`.
   Done. 
   [Output] `["docs_chunks"]`
   *(Note: I'll make sure there are no newlines or spaces that could break strict JSON parsing, though standard JSON allows whitespace.)*
   `["docs_chunks"]` is perfect. 
   Proceeds. 
   [Output Generation] -> `["docs_chunks"]`

Raw Classification Response

{
  "finish_reason": "stop",
  "content": "[\"docs_chunks\"]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Input Text:** A Markdown file from Godot Engine documentation (`pages/about__introduction__344b3840.md`).\n   - **Content:** Introduction to Godot Engine, code snippets (GDScript/C#), overview of the engine, documentation organization, licensing, community info.\n   - **Task:** Classify into zero or more target tables: `[\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]`.\n   - **Output Format:** Exactly one JSON array. Valid values are the table names. No markdown, no prose, no thinking text.\n   - **Rules:** Use `[]` if not useful documentation content. Use one or more valid table names when conversion is needed.\n\n2.  **Evaluate Content against Target Tables:**\n   - `docs_chunks`: This table typically stores chunks of documentation content (articles, guides, reference pages). The input is clearly a documentation page (\"Introduction\" from Godot docs). It contains headings, paragraphs, code blocks, and links. Highly suitable for `docs_chunks`.\n   - `api_mapping`: This table typically maps API classes/methods to documentation or defines API structures. The input mentions \"Class reference\" and shows a `_Ready` function snippet, but it's primarily an introductory overview page, not a detailed API mapping or reference table. It could potentially be included if it maps to API docs, but `docs_chunks` is the primary fit. I'll stick with `docs_chunks` as the main classification. Sometimes introductory pages are just `docs_chunks`.\n   - `label_prototypes`: This table typically stores UI/UX labels, button texts, or prototype definitions. Not present here.\n\n   Conclusion: The content is standard documentation. It fits `docs_chunks`.\n\n3.  **Format Output:**\n   - Must be exactly one JSON array.\n   - Valid values: `[\"docs_chunks\"]`\n   - No markdown fences, no extra text.\n\n   Check rules: \"Return only valid JSON. No markdown. No prose. No thinking text.\"\n   Output: `[\"docs_chunks\"]`\n\n   Double-check: Is there any reason to include `api_mapping`? The snippet shows `_Ready` but it's just a code comparison block in an intro page. Not a mapping. `docs_chunks` is sufficient.\n   The prompt says \"Classify this Markdown into zero or more target tables.\"\n   I will output `[\"docs_chunks\"]`.\n\n   All constraints met. Proceed. \n   Output matches exactly.✅\n   Note: I'll make sure there's no markdown formatting like ```json ... ``` around it. Just the raw JSON string.\n   `[\"docs_chunks\"]` is correct. \n   Ready. \n   Output Generation. \n   `[ \"docs_chunks\" ]` (or without spaces, doesn't matter, but standard JSON is fine)\n   I will output `[\"docs_chunks\"]`. \n   Self-Correction/Verification during thought: \n   Could it be `[]`? No, it's clearly useful documentation content.\n   Could it be `[\"docs_chunks\", \"api_mapping\"]`? The intro page mentions the Class Reference, but doesn't map APIs itself. `docs_chunks` is the standard classification for this type of page.\n   I'll stick with `[\"docs_chunks\"]`.\n   Output matches requirement.✅\n   Proceeds. \n   `[ \"docs_chunks\" ]` -> `[\"docs_chunks\"]` (compact)\n   Done. \n   Output Generation. \n   `[\"docs_chunks\"]`\n   *(Self-Correction/Refinement during thought)*: Wait, the prompt says \"Return exactly one JSON array. Valid values are: [\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]\". It implies the array should contain the table names. So `[\"docs_chunks\"]` is correct.\n   All good. \n   Output matches. \n   `[ \"docs_chunks\" ]` -> `[\"docs_chunks\"]`\n   Proceeds. \n   [Output Generation] -> `[\"docs_chunks\"]`\n   *(Final Check)*: The prompt says \"Return only valid JSON. No markdown. No prose. No thinking text.\"\n   I will output exactly `[\"docs_chunks\"]`.\n   Done. \n   [Output] `[\"docs_chunks\"]`\n   *(Note: I'll make sure there are no newlines or spaces that could break strict JSON parsing, though standard JSON allows whitespace.)*\n   `[\"docs_chunks\"]` is perfect. \n   Proceeds. \n   [Output Generation] -> `[\"docs_chunks\"]`\n"
}

6. pages/about__list_of_features__273abdc4.md

stage: classification
api_url: [redacted]
model: [redacted]
markdown_length: 29009
prompt_length: 29438
parsed_result: ['docs_chunks']
matched_tables: ['docs_chunks']
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 74
  },
  {
    "role": "user",
    "content_length": 29448
  }
]

Full Classification Prompt Sent To Qwen

Classify this Markdown into zero or more target tables.
Return exactly one JSON array. Valid values are:
["docs_chunks", "api_mapping", "label_prototypes"]

Rules:
- Use [] only if the file is not useful documentation content.
- Use one or more valid table names when conversion is needed.
- Do not include explanations, markdown fences, or any text outside JSON.

FILE: pages/about__list_of_features__273abdc4.md
FULL MARKDOWN:
# Source: https://docs.godotengine.org/en/stable/about/list_of_features.html

Godot Engine 4.6 documentation in English
List of features
Edit on GitHub
Learn how to contribute!
List of features

This page aims to list
all
features currently supported by Godot.
Note
This page lists features supported by the current stable version of
Godot. Some of these features are not available in the
3.x release series
.
Platforms

See also
See
System requirements
for hardware and software version requirements.
Note
For information about console support, see the
Godot website
.
Can run both the editor and exported projects:
Windows (x86 and ARM, 64-bit and 32-bit).
macOS (x86 and ARM, 64-bit only).
Linux (x86 and ARM, 64-bit and 32-bit).
Binaries are statically linked and can run on any distribution if compiled
on an old enough base distribution.
Official binaries are compiled using the
Godot Engine buildroot
,
allowing for binaries that work across common Linux distributions.
Android (editor support is experimental).
Web browsers
. Experimental in 4.0,
using Godot 3.x is recommended instead when targeting HTML5.
Note
Linux supports rv64 (RISC-V), ppc64 & ppc32 (PowerPC), and loongarch64. However
you must compile the editor for that platform (as well as export templates)
yourself, no official downloads are currently provided. RISC-V compiling
instructions can be found on the
Compiling for Linux, *BSD
page.
Runs exported projects:
iOS.
Godot aims to be as platform-independent as possible and can be
ported to new platforms
with relative ease.
Note
Projects written in C# using Godot 4 currently cannot be exported to the
web platform. To use C# on that platform, consider Godot 3 instead.
Android and iOS platform support is available as of Godot 4.2, but is
experimental and
some limitations apply
.
Editor

Features:
Scene tree editor.
Built-in script editor.
Support for
external script editors
such as
Visual Studio Code or Vim.
GDScript
debugger
.
Support for debugging in threads is available since 4.2.
Visual profiler with CPU and GPU time indications for each step of the
rendering pipeline.
Performance monitoring tools, including
custom performance monitors
.
Live script reloading.
Live scene editing.
Changes will reflect in the editor and will be kept after closing the running project.
Remote inspector.
Changes won't reflect in the editor and won't be kept after closing the running project.
Live camera replication.
Move the in-editor camera and see the result in the running project.
Built-in offline class reference documentation.
Use the editor in dozens of languages contributed by the community.
Plugins:
Editor plugins can be downloaded from the
asset library
to extend editor functionality.
Create your own plugins
using GDScript to add new
features or speed up your workflow.
Download projects from the asset library
in the Project Manager and import them directly.
Rendering

Godot 4 includes three renderers:
Forward+
. The most advanced renderer, suited for desktop platforms only.
Used by default on desktop platforms. This renderer uses
Vulkan
,
Direct3D 12
,
or
Metal
as the rendering driver, and it uses the
RenderingDevice
backend.
Mobile
. Fewer features, but renders simple scenes faster. Suited for mobile
and desktop platforms. Used by default on mobile platforms. This renderer uses
Vulkan
,
Direct3D 12
, or
Metal
as the rendering driver, and it uses
the
RenderingDevice
backend.
Compatibility
, sometimes called
GL Compatibility
. The least advanced
renderer, suited for low-end desktop and mobile platforms. Used by default on
the web platform. This renderer uses
OpenGL
as the rendering driver.
See
Overview of renderers
for a detailed comparison of the rendering methods.
2D graphics

Sprite, polygon and line rendering.
High-level tools to draw lines and polygons such as
Polygon2D
and
Line2D
, with support for texturing.
AnimatedSprite2D as a helper for creating animated sprites.
Parallax layers.
Pseudo-3D support including preview in the editor.
2D lighting
with normal maps and specular maps.
Point (omni/spot) and directional 2D lights.
Hard or soft shadows (adjustable on a per-light basis).
Custom shaders can access a real-time
SDF
representation of the 2D scene based on
LightOccluder2D
nodes,
which can be used for improved 2D lighting effects including 2D global illumination.
Font rendering
using bitmaps, rasterization using FreeType
or multi-channel signed distance fields (MSDF).
Bitmap fonts can be exported using tools like BMFont, or imported from images
(for fixed-width fonts only).
Dynamic fonts support monochrome fonts as well as colored fonts (e.g. for emoji).
Supported formats are TTF, OTF, WOFF1 and WOFF2.
Dynamic fonts support optional font outlines with adjustable width and color.
Dynamic fonts support variable fonts and OpenType features including ligatures.
Dynamic fonts support simulated bold and italic when the font file lacks
those styles.
Dynamic fonts support oversampling to keep fonts sharp at higher resolutions.
Dynamic fonts support subpixel positioning to make fonts crisper at low sizes.
Dynamic fonts support LCD subpixel optimizations to make fonts even crisper at low sizes.
Signed distance field fonts can be scaled at any resolution without
requiring re-rasterization. Multi-channel usage makes SDF fonts scale down
to lower sizes better compared to monochrome SDF fonts.
GPU-based
particles
with support for
custom particle shaders
.
CPU-based particles.
Optional
2D HDR rendering
for better glow capabilities.
2D tools

TileMaps
for 2D tile-based level design.
2D camera with built-in smoothing and drag margins.
Path2D node to represent a path in 2D space.
Can be drawn in the editor or generated procedurally.
PathFollow2D node to make nodes follow a Path2D.
2D geometry helper class
.
2D physics

Physics bodies:
Static bodies.
Animatable bodies (for objects moving only by script or animation, such as doors and platforms).
Rigid bodies.
Character bodies.
Joints.
Areas to detect bodies entering or leaving it.
Collision detection:
Built-in shapes: line, box, circle, capsule, world boundary (infinite plane).
Collision polygons (can be drawn manually or generated from a sprite in the editor).
3D graphics

HDR rendering with sRGB.
Perspective, orthographic and frustum-offset cameras.
When using the Forward+ renderer, a depth prepass is used to improve
performance in complex scenes by reducing the cost of overdraw.
Variable rate shading
on supported GPUs in Forward+ and Mobile.
Physically-based rendering (built-in material features):
Follows the Disney PBR model.
Supports Burley, Lambert, Lambert Wrap (half-Lambert) and Toon diffuse shading modes.
Supports Schlick-GGX, Toon and Disabled specular shading modes.
Uses a roughness-metallic workflow with support for ORM textures.
Uses horizon specular occlusion (Filament model) to improve material appearance.
Normal mapping.
Parallax/relief mapping with automatic level of detail based on distance.
Detail mapping for the albedo and normal maps.
Sub-surface scattering and transmittance.
Screen-space refraction with support for material roughness (resulting in blurry refraction).
Proximity fade (soft particles) and distance fade.
Distance fade can use alpha blending or dithering to avoid going through
the transparent pipeline.
Dithering can be determined on a per-pixel or per-object basis.
Real-time lighting:
Directional lights (sun/moon). Up to 4 per scene.
Omnidirectional lights.
Spot lights with adjustable cone angle and attenuation.
Specular, indirect light, and volumetric fog energy can be adjusted on a per-light basis.
Adjustable light "size" for fake area lights (will also make shadows blurrier).
Optional distance fade system to fade distant lights and their shadows, improving performance.
When using the Forward+ renderer (default on desktop), lights are
rendered with clustered forward optimizations to decrease their individual cost.
Clustered rendering also lifts any limits on the number of lights that can be used on a mesh.
When using the Mobile renderer, up to 8 omni lights and 8 spot lights can
be displayed per mesh resource. Baked lighting can be used to overcome this limit
if needed.
Shadow mapping:
DirectionalLight:
Orthogonal (fastest), PSSM 2-split and 4-split.
Supports blending between splits.
OmniLight:
Dual paraboloid (fast) or cubemap (slower but more accurate).
Supports colored projector textures in the form of panoramas.
SpotLight:
Single texture. Supports colored projector textures.
Shadow normal offset bias and shadow pancaking to decrease the amount of
visible shadow acne and peter-panning.
PCSS
-like shadow blur based on the
light size and distance from the surface the shadow is cast on.
Adjustable shadow blur on a per-light basis.
Global illumination with indirect lighting:
Baked lightmaps
(fast, but can't be updated at runtime).
Supports baking indirect light only or baking both direct and indirect lighting.
The bake mode can be adjusted on a per-light basis to allow for hybrid light
baking setups.
Supports lighting dynamic objects using automatic and manually placed probes.
Optionally supports directional lighting and rough reflections based on spherical
harmonics.
Lightmaps are baked on the GPU using compute shaders (much faster compared
to CPU lightmapping). Baking can only be performed from the editor,
not in exported projects.
Supports GPU-based
denoising
with JNLM, or CPU/GPU-based denoising with OIDN.
Voxel-based GI probes
. Supports
dynamic lights
and
dynamic occluders, while also supporting reflections.
Requires a fast baking step which can be performed in the editor or at
runtime (including from an exported project).
Signed-distance field GI
designed for large open worlds.
Supports dynamic lights, but not dynamic occluders. Supports reflections.
No baking required.
Screen-space indirect lighting (SSIL)
at half or full resolution. Fully real-time and supports any kind of emissive
light source (including decals).
VoxelGI and SDFGI use a deferred pass to allow for rendering GI at half
resolution to improve performance (while still having functional MSAA support).
Reflections:
Voxel-based reflections (when using GI probes) and SDF-based reflections
(when using signed distance field GI). Voxel-based reflections are visible
on transparent surfaces, while rough SDF-based reflections are visible
on transparent surfaces.
Fast baked reflections or slow real-time reflections using ReflectionProbe.
Parallax box correction can optionally be enabled.
Screen-space reflections with support for material roughness.
Reflection techniques can be mixed together for greater accuracy or scalability.
When using the Forward+ renderer (default on desktop), reflection probes are
rendered with clustered forward optimizations to decrease their individual cost.
Clustered rendering also lifts any limits on the number of reflection probes that can be used on a mesh.
When using the Mobile renderer, up to 8 reflection probes can be displayed per mesh
resource. When using the Compatibility renderer, up to 2 reflection probes can
be displayed per mesh resource.
Decals:
Supports albedo
, emissive,
ORM
,
and normal mapping.
Texture channels are smoothly overlaid on top of the underlying material,
with support for normal/ORM-only decals.
Support for normal fade to fade the decal depending on its incidence angle.
Does not rely on runtime mesh generation. This means decals can be used on
complex skinned meshes with no performance penalty, even if the decal moves every frame.
Support for nearest, bilinear, trilinear or anisotropic texture filtering (configured globally).
Optional distance fade system to fade distant decals, improving performance.
When using the Forward+ renderer (default on desktop), decals are
rendered with clustered forward optimizations to decrease their individual cost.
Clustered rendering also lifts any limits on the number of decals that can be used on a mesh.
When using the Mobile renderer, up to 8 decals can be displayed per mesh
resource.
Sky:
Panorama sky (using an HDRI).
Procedural sky and Physically-based sky that respond to the DirectionalLights in the scene.
Support for
custom sky shaders
, which can be animated.
The radiance map used for ambient and specular light can be updated in
real-time depending on the quality settings chosen.
Fog:
Exponential depth fog.
Exponential height fog.
Support for automatic fog color depending on the sky color (aerial perspective).
Support for sun scattering in the fog.
Support for controlling how much fog rendering should affect the sky, with
separate controls for traditional and volumetric fog.
Support for making specific materials ignore fog.
Volumetric fog:
Global
volumetric fog
that reacts to lights and shadows.
Volumetric fog can take indirect light into account when using VoxelGI or SDFGI.
Fog volume nodes that can be placed to add fog to specific areas (or remove fog from specific areas).
Supported shapes include box, ellipse, cone, cylinder, and 3D texture-based density maps.
Each fog volume can have its own custom shader.
Can be used together with traditional fog.
Particles:
GPU-based particles with support for subemitters (2D + 3D), trails (2D + 3D),
attractors (3D only) and collision (2D + 3D).
3D particle attractor shapes supported: box, sphere and 3D vector fields.
3D particle collision shapes supported: box, sphere, baked signed distance field
and real-time heightmap (suited for open world weather effects).
2D particle collision is handled using a signed distance field generated in real-time
based on
LightOccluder2D
nodes in the scene.
Trails can use the built-in ribbon trail and tube trail meshes, or custom
meshes with skeletons.
Support for custom particle shaders with manual emission.
CPU-based particles.
Post-processing:
Tonemapping (Linear, Reinhard, Filmic, ACES, AgX).
Automatic exposure adjustments based on viewport brightness (and manual exposure override).
Near and far depth of field with adjustable bokeh simulation (box, hexagon, circle).
Screen-space ambient occlusion (SSAO) at half or full resolution.
Glow/bloom with optional bicubic upscaling and several blend modes available:
Screen, Soft Light, Add, Replace, Mix.
Glow can have a colored dirt map texture, acting as a lens dirt effect.
Glow can be
used as a screen-space blur effect
.
Color correction using a one-dimensional ramp or a 3D LUT texture.
Roughness limiter to reduce the impact of specular aliasing.
Brightness, contrast and saturation adjustments.
Texture filtering:
Nearest, bilinear, trilinear or anisotropic filtering.
Filtering options are defined on a per-use basis, not a per-texture basis.
Texture compression:
Basis Universal (slow, but results in smaller files).
BPTC for high-quality compression (not supported on macOS).
ETC2 (not supported on macOS).
S3TC (not supported on mobile/Web platforms).
Antialiasing:
Temporal
antialiasing
(TAA).
AMD FidelityFX Super Resolution 2.2
antialiasing
(FSR2),
which can be used at native resolution as a form of high-quality temporal antialiasing.
Multi-sample antialiasing (MSAA), for both
2D antialiasing
and
3D antialiasing
.
Fast approximate antialiasing (FXAA).
Super-sample antialiasing (SSAA) using bilinear 3D scaling and a 3D resolution scale above 1.0.
Alpha antialiasing, MSAA alpha to coverage and alpha hashing on a per-material basis.
Resolution scaling:
Support for
rendering 3D at a lower resolution
while keeping 2D rendering at the original scale. This can be used to improve
performance on low-end systems or improve visuals on high-end systems.
Resolution scaling uses bilinear filtering, AMD FidelityFX Super Resolution
1.0 (FSR1) or AMD FidelityFX Super Resolution 2.2 (FSR2).
Texture mipmap LOD bias is adjusted automatically to improve quality at lower
resolution scales. It can also be modified with a manual offset.
Most effects listed above can be adjusted for better performance or to further
improve quality. This can be helpful when
using Godot for offline rendering
.
3D tools

Built-in meshes: cube, cylinder/cone, (hemi)sphere, prism, plane, quad, torus, ribbon, tube.
GridMaps
for 3D tile-based level design.
Constructive solid geometry
(intended for prototyping).
Tools for
procedural geometry generation
.
Path3D node to represent a path in 3D space.
Can be drawn in the editor or generated procedurally.
PathFollow3D node to make nodes follow a Path3D.
3D geometry helper class
.
Support for exporting the current scene as a glTF 2.0 file, both from the editor
and at runtime from an exported project.
3D physics

Physics bodies:
Static bodies.
Animatable bodies (for objects moving only by script or animation, such as doors and platforms).
Rigid bodies.
Character bodies.
Vehicle bodies (intended for arcade physics, not simulation).
Joints.
Soft bodies
.
Ragdolls
.
Areas to detect bodies entering or leaving it.
Collision detection:
Built-in shapes: cuboid, sphere, capsule, cylinder, world boundary (infinite plane).
Generate triangle collision shapes for any mesh from the editor.
Generate one or several convex collision shapes for any mesh from the editor.
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
.
Visual shader editor.
Support for
visual shader plugins
.
Scripting

General:
Object-oriented design pattern with scripts extending nodes.
Signals and groups for communicating between scripts.
Support for
cross-language scripting
.
Many 2D, 3D and 4D linear algebra data types such as vectors and transforms.
GDScript:
High-level interpreted language
with
optional static typing
.
Syntax inspired by Python. However, GDScript is
not
based on Python.
Syntax highlighting is provided on GitHub.
Use threads
to perform asynchronous actions
or make use of multiple processor cores.
C#:
Packaged in a separate binary to keep file sizes and dependencies down.
Supports .NET 8 and higher.
Full support for the C# 12.0 syntax and features.
Supports Windows, Linux, and macOS. Since Godot 4.2, experimental support for Android and iOS is also available.
On the iOS platform only some architectures are supported:
arm64
.
The web platform is currently unsupported. To use C# on that platform,
consider Godot 3 instead.
Using an external editor is recommended to benefit from IDE functionality.
GDExtension (C, C++, Rust, D, ...):
When you need it, link to native libraries for higher performance and third-party integrations.
For scripting game logic, GDScript or C# are recommended if their
performance is suitable.
Official GDExtension bindings for
C
and
C++
.
Use any build system and language features you wish.
Actively developed GDExtension bindings for
D
,
Swift
, and
Rust
bindings provided by the community. (Some of these bindings may be experimental and not production-ready).
Audio

Features:
Mono, stereo, 5.1 and 7.1 output.
Non-positional and positional playback in 2D and 3D.
Optional Doppler effect in 2D and 3D.
Support for re-routable
audio buses
and effects
with dozens of effects included.
Support for polyphony (playing several sounds from a single AudioStreamPlayer node).
Support for random volume and pitch.
Support for real-time pitch scaling.
Support for sequential/random sample selection, including repetition prevention
when using random sample selection.
Listener2D and Listener3D nodes to listen from a position different than the camera.
Support for
procedural audio generation
.
Audio input to record microphones.
Text to speech
using platform-provided TTS engines.
MIDI input.
No support for MIDI output yet.
APIs used:
Windows:
WASAPI.
macOS:
CoreAudio.
Linux:
PulseAudio or ALSA.
Import

Support for
custom import plugins
.
Formats:
Images:
See
Importing images
.
Audio:
WAV with optional IMA-ADPCM compression.
Ogg Vorbis.
MP3.
3D scenes:
See
Importing 3D scenes
.
glTF 2.0
(recommended)
.
.blend
(by calling Blender's glTF export functionality transparently).
FBX (by calling
FBX2glTF
transparently).
Collada (.dae).
Wavefront OBJ (static scenes only, can be loaded directly as a mesh or imported as a 3D scene).
Support for loading glTF 2.0 scenes at runtime, including from an exported project.
3D meshes use
Mikktspace
to generate tangents
on import, which ensures consistency with other 3D applications such as Blender.
Input

Input mapping system
using hardcoded input events
or remappable input actions.
Axis values can be mapped to two different actions with a configurable deadzone.
Use the same code to support both keyboards and gamepads.
Keyboard input.
Keys can be mapped in "physical" mode to be independent of the keyboard layout.
Mouse input.
The mouse cursor can be visible, hidden, captured or confined within the window.
When captured, raw input will be used on Windows and Linux to
sidestep the OS' mouse acceleration settings.
Gamepad input (up to 8 simultaneous controllers).
Pen/tablet input with pressure support.
Navigation

A* algorithm in
2D
and
3D
.
Navigation meshes with dynamic obstacle avoidance in
2D
and
3D
.
Generate navigation meshes from the editor or at runtime (including from an exported project).
Networking

Low-level TCP networking using
StreamPeer
and
TCPServer
.
Low-level UDP networking using
PacketPeer
and
UDPServer
.
Low-level HTTP requests using
HTTPClient
.
High-level HTTP requests using
HTTPRequest
.
Supports HTTPS out of the box using bundled certificates.
High-level multiplayer
API using UDP and ENet.
Automatic replication using remote procedure calls (RPCs).
Supports unreliable, reliable and ordered transfers.
WebSocket
client and server, available on all platforms.
WebRTC
client and server, available on all platforms.
Support for
UPnP
to sidestep the requirement to forward ports
when hosting a server behind a NAT.
Internationalization

Full support for Unicode including emoji.
Support for loading system fonts on Windows, macOS, and Linux.
By default, system fonts are used as a fallback to display unsupported
characters. This allows proper display of multilingual text without
having to bundle large font files with a project.
Store localization strings using
CSV
or
gettext
.
Support for generating gettext POT and PO files from the editor.
Use localized strings in your project automatically in GUI elements or by
using the
tr()
function.
Support for pluralization and translation contexts.
Support for
bidirectional typesetting
,
text shaping and OpenType localized forms.
Automatic UI mirroring for right-to-left locales.
Support for pseudolocalization to test your project for i18n-friendliness.
Windowing and OS integration

Spawn multiple independent windows within a single process.
Move, resize, minimize, and maximize windows spawned by the project.
Change the window title and icon.
Create transparent windows to use as overlays, with polygon-based
mouse passthrough support.
Request attention (will cause the title bar to blink on most platforms).
Fullscreen mode.
Uses borderless fullscreen by default on Windows for fast alt-tabbing,
but can optionally use exclusive fullscreen to reduce input lag.
Borderless windows (fullscreen or non-fullscreen).
Keep a window always on top.
Make a window ignore focus (useful for overlays).
Declare a window as a popup (hidden from task switcher)
or exclusive (prevents interacting with other windows from the same process).
Native file dialog support on Windows, macOS, Linux, and Android.
Tray icon support on Windows and macOS.
Global menu integration on macOS.
Client-side decorations on macOS.
Execute commands in a blocking or non-blocking manner (including running
multiple instances of the same project).
Open file paths and URLs using default or custom protocol handlers (if registered on the system).
Parse custom command line arguments.
Support for screen readers on Windows, macOS, and Linux.
Any Godot binary (editor or exported project) can be
used as a headless server
by starting it with the
--headless
command line argument.
This allows running the engine without a GPU or display server.
See also
See
Creating applications
for details on using these features.
Mobile

In-app purchases on
Android
and
iOS
.
Support for advertisements using third-party modules.
XR support (AR and VR)

Out of the box
support for OpenXR
.
Including support for popular desktop headsets like the Valve Index, WMR headsets, and Quest over Link.
Support for
Android-based headsets
using OpenXR through a plugin.
Including support for popular stand alone headsets like the Meta Quest 1/2/3 and Pro, Pico 4, Magic Leap 2, and Lynx R1.
Out of the box limited support for visionOS Apple headsets.
Currently only exporting an application for use on a flat plane within the
headset is supported. Immersive experiences are not supported.
Other devices supported through an XR plugin structure.
Various advanced toolkits are available that implement common features required by XR applications.
GUI system

Godot's GUI is built using the same Control nodes used to make games in Godot.
The editor UI can easily be extended in many ways using add-ons.
Nodes:
Buttons.
Checkboxes, check buttons, radio buttons.
Text entry using
LineEdit
(single line) and
TextEdit
(multiple lines).
TextEdit also supports code editing features such as displaying line numbers
and syntax highlighting.
Dropdown menus using
PopupMenu
and
OptionButton
.
Scrollbars.
Labels.
RichTextLabel for
text formatted using BBCode
,
with support for animated custom effects.
Trees (can also be used to represent tables).
Color picker with RGB and HSV modes.
Controls can be rotated and scaled.
Sizing:
Anchors to keep GUI elements in a specific corner, edge or centered.
Containers to place GUI elements automatically following certain rules.
Stack
layouts.
Grid
layouts.
Flow
layouts (similar to autowrapping text).
Margin
,
centered
and
aspect ratio
layouts.
Draggable splitter
layouts.
Scale to
multiple resolutions
using the
canvas_items
or
viewport
stretch modes.
Support any aspect ratio using anchors and the
expand
stretch aspect.
Theming:
Built-in theme editor.
Generate a theme based on the current editor theme settings.
Procedural vector-based theming using
StyleBoxFlat
.
Supports rounded/beveled corners, drop shadows, per-border widths and antialiasing.
Texture-based theming using
StyleBoxTexture
.
Godot's small distribution size can make it a suitable alternative to frameworks
like Electron or Qt.
Animation

Direct kinematics and inverse kinematics.
Support for animating any property with customizable interpolation.
Support for calling methods in animation tracks.
Support for playing sounds in animation tracks.
Support for Bézier curves in animation.
File formats

Scenes and resources can be saved in
text-based
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.
Read and write text or binary files using
FileAccess
.
Can optionally be compressed or encrypted.
Read and write
JSON
files.
Read and write INI-style configuration files using
ConfigFile
.
Can (de)serialize any Godot datatype, including Vector2/3, Color, ...
Read XML files using
XMLParser
.
Load and save images, audio/video, fonts and ZIP archives
in an exported project without having to go through Godot's import system.
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
that can be read
by the engine to support mods and DLCs.
Miscellaneous

Video playback
with built-in support for Ogg Theora.
Movie Maker mode
to record videos from a running
project with synchronized audio and perfect frame pacing.
Low-level access to servers
which allows bypassing
the scene tree's overhead when needed.
Command line interface
for automation.
Export and deploy projects using continuous integration platforms.
Shell completion scripts
are available for Bash, zsh and fish.
Print colored text to standard output on all platforms using
print_rich
.
The editor can
detect features used in a project and create a compilation profile
,
which can be used to create smaller export template binaries
with unneeded features disabled.
Support for
C++ modules
statically linked
into the engine binary.
Most built-in modules can be disabled at compile-time to reduce binary size
in custom builds. See
Optimizing a build for size
for details.
Engine and editor written in C++17.
Can be
compiled
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.
Builds can be fully reproducible.
Licensed under the permissive MIT license.
Open development process with
contributions welcome
.
See also
The
Godot proposals repository
lists features that have been requested by the community and may be implemented
in future Godot releases.

Classification Response Finish Reason

stop

Classification Response Content

["docs_chunks"]

Classification Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Input Text:** A Markdown file containing a list of features for Godot Engine 4.6. It covers platforms, editor, rendering, 2D/3D graphics, physics, shaders, scripting, audio, import, input, navigation, networking, i18n, windowing, mobile, XR, GUI, animation, file formats, and miscellaneous features.
   - **Task:** Classify the Markdown into zero or more target tables from the list: `["docs_chunks", "api_mapping", "label_prototypes"]`.
   - **Output Format:** Exactly one JSON array. No markdown, no prose, no thinking text.
   - **Rules:** Use `[]` if not useful documentation content. Use one or more valid table names when conversion is needed.

2.  **Evaluate Target Tables:**
   - `docs_chunks`: Typically refers to documentation content split into logical chunks/sections. This file is clearly a documentation page listing features. It fits perfectly.
   - `api_mapping`: Usually maps API endpoints, functions, or classes to descriptions/parameters. This file lists features, not specific API endpoints or function signatures. It's more of a feature list/documentation overview.
   - `label_prototypes`: Usually refers to datasets for labeling tasks, or prototypes of labels/categories. This doesn't seem to fit a feature list documentation page.

   Given the content, it's standard documentation. `docs_chunks` is the most appropriate.

3.  **Determine Output:**
   - The content is highly useful documentation content.
   - It should be classified as `["docs_chunks"]`.
   - Check constraints: "Return exactly one JSON array. Valid values are: ["docs_chunks", "api_mapping", "label_prototypes"]"
   - Output should be just `["docs_chunks"]`.

4.  **Final Verification:**
   - Content: Godot Engine feature list documentation.
   - Matches `docs_chunks`? Yes.
   - JSON format? Yes.
   - No extra text? Yes.
   - Ready.✅
   - Output: `["docs_chunks"]`
   - Self-Correction/Refinement during thought: Could it be `api_mapping`? It mentions nodes like `TileMap`, `Path2D`, `HTTPRequest`, etc., but it's a high-level feature list, not an API reference mapping. `docs_chunks` is definitely the best fit. The prompt says "Classify this Markdown into zero or more target tables." I will output `["docs_chunks"]`.
   - All constraints met. Proceed. 
   - Output matches exactly.✅
   - Generate. 
   - `[ "docs_chunks" ]` (without spaces if preferred, but standard JSON is fine) -> `["docs_chunks"]`
   - Done. 
   - Output Generation. 
   - `["docs_chunks"]`
   - Check format: "Return only valid JSON. No markdown. No prose. No thinking text."
   - Result: `["docs_chunks"]`✅
   - Proceeds. 
   - [Output Generation] -> `["docs_chunks"]`
   - All good. 
   - *Self-Correction/Verification during generation*: Wait, the prompt says "target tables". Sometimes these refer to specific database tables in a RAG pipeline. `docs_chunks` is standard for documentation. I'll stick with `["docs_chunks"]`.
   - Final Answer: `["docs_chunks"]`✅
   - Output matches request.✅
   - Proceeds. 
   - `[ "docs_chunks" ]` -> `["docs_chunks"]` (JSON array)
   - Done. 
   - Output Generation. 
   - `["docs_chunks"]`

Raw Classification Response

{
  "finish_reason": "stop",
  "content": "[\"docs_chunks\"]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Input Text:** A Markdown file containing a list of features for Godot Engine 4.6. It covers platforms, editor, rendering, 2D/3D graphics, physics, shaders, scripting, audio, import, input, navigation, networking, i18n, windowing, mobile, XR, GUI, animation, file formats, and miscellaneous features.\n   - **Task:** Classify the Markdown into zero or more target tables from the list: `[\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]`.\n   - **Output Format:** Exactly one JSON array. No markdown, no prose, no thinking text.\n   - **Rules:** Use `[]` if not useful documentation content. Use one or more valid table names when conversion is needed.\n\n2.  **Evaluate Target Tables:**\n   - `docs_chunks`: Typically refers to documentation content split into logical chunks/sections. This file is clearly a documentation page listing features. It fits perfectly.\n   - `api_mapping`: Usually maps API endpoints, functions, or classes to descriptions/parameters. This file lists features, not specific API endpoints or function signatures. It's more of a feature list/documentation overview.\n   - `label_prototypes`: Usually refers to datasets for labeling tasks, or prototypes of labels/categories. This doesn't seem to fit a feature list documentation page.\n\n   Given the content, it's standard documentation. `docs_chunks` is the most appropriate.\n\n3.  **Determine Output:**\n   - The content is highly useful documentation content.\n   - It should be classified as `[\"docs_chunks\"]`.\n   - Check constraints: \"Return exactly one JSON array. Valid values are: [\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]\"\n   - Output should be just `[\"docs_chunks\"]`.\n\n4.  **Final Verification:**\n   - Content: Godot Engine feature list documentation.\n   - Matches `docs_chunks`? Yes.\n   - JSON format? Yes.\n   - No extra text? Yes.\n   - Ready.✅\n   - Output: `[\"docs_chunks\"]`\n   - Self-Correction/Refinement during thought: Could it be `api_mapping`? It mentions nodes like `TileMap`, `Path2D`, `HTTPRequest`, etc., but it's a high-level feature list, not an API reference mapping. `docs_chunks` is definitely the best fit. The prompt says \"Classify this Markdown into zero or more target tables.\" I will output `[\"docs_chunks\"]`.\n   - All constraints met. Proceed. \n   - Output matches exactly.✅\n   - Generate. \n   - `[ \"docs_chunks\" ]` (without spaces if preferred, but standard JSON is fine) -> `[\"docs_chunks\"]`\n   - Done. \n   - Output Generation. \n   - `[\"docs_chunks\"]`\n   - Check format: \"Return only valid JSON. No markdown. No prose. No thinking text.\"\n   - Result: `[\"docs_chunks\"]`✅\n   - Proceeds. \n   - [Output Generation] -> `[\"docs_chunks\"]`\n   - All good. \n   - *Self-Correction/Verification during generation*: Wait, the prompt says \"target tables\". Sometimes these refer to specific database tables in a RAG pipeline. `docs_chunks` is standard for documentation. I'll stick with `[\"docs_chunks\"]`.\n   - Final Answer: `[\"docs_chunks\"]`✅\n   - Output matches request.✅\n   - Proceeds. \n   - `[ \"docs_chunks\" ]` -> `[\"docs_chunks\"]` (JSON array)\n   - Done. \n   - Output Generation. \n   - `[\"docs_chunks\"]`\n"
}

7. pages/about__release_policy__9f3af805.md

stage: classification
api_url: [redacted]
model: [redacted]
markdown_length: 11710
prompt_length: 12137
parsed_result: ['docs_chunks']
matched_tables: ['docs_chunks']
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 74
  },
  {
    "role": "user",
    "content_length": 12147
  }
]

Full Classification Prompt Sent To Qwen

Classify this Markdown into zero or more target tables.
Return exactly one JSON array. Valid values are:
["docs_chunks", "api_mapping", "label_prototypes"]

Rules:
- Use [] only if the file is not useful documentation content.
- Use one or more valid table names when conversion is needed.
- Do not include explanations, markdown fences, or any text outside JSON.

FILE: pages/about__release_policy__9f3af805.md
FULL MARKDOWN:
# Source: https://docs.godotengine.org/en/stable/about/release_policy.html

Godot Engine 4.6 documentation in English
Godot release policy
Edit on GitHub
Learn how to contribute!
Godot release policy

Godot's release policy is in constant evolution. The description below
provides a general idea of what to expect, but what will actually
happen depends on the choices of core contributors and the needs of the
community at a given time.
Godot versioning

Godot loosely follows
Semantic Versioning
with a
major.minor.patch
versioning system, albeit with an interpretation of each
term adapted to the complexity of a game engine:
The
major
version is incremented when major compatibility breakages happen
which imply significant porting work to move projects from one major version
to another.
For example, porting Godot projects from Godot 3.x to Godot 4.x requires
running the project through a conversion tool, and then performing a number
of further adjustments manually for what the tool could not do automatically.
The
minor
version is incremented for feature releases that do not break
compatibility in a major way. Minor compatibility breakage in very specific
areas
may
happen in minor versions, but the vast majority of projects
should not be affected or require significant porting work.
This is because Godot, as a game engine, covers many areas like rendering,
physics, and scripting. Fixing bugs or implementing new features in one area
might sometimes require changing a feature's behavior or modifying a class's
interface, even if the rest of the engine API remains backwards compatible.
Tip
Upgrading to a new minor version is recommended for all users,
but some testing is necessary to ensure that your project still behaves as
expected.
The
patch
version is incremented for maintenance releases which focus on
fixing bugs and security issues, implementing new requirements for platform
support, and backporting safe usability enhancements. Patch releases are
backwards compatible.
Patch versions may include minor new features which do not impact the
existing API, and thus have no risk of impacting existing projects.
Tip
Updating to new patch versions is therefore considered safe and strongly
recommended to all users of a given stable branch.
We call
major.minor
combinations
stable branches
. Each stable branch
starts with a
major.minor
release (without the
0
for
patch
) and is
further developed for maintenance releases in a Git branch of the same name
(for example patch updates for the 4.0 stable branch are developed in the
4.0
Git branch).
Release support timeline

Stable branches are supported
at least
until the next stable branch is
released and has received its first patch update. In practice, we support
stable branches on a
best effort
basis for as long as they have active users
who need maintenance updates.
Whenever a new major version is released, we make the previous stable branch a
long-term supported release, and do our best to provide fixes for issues
encountered by users of that branch who cannot port complex projects to the new
major version. This was the case for the 2.1 branch, and is the case for the
3.x branch.
In a given minor release series, only the latest patch release receives support.
If you experience an issue using an older patch release, please upgrade to the
latest patch release of that series and test again before reporting an issue
on GitHub.
Version
Release date
Support level
Godot 4.7
(
master
)
Q2/Q3 2026 (estimate)
Development.
Receives new features, usability and
performance improvements, as well as bug fixes, while under development.
Godot 4.6
January 2026
Receives fixes for bugs and security issues, as well as
patches that enable platform support.
Godot 4.5
September 2025
Receives fixes for security and platform support issues only.
Godot 4.4
March 2025
No longer supported (last update: 4.4.1).
Godot 4.3
August 2024
No longer supported (last update: 4.3).
Godot 4.2
November 2023
No longer supported (last update: 4.2.2).
Godot 4.1
July 2023
No longer supported (last update: 4.1.4).
Godot 4.0
March 2023
No longer supported (last update: 4.0.4).
Godot 3.7
(
3.x
)
No ETA for now
Beta.
Receives new features, usability and performance
improvements, as well as bug fixes, while under development.
Godot 3.6
September 2024
Receives fixes for bugs and security issues, as well as
patches that enable platform support.
Godot 3.5
August 2022
No longer supported (last update: 3.5.3).
Godot 3.4
November 2021
No longer supported (last update: 3.4.5).
Godot 3.3
April 2021
No longer supported (last update: 3.3.4).
Godot 3.2
January 2020
No longer supported (last update: 3.2.3).
Godot 3.1
March 2019
No longer supported (last update: 3.1.2).
Godot 3.0
January 2018
No longer supported (last update: 3.0.6).
Godot 2.1
July 2016
No longer supported (last update: 2.1.6).
Godot 2.0
February 2016
No longer supported (last update: 2.0.4.1).
Godot 1.1
May 2015
No longer supported.
Godot 1.0
December 2014
No longer supported.
Legend:
Full support –
Partial support –
No support (end of life) –
Development version
Pre-release Godot versions aren't intended to be used in production and are
provided for testing purposes only.
See also
See
Upgrading from Godot 3 to Godot 4
for instructions on migrating a project
from Godot 3.x to 4.x.
Which version should I use for a new project?

We recommend using Godot 4.x for new projects, as the Godot 4.x series will be
supported long after 3.x stops receiving updates in the future. One caveat is
that a lot of third-party documentation hasn't been updated for Godot 4.x yet.
If you have to follow a tutorial designed for Godot 3.x, we recommend keeping
Upgrading from Godot 3 to Godot 4
open in a separate tab to check which methods
have been renamed (if you get a script error while trying to use a specific node
or method that was renamed in Godot 4.x).
If your project requires a feature that is missing in 4.x (such as GLES2/WebGL
1.0), you should use Godot 3.x for a new project instead.
Should I upgrade my project to use new engine versions?

Note
Upgrading software while working on a project is inherently risky, so
consider whether it's a good idea for your project before attempting an
upgrade. Also, make backups of your project or use version control to
prevent losing data in case the upgrade goes wrong.
That said, we do our best to keep minor and especially patch releases
compatible with existing projects.
The general recommendation is to upgrade your project to follow new
patch
releases, such as upgrading from 4.0.2 to 4.0.3. This ensures you get bug fixes,
security updates and platform support updates (which is especially important for
mobile platforms). You also get continued support, as only the last patch
release receives support on official community platforms.
For
minor
releases, you should determine whether it's a good idea to upgrade
on a case-by-case basis. We've made a lot of effort in making the upgrade
process as seamless as possible, but some breaking changes may be present in
minor releases, along with a greater risk of regressions. Some fixes included in
minor releases may also change a class' expected behavior as required to fix
some bugs. This is especially the case in classes marked as
experimental
in
the documentation.
Major
releases bring a lot of new functionality, but they also remove
previously existing functionality and may raise hardware requirements. They also
require much more work to upgrade to compared to minor releases. As a result, we
recommend sticking with the major release you've started your project with if
you are happy with how your project currently works. For example, if your
project was started with 3.5, we recommend upgrading to 3.5.2 and possibly 3.6
in the future, but not to 4.0+, unless your project really needs the new
features that come with 4.0+.
When is the next release out?

While Godot contributors aren't working under any deadlines, we strive to
publish minor releases relatively frequently.
In particular, after the very long release cycle for 4.0, we are pivoting to
a faster-paced development workflow, 4.1 released 4 months after 4.0, and 4.2
released 4 months after 4.1.
Frequent minor releases will enable us to ship new features faster (possibly
as experimental), get user feedback quickly, and iterate to improve those
features and their usability. Likewise, the general user experience will be
improved more steadily with a faster path to the end users.
Maintenance (patch) releases are released as needed with potentially very
short development cycles, to provide users of the current stable branch with
the latest bug fixes for their production needs.
There is currently no planned release date for the next 3.x minor version, 3.7.
The current stable release, 3.6, may be the last stable branch of Godot 3.x.
Godot 3.x is supported on a best-effort basis, as long as contributors continue
to maintain it.
What are the criteria for compatibility across engine versions?

Note
This section is intended to be used by contributors to determine which
changes are safe for a given release. The list is not exhaustive; it only
outlines the most common situations encountered during Godot's development.
The following changes are acceptable in patch releases:
Fixing a bug in a way that has no major negative impact on most projects, such
as a visual or physics bug. Godot's physics engine is not deterministic, so
physics bug fixes are not considered to break compatibility. If fixing a bug
has a negative impact that could impact a lot of projects, it should be made
optional (e.g. using a project setting or separate method).
Adding a new optional parameter to a method.
Small-scale editor usability tweaks.
Note that we tend to be more conservative with the fixes we allow in each
subsequent patch release. For instance, 4.0.1 may receive more impactful fixes
than 4.0.4 would.
The following changes are acceptable in minor releases, but not patch releases:
Significant new features.
Renaming a method parameter. In C#, method parameters can be passed by name
(but not in GDScript). As a result, this can break some projects that use C#.
Deprecating a method, member variable, or class. This is done by adding a
deprecated flag to its class reference, which will show up in the editor. When
a method is marked as deprecated, it's slated to be removed in the next
major
release.
Changes that affect the default project theme's visuals.
Bug fixes which significantly change the behavior or the output, with the aim
to meet user expectations better. In comparison, in patch releases, we may
favor keeping a buggy behavior so we don't break existing projects which
likely already rely on the bug or use a workaround.
Performance optimizations that result in visual changes.
The following changes are considered
compatibility-breaking
and can only be
performed in a new major release:
Renaming or removing a method, member variable, or class.
Modifying a node's inheritance tree by making it inherit from a different class.
Changing the default value of a project setting value in a way that affects existing
projects. To only affect new projects, the project manager should write a
modified
project.godot
instead.
Since Godot 5.0 hasn't been branched off yet, we currently discourage making
compatibility-breaking changes of this kind.
Note
When modifying a method's signature in any fashion (including adding an
optional parameter), a GDExtension compatibility method must be created.
This ensures that existing GDExtensions continue to work across patch and
minor releases, so that users don't have to recompile them.
See
Handling compatibility breakages
for more information.

Classification Response Finish Reason

stop

Classification Response Content

["docs_chunks"]

Classification Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Input Text:** A Markdown file about Godot Engine's release policy.
   - **Task:** Classify the Markdown into zero or more target tables from a predefined list: `["docs_chunks", "api_mapping", "label_prototypes"]`.
   - **Output Format:** Exactly one JSON array. No markdown, no prose, no thinking text.
   - **Rules:** Use `[]` if not useful documentation content. Use one or more valid table names if conversion is needed.

2.  **Evaluate Content against Target Tables:**
   - `docs_chunks`: Typically refers to documentation content that can be chunked for retrieval, FAQs, guides, release notes, policies, etc. This file is clearly a documentation page about the release policy, versioning, support timeline, and upgrade recommendations. It fits perfectly as documentation content.
   - `api_mapping`: Usually maps API names, functions, classes, or parameters to descriptions or implementations. This file mentions API concepts (methods, classes, parameters) but isn't an API mapping table itself.
   - `label_prototypes`: Usually refers to UI/UX labels, button text, or prototype definitions. Not applicable here.

   Conclusion: The content is clearly documentation. It should be classified as `["docs_chunks"]`.

3.  **Format Output:**
   - Must be exactly one JSON array.
   - Valid values: `["docs_chunks", "api_mapping", "label_prototypes"]`
   - Result: `["docs_chunks"]`

4.  **Final Check:**
   - Does it match the rules? Yes.
   - Is it valid JSON? Yes.
   - No markdown fences? Yes.
   - No extra text? Yes.
   - Output matches requirement. Proceed. 
   - Self-Correction/Refinement during thought: The prompt says "Classify this Markdown into zero or more target tables." and gives valid values. The content is definitely documentation. So `["docs_chunks"]` is correct. I will output just that.✅
   - Output generation. 
   - `["docs_chunks"]` matches all constraints.✅
   - Proceed. 
   - Output: `["docs_chunks"]` (as raw JSON)
   - Check format: "Return only valid JSON. No markdown. No prose. No thinking text." -> `["docs_chunks"]` is perfect. 
   - Done. 
   - Output Generation. 
   - `[ "docs_chunks" ]` (without spaces is fine too) -> `["docs_chunks"]`
   - All good. 
   - Proceeds. 
   - [Output Generation] -> `["docs_chunks"]`
   - [Final Check of the Prompt] "Classify this Markdown into zero or more target tables. Return exactly one JSON array. Valid values are: ["docs_chunks", "api_mapping", "label_prototypes"]" -> Matches.
   - Ready. 
   - Output matches exactly.✅
   - *Self-Correction/Verification during thought*: Wait, is there any chance it's `["docs_chunks"]`? Yes. The content is a standard documentation page. It contains text, headings, tips, and a table of versions. It's clearly for documentation chunking.
   - Final Output: `["docs_chunks"]`
   - Proceeds. 
   - [Output Generation] -> `["docs_chunks"]` (raw string)
   - Done. 
   - *Output Generation* (matches exactly)
   - `["docs_chunks"]`
   - All constraints met.✅

Raw Classification Response

{
  "finish_reason": "stop",
  "content": "[\"docs_chunks\"]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Input Text:** A Markdown file about Godot Engine's release policy.\n   - **Task:** Classify the Markdown into zero or more target tables from a predefined list: `[\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]`.\n   - **Output Format:** Exactly one JSON array. No markdown, no prose, no thinking text.\n   - **Rules:** Use `[]` if not useful documentation content. Use one or more valid table names if conversion is needed.\n\n2.  **Evaluate Content against Target Tables:**\n   - `docs_chunks`: Typically refers to documentation content that can be chunked for retrieval, FAQs, guides, release notes, policies, etc. This file is clearly a documentation page about the release policy, versioning, support timeline, and upgrade recommendations. It fits perfectly as documentation content.\n   - `api_mapping`: Usually maps API names, functions, classes, or parameters to descriptions or implementations. This file mentions API concepts (methods, classes, parameters) but isn't an API mapping table itself.\n   - `label_prototypes`: Usually refers to UI/UX labels, button text, or prototype definitions. Not applicable here.\n\n   Conclusion: The content is clearly documentation. It should be classified as `[\"docs_chunks\"]`.\n\n3.  **Format Output:**\n   - Must be exactly one JSON array.\n   - Valid values: `[\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]`\n   - Result: `[\"docs_chunks\"]`\n\n4.  **Final Check:**\n   - Does it match the rules? Yes.\n   - Is it valid JSON? Yes.\n   - No markdown fences? Yes.\n   - No extra text? Yes.\n   - Output matches requirement. Proceed. \n   - Self-Correction/Refinement during thought: The prompt says \"Classify this Markdown into zero or more target tables.\" and gives valid values. The content is definitely documentation. So `[\"docs_chunks\"]` is correct. I will output just that.✅\n   - Output generation. \n   - `[\"docs_chunks\"]` matches all constraints.✅\n   - Proceed. \n   - Output: `[\"docs_chunks\"]` (as raw JSON)\n   - Check format: \"Return only valid JSON. No markdown. No prose. No thinking text.\" -> `[\"docs_chunks\"]` is perfect. \n   - Done. \n   - Output Generation. \n   - `[ \"docs_chunks\" ]` (without spaces is fine too) -> `[\"docs_chunks\"]`\n   - All good. \n   - Proceeds. \n   - [Output Generation] -> `[\"docs_chunks\"]`\n   - [Final Check of the Prompt] \"Classify this Markdown into zero or more target tables. Return exactly one JSON array. Valid values are: [\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]\" -> Matches.\n   - Ready. \n   - Output matches exactly.✅\n   - *Self-Correction/Verification during thought*: Wait, is there any chance it's `[\"docs_chunks\"]`? Yes. The content is a standard documentation page. It contains text, headings, tips, and a table of versions. It's clearly for documentation chunking.\n   - Final Output: `[\"docs_chunks\"]`\n   - Proceeds. \n   - [Output Generation] -> `[\"docs_chunks\"]` (raw string)\n   - Done. \n   - *Output Generation* (matches exactly)\n   - `[\"docs_chunks\"]`\n   - All constraints met.✅\n"
}

8. pages/about__system_requirements__6f1863c2.md

stage: classification
api_url: [redacted]
model: [redacted]
markdown_length: 11736
prompt_length: 12168
parsed_result: ['docs_chunks']
matched_tables: ['docs_chunks']
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 74
  },
  {
    "role": "user",
    "content_length": 12178
  }
]

Full Classification Prompt Sent To Qwen

Classify this Markdown into zero or more target tables.
Return exactly one JSON array. Valid values are:
["docs_chunks", "api_mapping", "label_prototypes"]

Rules:
- Use [] only if the file is not useful documentation content.
- Use one or more valid table names when conversion is needed.
- Do not include explanations, markdown fences, or any text outside JSON.

FILE: pages/about__system_requirements__6f1863c2.md
FULL MARKDOWN:
# Source: https://docs.godotengine.org/en/stable/about/system_requirements.html

Godot Engine 4.6 documentation in English
System requirements
Edit on GitHub
Learn how to contribute!
System requirements

This page contains system requirements for the editor and exported projects.
These specifications are given for informative purposes only, but they can be
referred to if you're looking to build or upgrade a system to use Godot on.
Godot editor

These are the
minimum
specifications required to run the Godot editor and work
on a simple 2D or 3D project:
Desktop or laptop PC - Minimum

CPU
Windows:
x86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv8 CPU
Example: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite
macOS:
x86_64 or ARM CPU (Apple Silicon)
Example: Intel Core 2 Duo SU9400, Apple M1
Linux:
x86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv7 or
ARMv8 CPU
Example: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4
GPU
Forward+ renderer:
Integrated graphics with full Vulkan 1.0 support
Example: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)
Mobile renderer:
Integrated graphics with full Vulkan 1.0 support
Example: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)
Compatibility renderer:
Integrated graphics with full OpenGL 3.3 support
Example: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)
RAM
Native editor:
4 GB
Web editor:
8 GB
Storage
200 MB (used for the executable, project files and cache).
Exporting projects requires downloading export templates separately
(1.3 GB after installation).
Operating system
Native editor:
Windows 10, macOS 10.13 (Compatibility) or
macOS 10.15 (Forward+/Mobile), Linux distribution released after 2018
Web editor:
Recent versions of mainstream browsers: Firefox and derivatives
(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.
Note
If your x86_64 CPU does not support SSE4.2, you can still run the 32-bit Godot
executable which only has a SSE2 requirement (all x86_64 CPUs support SSE2).
While supported on Linux, we have no official minimum requirements for running on
rv64 (RISC-V), ppc64 & ppc32 (PowerPC), and loongarch64. In addition you must
compile the editor for that platform (as well as export templates) yourself,
no official downloads are currently provided. RISC-V compiling instructions can
be found on the
Compiling for Linux, *BSD
page.
Mobile device (smartphone/tablet) - Minimum

CPU
Android:
SoC with any 32-bit or 64-bit ARM or x86 CPU
Example: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430
iOS:
Cannot run the editor
GPU
Forward+ renderer:
SoC featuring GPU with full Vulkan 1.0 support
Example: Qualcomm Adreno 505, Mali-G71 MP2
Mobile renderer:
SoC featuring GPU with full Vulkan 1.0 support
Example: Qualcomm Adreno 505, Mali-G71 MP2
Compatibility renderer:
SoC featuring GPU with full OpenGL ES 3.0 support
Example: Qualcomm Adreno 306, Mali-T628 MP6
RAM
Native editor:
3 GB
Web editor:
6 GB
Storage
200 MB (used for the executable, project files and cache)
Exporting projects requires downloading export templates separately
(1.3 GB after installation)
Operating system
Native editor:
Android 6.0 (Compatibility) or Android 9.0 (Forward+/Mobile)
Web editor:
Recent versions of mainstream browsers: Firefox and derivatives
(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.
These are the
recommended
specifications to get a smooth experience with the
Godot editor on a simple 2D or 3D project:
Desktop or laptop PC - Recommended

CPU
Windows:
x86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU
Example: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite
macOS:
x86_64 or ARM CPU (Apple Silicon)
Example: Intel Core i5-8500, Apple M1
Linux:
x86_64 CPU with SSE4.2 support, ARMv7 or ARMv8 CPU
Example: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking
GPU
Forward+ renderer:
Dedicated graphics with full Vulkan 1.2 support
Example: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)
Mobile renderer:
Dedicated graphics with full Vulkan 1.2 support
Example: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)
Compatibility renderer:
Dedicated graphics with full OpenGL 4.6 support
Example: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)
RAM
Native editor:
8 GB
Web editor:
12 GB
Storage
1.5 GB (used for the executable, project files, all export templates and cache)
Operating system
Native editor:
Windows 10, macOS 10.15,
Linux distribution released after 2020
Web editor:
Latest version of Firefox, Chrome, Edge, Safari, Opera
Mobile device (smartphone/tablet) - Recommended

CPU
Android:
SoC with 64-bit ARM or x86 CPU, with 3 "performance" cores or more
Example: Qualcomm Snapdragon 845, Samsung Exynos 9810
iOS:
Cannot run the editor
GPU
Forward+ renderer:
SoC featuring GPU with full Vulkan 1.2 support
Example: Qualcomm Adreno 630, Mali-G72 MP18
Mobile renderer:
SoC featuring GPU with full Vulkan 1.2 support
Example: Qualcomm Adreno 630, Mali-G72 MP18
Compatibility renderer:
SoC featuring GPU with full OpenGL ES 3.2 support
Example: Qualcomm Adreno 630, Mali-G72 MP18
RAM
Native editor:
6 GB
Web editor:
8 GB
Storage
1.5 GB (used for the executable, project files, all export templates and cache)
Operating system
Native editor:
Android 9.0
Web editor:
Latest version of Firefox, Chrome, Edge, Safari, Opera,
Samsung Internet
Exported Godot project

Warning
The requirements below are a baseline for a
simple
2D or 3D project,
with basic scripting and few visual flourishes. CPU, GPU, RAM and
storage requirements will heavily vary depending on your project's scope,
its renderer, viewport resolution and graphics settings chosen.
Other programs running on the system while the project is running
will also compete for resources, including RAM and video RAM.
It is strongly recommended to do your own testing on low-end hardware to
make sure your project runs at the desired speed. To provide scalability for
low-end hardware, you will also need to introduce a
graphics options menu
to your project.
These are the
minimum
specifications required to run a simple 2D or 3D
project exported with Godot:
Desktop or laptop PC - Minimum

CPU
Windows:
x86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,
ARMv8 CPU
Example: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite
macOS:
x86_64 or ARM CPU (Apple Silicon)
Example: Intel Core 2 Duo SU9400, Apple M1
Linux:
x86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,
ARMv7 or ARMv8 CPU
Example: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4
GPU
Forward+ renderer:
Integrated graphics with full Vulkan 1.0 support,
Metal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)
Example: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)
Mobile renderer:
Integrated graphics with full Vulkan 1.0 support,
Metal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)
Example: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)
Compatibility renderer:
Integrated graphics with full OpenGL 3.3 support
or Direct3D 11 support (Windows).
Example: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)
RAM
For native exports:
2 GB
For web exports:
4 GB
Storage
150 MB (used for the executable, project files and cache)
Operating system
For native exports:
Windows 10, macOS 10.13 (Compatibility), macOS 10.15
(Forward+/Mobile, Vulkan), macOS 13.0 (Forward+/Mobile, Metal), Linux distribution
released after 2018
Web editor:
Recent versions of mainstream browsers: Firefox and derivatives
(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.
Mobile device (smartphone/tablet) - Minimum

CPU
Android:
SoC with any 32-bit or 64-bit ARM or x86 CPU
Example: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430
iOS:
SoC with any 64-bit ARM CPU
Example: Apple A7 (iPhone 5S)
GPU
Forward+ renderer:
SoC featuring GPU with full Vulkan 1.0 support, or
Metal 3 support (iOS/iPadOS)
Example (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)
Example (Metal): Apple A12 (iPhone XR/XS)
Mobile renderer:
SoC featuring GPU with full Vulkan 1.0 support, or
Metal 3 support (iOS/iPadOS)
Example (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)
Example (Metal): Apple A12 (iPhone XR/XS)
Compatibility renderer:
SoC featuring GPU with full OpenGL ES 3.0 support
Example: Qualcomm Adreno 306, Mali-T628 MP6, Apple A7 (iPhone 5S)
RAM
For native exports:
1 GB
For web exports:
2 GB
Storage
150 MB (used for the executable, project files and cache)
Operating system
For native exports:
Android 6.0 (Compatibility), Android 9.0 (Forward+/Mobile),
iOS 12.0 (Forward+/Mobile, Vulkan), iOS 16.0 (Forward+/Mobile, Metal)
Web editor:
Recent versions of mainstream browsers: Firefox and derivatives
(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.
These are the
recommended
specifications to get a smooth experience with a
simple 2D or 3D project exported with Godot:
Desktop or laptop PC - Recommended

CPU
Windows:
x86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU
Example: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite
macOS:
x86_64 or ARM CPU (Apple Silicon)
Example: Intel Core i5-8500, Apple M1
Linux:
x86_64 CPU with SSE4.2 support, with 4 physical cores or more,
ARMv7 or ARMv8 CPU
Example: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking
GPU
Forward+ renderer:
Dedicated graphics with full Vulkan 1.2 support,
Metal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)
Example: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)
Mobile renderer:
Dedicated graphics with full Vulkan 1.2 support,
Metal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)
Example: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)
Compatibility renderer:
Dedicated graphics with full OpenGL 4.6 support
Example: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)
RAM
For native exports:
4 GB
For web exports:
8 GB
Storage
150 MB (used for the executable, project files and cache)
Operating system
For native exports:
Windows 10, macOS 10.15 (Forward+/Mobile, Vulkan), macOS 13.0
(Forward+/Mobile, Metal), Linux distribution released after 2020
For web exports:
Latest version of Firefox, Chrome, Edge, Safari, Opera
Mobile device (smartphone/tablet) - Recommended

CPU
Android:
SoC with 64-bit ARM or x86 CPU, with 3 "performance" cores or more
Example: Qualcomm Snapdragon 845, Samsung Exynos 9810
iOS:
SoC with 64-bit ARM CPU
Example: Apple A14 (iPhone 12)
GPU
Forward+ renderer:
SoC featuring GPU with full Vulkan 1.2 support, or
Metal 3 support (iOS/iPadOS)
Example: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)
Mobile renderer:
SoC featuring GPU with full Vulkan 1.2 support, or
Metal 3 support (iOS/iPadOS)
Example: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)
Compatibility renderer:
SoC featuring GPU with full OpenGL ES 3.2 support
Example: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)
RAM
For native exports:
2 GB
For web exports:
4 GB
Storage
150 MB (used for the executable, project files and cache)
Operating system
For native exports:
Android 9.0, iOS 14.1 (Forward+/Mobile, Vulkan), iOS 16.0
(Forward+/Mobile, Metal)
For web exports:
Latest version of Firefox, Chrome, Edge, Safari, Opera,
Samsung Internet
Note
Godot doesn't use OpenGL/OpenGL ES extensions introduced after OpenGL
3.3/OpenGL ES 3.0, but GPUs supporting newer OpenGL/OpenGL ES versions
generally have fewer driver issues.

Classification Response Finish Reason

stop

Classification Response Content

["docs_chunks"]

Classification Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Input File:** `pages/about__system_requirements__6f1863c2.md`
   - **Content:** A Markdown document detailing system requirements for the Godot Engine 4.6 editor and exported projects. It covers minimum and recommended specs for Desktop/Laptop PC and Mobile devices, broken down by CPU, GPU, RAM, Storage, and OS.
   - **Task:** Classify into zero or more target tables: `["docs_chunks", "api_mapping", "label_prototypes"]`
   - **Output Format:** Exactly one JSON array. No markdown, no prose, no thinking text.

2.  **Understand Target Tables:**
   - `docs_chunks`: Typically for documentation content, articles, guides, reference pages. This file is clearly a documentation page about system requirements.
   - `api_mapping`: Typically for API references, function signatures, class/method mappings. Not applicable here.
   - `label_prototypes`: Typically for UI/UX labels, button text, form fields, or specific prototype definitions. Not applicable here.

3.  **Evaluate Content against Target Tables:**
   - The content is a standard documentation page (`System requirements` for Godot Engine).
   - It fits perfectly into `docs_chunks`.
   - It does not contain API mappings or label prototypes.

4.  **Determine Output:**
   - Since it's useful documentation content, I should return `["docs_chunks"]`.
   - Check rules: "Use [] only if the file is not useful documentation content." -> It is useful.
   - "Use one or more valid table names when conversion is needed." -> `docs_chunks` is needed.
   - Format: JSON array only.

5.  **Construct JSON:**
   `["docs_chunks"]`

   Double-check constraints: "Return only valid JSON. No markdown. No prose. No thinking text."
   Output matches exactly.✅
   Proceed. 
   Self-Correction/Refinement during thought: 
   Could it be `["docs_chunks"]`? Yes.
   Is there any chance it fits `api_mapping` or `label_prototypes`? No.
   Final answer: `["docs_chunks"]`
   Output matches requirement.✅
   Generate. 
   [Output Generation] -> `["docs_chunks"]` (as raw JSON)
   All constraints met.✅
   Proceeds. 
   [Final Check of the Prompt] "Classify this Markdown into zero or more target tables. Return exactly one JSON array. Valid values are: ["docs_chunks", "api_mapping", "label_prototypes"]"
   Result: `["docs_chunks"]` -> Correct. 
   Output matches.✅
   Done. 
   [Output Generation] (Proceeds)
   `["docs_chunks"]`
   (Note: I will ensure no markdown formatting like backticks surrounds it, as per "No markdown.")
   Ready. 
   [Output] `["docs_chunks"]`
   *(Self-Correction/Verification during generation)*: The prompt says "No markdown." so I will output just the raw string `["docs_chunks"]`.
   All good. 
   Proceeds. 
   [Output Generation] -> `["docs_chunks"]`
   *(Done.)*

Raw Classification Response

{
  "finish_reason": "stop",
  "content": "[\"docs_chunks\"]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Input File:** `pages/about__system_requirements__6f1863c2.md`\n   - **Content:** A Markdown document detailing system requirements for the Godot Engine 4.6 editor and exported projects. It covers minimum and recommended specs for Desktop/Laptop PC and Mobile devices, broken down by CPU, GPU, RAM, Storage, and OS.\n   - **Task:** Classify into zero or more target tables: `[\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]`\n   - **Output Format:** Exactly one JSON array. No markdown, no prose, no thinking text.\n\n2.  **Understand Target Tables:**\n   - `docs_chunks`: Typically for documentation content, articles, guides, reference pages. This file is clearly a documentation page about system requirements.\n   - `api_mapping`: Typically for API references, function signatures, class/method mappings. Not applicable here.\n   - `label_prototypes`: Typically for UI/UX labels, button text, form fields, or specific prototype definitions. Not applicable here.\n\n3.  **Evaluate Content against Target Tables:**\n   - The content is a standard documentation page (`System requirements` for Godot Engine).\n   - It fits perfectly into `docs_chunks`.\n   - It does not contain API mappings or label prototypes.\n\n4.  **Determine Output:**\n   - Since it's useful documentation content, I should return `[\"docs_chunks\"]`.\n   - Check rules: \"Use [] only if the file is not useful documentation content.\" -> It is useful.\n   - \"Use one or more valid table names when conversion is needed.\" -> `docs_chunks` is needed.\n   - Format: JSON array only.\n\n5.  **Construct JSON:**\n   `[\"docs_chunks\"]`\n\n   Double-check constraints: \"Return only valid JSON. No markdown. No prose. No thinking text.\"\n   Output matches exactly.✅\n   Proceed. \n   Self-Correction/Refinement during thought: \n   Could it be `[\"docs_chunks\"]`? Yes.\n   Is there any chance it fits `api_mapping` or `label_prototypes`? No.\n   Final answer: `[\"docs_chunks\"]`\n   Output matches requirement.✅\n   Generate. \n   [Output Generation] -> `[\"docs_chunks\"]` (as raw JSON)\n   All constraints met.✅\n   Proceeds. \n   [Final Check of the Prompt] \"Classify this Markdown into zero or more target tables. Return exactly one JSON array. Valid values are: [\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]\"\n   Result: `[\"docs_chunks\"]` -> Correct. \n   Output matches.✅\n   Done. \n   [Output Generation] (Proceeds)\n   `[\"docs_chunks\"]`\n   (Note: I will ensure no markdown formatting like backticks surrounds it, as per \"No markdown.\")\n   Ready. \n   [Output] `[\"docs_chunks\"]`\n   *(Self-Correction/Verification during generation)*: The prompt says \"No markdown.\" so I will output just the raw string `[\"docs_chunks\"]`.\n   All good. \n   Proceeds. \n   [Output Generation] -> `[\"docs_chunks\"]`\n   *(Done.)*\n"
}

9. pages/classesclass_40gdscript__a254d64e.md

stage: classification
api_url: [redacted]
model: [redacted]
markdown_length: 39592
prompt_length: 40025
parsed_result: ['docs_chunks', 'api_mapping']
matched_tables: ['docs_chunks', 'api_mapping']
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 74
  },
  {
    "role": "user",
    "content_length": 40035
  }
]

Full Classification Prompt Sent To Qwen

Classify this Markdown into zero or more target tables.
Return exactly one JSON array. Valid values are:
["docs_chunks", "api_mapping", "label_prototypes"]

Rules:
- Use [] only if the file is not useful documentation content.
- Use one or more valid table names when conversion is needed.
- Do not include explanations, markdown fences, or any text outside JSON.

FILE: pages/classes__class___40gdscript__a254d64e.md
FULL MARKDOWN:
# Source: https://docs.godotengine.org/en/stable/classes/class_%40gdscript.html

Godot Engine 4.6 documentation in English
All classes
@GDScript
@GDScript

Built-in GDScript constants, functions, and annotations.
Description

A list of utility functions and annotations accessible from any script written in GDScript.
For the list of global functions and constants that can be accessed in any scripting language, see
@GlobalScope
.
Tutorials

GDScript exports
Methods

Color
Color8
(r8:
int
, g8:
int
, b8:
int
, a8:
int
= 255)
void
assert
(condition:
bool
, message:
String
= "")
String
char
(code:
int
)
Variant
convert
(what:
Variant
, type:
Variant.Type
)
Object
dict_to_inst
(dictionary:
Dictionary
)
Array
get_stack
()
Dictionary
inst_to_dict
(instance:
Object
)
bool
is_instance_of
(value:
Variant
, type:
Variant
)
int
len
(var:
Variant
)
Resource
load
(path:
String
)
int
ord
(char:
String
)
Resource
preload
(path:
String
)
void
print_debug
(...)
vararg
void
print_stack
()
Array
range
(...)
vararg
bool
type_exists
(type:
StringName
)
Constants

PI
=
3.14159265358979
🔗
Constant that represents how many times the diameter of a circle fits around its perimeter. This is equivalent to
TAU
/
2
, or 180 degrees in rotations.
TAU
=
6.28318530717959
🔗
The circle constant, the circumference of the unit circle in radians. This is equivalent to
PI
*
2
, or 360 degrees in rotations.
INF
=
inf
🔗
Positive floating-point infinity. This is the result of floating-point division when the divisor is
0.0
. For negative infinity, use
-INF
. Dividing by
-0.0
will result in negative infinity if the numerator is positive, so dividing by
0.0
is not the same as dividing by
-0.0
(despite
0.0
==
-0.0
returning
true
).
Warning:
Numeric infinity is only a concept with floating-point numbers, and has no equivalent for integers. Dividing an integer number by
0
will not result in
INF
and will result in a run-time error instead.
NAN
=
nan
🔗
"Not a Number", an invalid floating-point value. It is returned by some invalid operations, such as dividing floating-point
0.0
by
0.0
.
NAN
has special properties, including that
!=
always returns
true
, while other comparison operators always return
false
. This is true even when comparing with itself (
NAN
==
NAN
returns
false
and
NAN
!=
NAN
returns
true
). Due to this, you must use
@GlobalScope.is_nan()
to check whether a number is equal to
NAN
.
Warning:
"Not a Number" is only a concept with floating-point numbers, and has no equivalent for integers. Dividing an integer
0
by
0
will not result in
NAN
and will result in a run-time error instead.
Annotations

@abstract
()
🔗
Marks a class or a method as abstract.
An abstract class is a class that cannot be instantiated directly. Instead, it is meant to be inherited by other classes. Attempting to instantiate an abstract class will result in an error.
An abstract method is a method that has no implementation. Therefore, a newline or a semicolon is expected after the function header. This defines a contract that inheriting classes must conform to, because the method signature must be compatible when overriding.
Inheriting classes must either provide implementations for all abstract methods, or the inheriting class must be marked as abstract. If a class has at least one abstract method (either its own or an unimplemented inherited one), then it must also be marked as abstract. However, the reverse is not true: an abstract class is allowed to have no abstract methods.
@abstract
class
Shape
:
@abstract
func
draw
()
class
Circle
extends
Shape
:
func
draw
():
print
(
"Drawing a circle."
)
class
Square
extends
Shape
:
func
draw
():
print
(
"Drawing a square."
)
Copy to clipboard
@export
()
🔗
Mark the following property as exported (editable in the Inspector dock and saved to disk). To control the type of the exported property, use the type hint notation.
extends
Node
enum
Direction
{
LEFT
,
RIGHT
,
UP
,
DOWN
}
# Built-in types.
@export
var
string
=
""
@export
var
int_number
=
5
@export
var
float_number
:
float
=
5
# Enums.
@export
var
type
:
Variant
.
Type
@export
var
format
:
Image
.
Format
@export
var
direction
:
Direction
# Resources.
@export
var
image
:
Image
@export
var
custom_resource
:
CustomResource
# Nodes.
@export
var
node
:
Node
@export
var
custom_node
:
CustomNode
# Typed arrays.
@export
var
int_array
:
Array
[
int
]
@export
var
direction_array
:
Array
[
Direction
]
@export
var
image_array
:
Array
[
Image
]
@export
var
node_array
:
Array
[
Node
]
Copy to clipboard
Note:
Custom resources and nodes should be registered as global classes using
class_name
, since the Inspector currently only supports global classes. Otherwise, a less specific type will be exported instead.
Note:
Node export is only supported in
Node
-derived classes and has a number of other limitations.
@export_category
(name:
String
)
🔗
Define a new category for the following exported properties. This helps to organize properties in the Inspector dock.
See also
@GlobalScope.PROPERTY_USAGE_CATEGORY
.
@export_category
(
"Statistics"
)
@export
var
hp
=
30
@export
var
speed
=
1.25
Copy to clipboard
Note:
Categories in the Inspector dock's list usually divide properties coming from different classes (Node, Node2D, Sprite, etc.). For better clarity, it's recommended to use
@export_group
and
@export_subgroup
, instead.
@export_color_no_alpha
()
🔗
Export a
Color
,
Array
[
Color
], or
PackedColorArray
property without allowing its transparency (
Color.a
) to be edited.
See also
@GlobalScope.PROPERTY_HINT_COLOR_NO_ALPHA
.
@export_color_no_alpha
var
dye_color
:
Color
@export_color_no_alpha
var
dye_colors
:
Array
[
Color
]
Copy to clipboard
@export_custom
(hint:
PropertyHint
, hint_string:
String
, usage:
BitField
[
PropertyUsageFlags
] = 6)
🔗
Allows you to set a custom hint, hint string, and usage flags for the exported property. Note that there's no validation done in GDScript, it will just pass the parameters to the editor.
@export_custom
(
PROPERTY_HINT_NONE
,
"suffix:m"
)
var
suffix
:
Vector3
Copy to clipboard
Note:
Regardless of the
usage
value, the
@GlobalScope.PROPERTY_USAGE_SCRIPT_VARIABLE
flag is always added, as with any explicitly declared script variable.
@export_dir
()
🔗
Export a
String
,
Array
[
String
], or
PackedStringArray
property as a path to a directory. The path will be limited to the project folder and its subfolders. See
@export_global_dir
to allow picking from the entire filesystem.
See also
@GlobalScope.PROPERTY_HINT_DIR
.
@export_dir
var
sprite_folder_path
:
String
@export_dir
var
sprite_folder_paths
:
Array
[
String
]
Copy to clipboard
@export_enum
(names:
String
, ...)
vararg
🔗
Export an
int
,
String
,
Array
[
int
],
Array
[
String
],
PackedByteArray
,
PackedInt32Array
,
PackedInt64Array
, or
PackedStringArray
property as an enumerated list of options (or an array of options). If the property is an
int
, then the index of the value is stored, in the same order the values are provided. You can add explicit values using a colon. If the property is a
String
, then the value is stored.
See also
@GlobalScope.PROPERTY_HINT_ENUM
.
@export_enum
(
"Warrior"
,
"Magician"
,
"Thief"
)
var
character_class
:
int
@export_enum
(
"Slow:30"
,
"Average:60"
,
"Very Fast:200"
)
var
character_speed
:
int
@export_enum
(
"Rebecca"
,
"Mary"
,
"Leah"
)
var
character_name
:
String
@export_enum
(
"Sword"
,
"Spear"
,
"Mace"
)
var
character_items
:
Array
[
int
]
@export_enum
(
"double_jump"
,
"climb"
,
"dash"
)
var
character_skills
:
Array
[
String
]
Copy to clipboard
If you want to set an initial value, you must specify it explicitly:
@export_enum
(
"Rebecca"
,
"Mary"
,
"Leah"
)
var
character_name
:
String
=
"Rebecca"
Copy to clipboard
If you want to use named GDScript enums, then use
@export
instead:
enum
CharacterName
{
REBECCA
,
MARY
,
LEAH
}
@export
var
character_name
:
CharacterName
enum
CharacterItem
{
SWORD
,
SPEAR
,
MACE
}
@export
var
character_items
:
Array
[
CharacterItem
]
Copy to clipboard
@export_exp_easing
(hints:
String
= "", ...)
vararg
🔗
Export a floating-point property with an easing editor widget. Additional hints can be provided to adjust the behavior of the widget.
"attenuation"
flips the curve, which makes it more intuitive for editing attenuation properties.
"positive_only"
limits values to only be greater than or equal to zero.
See also
@GlobalScope.PROPERTY_HINT_EXP_EASING
.
@export_exp_easing
var
transition_speed
@export_exp_easing
(
"attenuation"
)
var
fading_attenuation
@export_exp_easing
(
"positive_only"
)
var
effect_power
@export_exp_easing
var
speeds
:
Array
[
float
]
Copy to clipboard
@export_file
(filter:
String
= "", ...)
vararg
🔗
Export a
String
,
Array
[
String
], or
PackedStringArray
property as a path to a file. The path will be limited to the project folder and its subfolders. See
@export_global_file
to allow picking from the entire filesystem.
If
filter
is provided, only matching files will be available for picking.
See also
@GlobalScope.PROPERTY_HINT_FILE
.
@export_file
var
sound_effect_path
:
String
@export_file
(
"*.txt"
)
var
notes_path
:
String
@export_file
var
level_paths
:
Array
[
String
]
Copy to clipboard
Note:
The file will be stored and referenced as UID, if available. This ensures that the reference is valid even when the file is moved. You can use
ResourceUID
methods to convert it to path.
@export_file_path
(filter:
String
= "", ...)
vararg
🔗
Same as
@export_file
, except the file will be stored as a raw path. This means that it may become invalid when the file is moved. If you are exporting a
Resource
path, consider using
@export_file
instead.
@export_flags
(names:
String
, ...)
vararg
🔗
Export an integer property as a bit flag field. This allows to store several "checked" or
true
values with one property, and comfortably select them from the Inspector dock.
See also
@GlobalScope.PROPERTY_HINT_FLAGS
.
@export_flags
(
"Fire"
,
"Water"
,
"Earth"
,
"Wind"
)
var
spell_elements
=
0
Copy to clipboard
You can add explicit values using a colon:
@export_flags
(
"Self:4"
,
"Allies:8"
,
"Foes:16"
)
var
spell_targets
=
0
Copy to clipboard
You can also combine several flags:
@export_flags
(
"Self:4"
,
"Allies:8"
,
"Self and Allies:12"
,
"Foes:16"
)
var
spell_targets
=
0
Copy to clipboard
Note:
A flag value must be at least
1
and at most
2
**
32
-
1
.
Note:
Unlike
@export_enum
, the previous explicit value is not taken into account. In the following example, A is 16, B is 2, C is 4.
@export_flags
(
"A:16"
,
"B"
,
"C"
)
var
x
Copy to clipboard
You can also use the annotation on
Array
[
int
],
PackedByteArray
,
PackedInt32Array
, and
PackedInt64Array
@export_flags
(
"Fire"
,
"Water"
,
"Earth"
,
"Wind"
)
var
phase_elements
:
Array
[
int
]
Copy to clipboard
@export_flags_2d_navigation
()
🔗
Export an integer property as a bit flag field for 2D navigation layers. The widget in the Inspector dock will use the layer names defined in
ProjectSettings.layer_names/2d_navigation/layer_1
.
See also
@GlobalScope.PROPERTY_HINT_LAYERS_2D_NAVIGATION
.
@export_flags_2d_navigation
var
navigation_layers
:
int
@export_flags_2d_navigation
var
navigation_layers_array
:
Array
[
int
]
Copy to clipboard
@export_flags_2d_physics
()
🔗
Export an integer property as a bit flag field for 2D physics layers. The widget in the Inspector dock will use the layer names defined in
ProjectSettings.layer_names/2d_physics/layer_1
.
See also
@GlobalScope.PROPERTY_HINT_LAYERS_2D_PHYSICS
.
@export_flags_2d_physics
var
physics_layers
:
int
@export_flags_2d_physics
var
physics_layers_array
:
Array
[
int
]
Copy to clipboard
@export_flags_2d_render
()
🔗
Export an integer property as a bit flag field for 2D render layers. The widget in the Inspector dock will use the layer names defined in
ProjectSettings.layer_names/2d_render/layer_1
.
See also
@GlobalScope.PROPERTY_HINT_LAYERS_2D_RENDER
.
@export_flags_2d_render
var
render_layers
:
int
@export_flags_2d_render
var
render_layers_array
:
Array
[
int
]
Copy to clipboard
@export_flags_3d_navigation
()
🔗
Export an integer property as a bit flag field for 3D navigation layers. The widget in the Inspector dock will use the layer names defined in
ProjectSettings.layer_names/3d_navigation/layer_1
.
See also
@GlobalScope.PROPERTY_HINT_LAYERS_3D_NAVIGATION
.
@export_flags_3d_navigation
var
navigation_layers
:
int
@export_flags_3d_navigation
var
navigation_layers_array
:
Array
[
int
]
Copy to clipboard
@export_flags_3d_physics
()
🔗
Export an integer property as a bit flag field for 3D physics layers. The widget in the Inspector dock will use the layer names defined in
ProjectSettings.layer_names/3d_physics/layer_1
.
See also
@GlobalScope.PROPERTY_HINT_LAYERS_3D_PHYSICS
.
@export_flags_3d_physics
var
physics_layers
:
int
@export_flags_3d_physics
var
physics_layers_array
:
Array
[
int
]
Copy to clipboard
@export_flags_3d_render
()
🔗
Export an integer property as a bit flag field for 3D render layers. The widget in the Inspector dock will use the layer names defined in
ProjectSettings.layer_names/3d_render/layer_1
.
See also
@GlobalScope.PROPERTY_HINT_LAYERS_3D_RENDER
.
@export_flags_3d_render
var
render_layers
:
int
@export_flags_3d_render
var
render_layers_array
:
Array
[
int
]
Copy to clipboard
@export_flags_avoidance
()
🔗
Export an integer property as a bit flag field for navigation avoidance layers. The widget in the Inspector dock will use the layer names defined in
ProjectSettings.layer_names/avoidance/layer_1
.
See also
@GlobalScope.PROPERTY_HINT_LAYERS_AVOIDANCE
.
@export_flags_avoidance
var
avoidance_layers
:
int
@export_flags_avoidance
var
avoidance_layers_array
:
Array
[
int
]
Copy to clipboard
@export_global_dir
()
🔗
Export a
String
,
Array
[
String
], or
PackedStringArray
property as an absolute path to a directory. The path can be picked from the entire filesystem. See
@export_dir
to limit it to the project folder and its subfolders.
See also
@GlobalScope.PROPERTY_HINT_GLOBAL_DIR
.
@export_global_dir
var
sprite_folder_path
:
String
@export_global_dir
var
sprite_folder_paths
:
Array
[
String
]
Copy to clipboard
@export_global_file
(filter:
String
= "", ...)
vararg
🔗
Export a
String
,
Array
[
String
], or
PackedStringArray
property as an absolute path to a file. The path can be picked from the entire filesystem. See
@export_file
to limit it to the project folder and its subfolders.
If
filter
is provided, only matching files will be available for picking.
See also
@GlobalScope.PROPERTY_HINT_GLOBAL_FILE
.
@export_global_file
var
sound_effect_path
:
String
@export_global_file
(
"*.txt"
)
var
notes_path
:
String
@export_global_file
var
multiple_paths
:
Array
[
String
]
Copy to clipboard
@export_group
(name:
String
, prefix:
String
= "")
🔗
Define a new group for the following exported properties. This helps to organize properties in the Inspector dock. Groups can be added with an optional
prefix
, which would make group to only consider properties that have this prefix. The grouping will break on the first property that doesn't have a prefix. The prefix is also removed from the property's name in the Inspector dock.
If no
prefix
is provided, then every following property will be added to the group. The group ends when then next group or category is defined. You can also force end a group by using this annotation with empty strings for parameters,
@export_group("",
"")
.
Groups cannot be nested, use
@export_subgroup
to add subgroups within groups.
See also
@GlobalScope.PROPERTY_USAGE_GROUP
.
@export_group
(
"Racer Properties"
)
@export
var
nickname
=
"Nick"
@export
var
age
=
26
@export_group
(
"Car Properties"
,
"car_"
)
@export
var
car_label
=
"Speedy"
@export
var
car_number
=
3
@export_group
(
""
,
""
)
@export
var
ungrouped_number
=
3
Copy to clipboard
@export_multiline
(hint:
String
= "", ...)
vararg
🔗
Export a
String
,
Array
[
String
],
PackedStringArray
,
Dictionary
or
Array
[
Dictionary
] property with a large
TextEdit
widget instead of a
LineEdit
. This adds support for multiline content and makes it easier to edit large amount of text stored in the property.
See also
@GlobalScope.PROPERTY_HINT_MULTILINE_TEXT
.
@export_multiline
var
character_biography
@export_multiline
var
npc_dialogs
:
Array
[
String
]
@export_multiline
(
"monospace"
,
"no_wrap"
)
var
favorite_ascii_art
:
String
Copy to clipboard
@export_node_path
(type:
String
= "", ...)
vararg
🔗
Export a
NodePath
or
Array
[
NodePath
] property with a filter for allowed node types.
See also
@GlobalScope.PROPERTY_HINT_NODE_PATH_VALID_TYPES
.
@export_node_path
(
"Button"
,
"TouchScreenButton"
)
var
some_button
@export_node_path
(
"Button"
,
"TouchScreenButton"
)
var
many_buttons
:
Array
[
NodePath
]
Copy to clipboard
Note:
The type must be a native class or a globally registered script (using the
class_name
keyword) that inherits
Node
.
@export_placeholder
(placeholder:
String
)
🔗
Export a
String
,
Array
[
String
], or
PackedStringArray
property with a placeholder text displayed in the editor widget when no value is present.
See also
@GlobalScope.PROPERTY_HINT_PLACEHOLDER_TEXT
.
@export_placeholder
(
"Name in lowercase"
)
var
character_id
:
String
@export_placeholder
(
"Name in lowercase"
)
var
friend_ids
:
Array
[
String
]
Copy to clipboard
@export_range
(min:
float
, max:
float
, step:
float
= 1.0, extra_hints:
String
= "", ...)
vararg
🔗
Export an
int
,
float
,
Array
[
int
],
Array
[
float
],
PackedByteArray
,
PackedInt32Array
,
PackedInt64Array
,
PackedFloat32Array
, or
PackedFloat64Array
property as a range value. The range must be defined by
min
and
max
, as well as an optional
step
and a variety of extra hints. The
step
defaults to
1
for integer properties. For floating-point numbers this value depends on your
EditorSettings.interface/inspector/default_float_step
setting.
If hints
"or_greater"
and
"or_less"
are provided, the editor widget will not cap the value at range boundaries. The
"exp"
hint will make the edited values on range to change exponentially. The
"prefer_slider"
hint will make integer values use the slider instead of arrows for editing, while
"hide_control"
will hide the element controlling the value of the editor widget.
Hints also allow to indicate the units for the edited value. Using
"radians_as_degrees"
you can specify that the actual value is in radians, but should be displayed in degrees in the Inspector dock (the range values are also in degrees).
"degrees"
allows to add a degree sign as a unit suffix (the value is unchanged). Finally, a custom suffix can be provided using
"suffix:unit"
, where "unit" can be any string.
See also
@GlobalScope.PROPERTY_HINT_RANGE
.
@export_range
(
0
,
20
)
var
number
@export_range
(
-
10
,
20
)
var
number
@export_range
(
-
10
,
20
,
0.2
)
var
number
:
float
@export_range
(
0
,
20
)
var
numbers
:
Array
[
float
]
@export_range
(
0
,
100
,
1
,
"or_greater"
)
var
power_percent
@export_range
(
0
,
100
,
1
,
"or_greater"
,
"or_less"
)
var
health_delta
@export_range
(
-
180
,
180
,
0.001
,
"radians_as_degrees"
)
var
angle_radians
@export_range
(
0
,
360
,
1
,
"degrees"
)
var
angle_degrees
@export_range
(
-
8
,
8
,
2
,
"suffix:px"
)
var
target_offset
Copy to clipboard
@export_storage
()
🔗
Export a property with
@GlobalScope.PROPERTY_USAGE_STORAGE
flag. The property is not displayed in the editor, but it is serialized and stored in the scene or resource file. This can be useful for
@tool
scripts. Also the property value is copied when
Resource.duplicate()
or
Node.duplicate()
is called, unlike non-exported variables.
var
a
# Not stored in the file, not displayed in the editor.
@export_storage
var
b
# Stored in the file, not displayed in the editor.
@export
var
c
:
int
# Stored in the file, displayed in the editor.
Copy to clipboard
@export_subgroup
(name:
String
, prefix:
String
= "")
🔗
Define a new subgroup for the following exported properties. This helps to organize properties in the Inspector dock. Subgroups work exactly like groups, except they need a parent group to exist. See
@export_group
.
See also
@GlobalScope.PROPERTY_USAGE_SUBGROUP
.
@export_group
(
"Racer Properties"
)
@export
var
nickname
=
"Nick"
@export
var
age
=
26
@export_subgroup
(
"Car Properties"
,
"car_"
)
@export
var
car_label
=
"Speedy"
@export
var
car_number
=
3
Copy to clipboard
Note:
Subgroups cannot be nested, but you can use the slash separator (
/
) to achieve the desired effect:
@export_group
(
"Car Properties"
)
@export_subgroup
(
"Wheels"
,
"wheel_"
)
@export_subgroup
(
"Wheels/Front"
,
"front_wheel_"
)
@export
var
front_wheel_strength
=
10
@export
var
front_wheel_mobility
=
5
@export_subgroup
(
"Wheels/Rear"
,
"rear_wheel_"
)
@export
var
rear_wheel_strength
=
8
@export
var
rear_wheel_mobility
=
3
@export_subgroup
(
"Wheels"
,
"wheel_"
)
@export
var
wheel_material
:
PhysicsMaterial
Copy to clipboard
@export_tool_button
(text:
String
, icon:
String
= "")
🔗
Export a
Callable
property as a clickable button with the label
text
. When the button is pressed, the callable is called.
If
icon
is specified, it is used to fetch an icon for the button via
Control.get_theme_icon()
, from the
"EditorIcons"
theme type. If
icon
is omitted, the default
"Callable"
icon is used instead.
Consider using the
EditorUndoRedoManager
to allow the action to be reverted safely.
See also
@GlobalScope.PROPERTY_HINT_TOOL_BUTTON
.
@tool
extends
Sprite2D
@export_tool_button
(
"Hello"
)
var
hello_action
=
hello
@export_tool_button
(
"Randomize the color!"
,
"ColorRect"
)
var
randomize_color_action
=
randomize_color
func
hello
():
print
(
"Hello world!"
)
func
randomize_color
():
var
undo_redo
=
EditorInterface
.
get_editor_undo_redo
()
undo_redo
.
create_action
(
"Randomized Sprite2D Color"
)
undo_redo
.
add_do_property
(
self
,
&"self_modulate"
,
Color
(
randf
(),
randf
(),
randf
()))
undo_redo
.
add_undo_property
(
self
,
&"self_modulate"
,
self_modulate
)
undo_redo
.
commit_action
()
Copy to clipboard
Note:
The property is exported without the
@GlobalScope.PROPERTY_USAGE_STORAGE
flag because a
Callable
cannot be properly serialized and stored in a file.
Note:
In an exported project neither
EditorInterface
nor
EditorUndoRedoManager
exist, which may cause some scripts to break. To prevent this, you can use
Engine.get_singleton()
and omit the static type from the variable declaration:
var
undo_redo
=
Engine
.
get_singleton
(
&"EditorInterface"
)
.
get_editor_undo_redo
()
Copy to clipboard
Note:
Avoid storing lambda callables in member variables of
RefCounted
-based classes (e.g. resources), as this can lead to memory leaks. Use only method callables and optionally
Callable.bind()
or
Callable.unbind()
.
@icon
(icon_path:
String
)
🔗
Add a custom icon to the current script. The icon specified at
icon_path
is displayed in the Scene dock for every node of that class, as well as in various editor dialogs.
@icon
(
"res://path/to/class/icon.svg"
)
Copy to clipboard
Note:
Only the script can have a custom icon. Inner classes are not supported.
Note:
As annotations describe their subject, the
@icon
annotation must be placed before the class definition and inheritance.
Note:
Unlike most other annotations, the argument of the
@icon
annotation must be a string literal (constant expressions are not supported).
@onready
()
🔗
Mark the following property as assigned when the
Node
is ready. Values for these properties are not assigned immediately when the node is initialized (
Object._init()
), and instead are computed and stored right before
Node._ready()
.
@onready
var
character_name
=
$Label
Copy to clipboard
@rpc
(mode:
String
= "authority", sync:
String
= "call_remote", transfer_mode:
String
= "reliable", transfer_channel:
int
= 0)
🔗
Mark the following method for remote procedure calls. See
High-level multiplayer
.
If
mode
is set as
"any_peer"
, allows any peer to call this RPC function. Otherwise, only the authority peer is allowed to call it and
mode
should be kept as
"authority"
. When configuring functions as RPCs with
Node.rpc_config()
, each of these modes respectively corresponds to the
MultiplayerAPI.RPC_MODE_AUTHORITY
and
MultiplayerAPI.RPC_MODE_ANY_PEER
RPC modes. See
RPCMode
. If a peer that is not the authority tries to call a function that is only allowed for the authority, the function will not be executed. If the error can be detected locally (when the RPC configuration is consistent between the local and the remote peer), an error message will be displayed on the sender peer. Otherwise, the remote peer will detect the error and print an error there.
If
sync
is set as
"call_remote"
, the function will only be executed on the remote peer, but not locally. To run this function locally too, set
sync
to
"call_local"
. When configuring functions as RPCs with
Node.rpc_config()
, this is equivalent to setting
call_local
to
true
.
The
transfer_mode
accepted values are
"unreliable"
,
"unreliable_ordered"
, or
"reliable"
. It sets the transfer mode of the underlying
MultiplayerPeer
. See
MultiplayerPeer.transfer_mode
.
The
transfer_channel
defines the channel of the underlying
MultiplayerPeer
. See
MultiplayerPeer.transfer_channel
.
The order of
mode
,
sync
and
transfer_mode
does not matter, but values related to the same argument must not be used more than once.
transfer_channel
always has to be the 4th argument (you must specify 3 preceding arguments).
@rpc
func
fn
():
pass
@rpc
(
"any_peer"
,
"unreliable_ordered"
)
func
fn_update_pos
():
pass
@rpc
(
"authority"
,
"call_remote"
,
"reliable"
,
0
)
# Equivalent to @rpc
func
fn_default
():
pass
Copy to clipboard
Note:
Methods annotated with
@rpc
cannot receive objects which define required parameters in
Object._init()
. See
Object._init()
for more details.
@static_unload
()
🔗
Make a script with static variables to not persist after all references are lost. If the script is loaded again the static variables will revert to their default values.
Note:
As annotations describe their subject, the
@static_unload
annotation must be placed before the class definition and inheritance.
Warning:
Currently, due to a bug, scripts are never freed, even if
@static_unload
annotation is used.
@tool
()
🔗
Mark the current script as a tool script, allowing it to be loaded and executed by the editor. See
Running code in the editor
.
@tool
extends
Node
Copy to clipboard
Note:
As annotations describe their subject, the
@tool
annotation must be placed before the class definition and inheritance.
@warning_ignore
(warning:
String
, ...)
vararg
🔗
Mark the following statement to ignore the specified
warning
. See
GDScript warning system
.
func
test
():
print
(
"hello"
)
return
@warning_ignore
(
"unreachable_code"
)
print
(
"unreachable"
)
Copy to clipboard
See also
@warning_ignore_start
and
@warning_ignore_restore
.
@warning_ignore_restore
(warning:
String
, ...)
vararg
🔗
Stops ignoring the listed warning types after
@warning_ignore_start
. Ignoring the specified warning types will be reset to Project Settings. This annotation can be omitted to ignore the warning types until the end of the file.
Note:
Unlike most other annotations, arguments of the
@warning_ignore_restore
annotation must be string literals (constant expressions are not supported).
@warning_ignore_start
(warning:
String
, ...)
vararg
🔗
Starts ignoring the listed warning types until the end of the file or the
@warning_ignore_restore
annotation with the given warning type.
func
test
():
var
a
=
1
# Warning (if enabled in the Project Settings).
@warning_ignore_start
(
"unused_variable"
)
var
b
=
2
# No warning.
var
c
=
3
# No warning.
@warning_ignore_restore
(
"unused_variable"
)
var
d
=
4
# Warning (if enabled in the Project Settings).
Copy to clipboard
Note:
To suppress a single warning, use
@warning_ignore
instead.
Note:
Unlike most other annotations, arguments of the
@warning_ignore_start
annotation must be string literals (constant expressions are not supported).
Method Descriptions

Color
Color8
(r8:
int
, g8:
int
, b8:
int
, a8:
int
= 255)
🔗
Deprecated:
Use
Color.from_rgba8()
instead.
Returns a
Color
constructed from red (
r8
), green (
g8
), blue (
b8
), and optionally alpha (
a8
) integer channels, each divided by
255.0
for their final value. Using
Color8()
instead of the standard
Color
constructor is useful when you need to match exact color values in an
Image
.
var
red
=
Color8
(
255
,
0
,
0
)
# Same as Color(1, 0, 0).
var
dark_blue
=
Color8
(
0
,
0
,
51
)
# Same as Color(0, 0, 0.2).
var
my_color
=
Color8
(
306
,
255
,
0
,
102
)
# Same as Color(1.2, 1, 0, 0.4).
Copy to clipboard
Note:
Due to the lower precision of
Color8()
compared to the standard
Color
constructor, a color created with
Color8()
will generally not be equal to the same color created with the standard
Color
constructor. Use
Color.is_equal_approx()
for comparisons to avoid issues with floating-point precision error.
void
assert
(condition:
bool
, message:
String
= "")
🔗
Asserts that the
condition
is
true
. If the
condition
is
false
, an error is generated. When running from the editor, the running project will also be paused until you resume it. This can be used as a stronger form of
@GlobalScope.push_error()
for reporting errors to project developers or add-on users.
An optional
message
can be shown in addition to the generic "Assertion failed" message. You can use this to provide additional details about why the assertion failed.
Warning:
For performance reasons, the code inside
assert()
is only executed in debug builds or when running the project from the editor. Don't include code that has side effects in an
assert()
call. Otherwise, the project will behave differently when exported in release mode.
# Imagine we always want speed to be between 0 and 20.
var
speed
=
-
10
assert
(
speed
<
20
)
# True, the program will continue.
assert
(
speed
>=
0
)
# False, the program will stop.
assert
(
speed
>=
0
and
speed
<
20
)
# You can also combine the two conditional statements in one check.
assert
(
speed
<
20
,
"the speed limit is 20"
)
# Show a message.
Copy to clipboard
Note:
assert()
is a keyword, not a function. So you cannot access it as a
Callable
or use it inside expressions.
String
char
(code:
int
)
🔗
Returns a single character (as a
String
of length 1) of the given Unicode code point
code
.
print
(
char
(
65
))
# Prints "A"
print
(
char
(
129302
))
# Prints "🤖" (robot face emoji)
Copy to clipboard
This is the inverse of
ord()
. See also
String.chr()
and
String.unicode_at()
.
Variant
convert
(what:
Variant
, type:
Variant.Type
)
🔗
Deprecated:
Use
@GlobalScope.type_convert()
instead.
Converts
what
to
type
in the best way possible. The
type
uses the
Variant.Type
values.
var
a
=
[
4
,
2.5
,
1.2
]
print
(
a
is
Array
)
# Prints true
var
b
=
convert
(
a
,
TYPE_PACKED_BYTE_ARRAY
)
print
(
b
)
# Prints [4, 2, 1]
print
(
b
is
Array
)
# Prints false
Copy to clipboard
Object
dict_to_inst
(dictionary:
Dictionary
)
🔗
Deprecated:
Consider using
JSON.to_native()
or
Object.get_property_list()
instead.
Converts a
dictionary
(created with
inst_to_dict()
) back to an Object instance. Can be useful for deserializing.
Array
get_stack
()
🔗
Returns an array of dictionaries representing the current call stack.
func
_ready
():
foo
()
func
foo
():
bar
()
func
bar
():
print
(
get_stack
())
Copy to clipboard
Starting from
_ready()
,
bar()
would print:
[{function:bar, line:12, source:res://script.gd}, {function:foo, line:9, source:res://script.gd}, {function:_ready, line:6, source:res://script.gd}]
Copy to clipboard
See also
print_debug()
,
print_stack()
, and
Engine.capture_script_backtraces()
.
Note:
By default, backtraces are only available in editor builds and debug builds. To enable them for release builds as well, you need to enable
ProjectSettings.debug/settings/gdscript/always_track_call_stacks
.
Dictionary
inst_to_dict
(instance:
Object
)
🔗
Deprecated:
Consider using
JSON.from_native()
or
Object.get_property_list()
instead.
Returns the passed
instance
converted to a
Dictionary
. Can be useful for serializing.
var
foo
=
"bar"
func
_ready
():
var
d
=
inst_to_dict
(
self
)
print
(
d
.
keys
())
print
(
d
.
values
())
Copy to clipboard
Prints out:
[@subpath, @path, foo]
[, res://test.gd, bar]
Copy to clipboard
Note:
This function can only be used to serialize objects with an attached
GDScript
stored in a separate file. Objects without an attached script, with a script written in another language, or with a built-in script are not supported.
Note:
This function is not recursive, which means that nested objects will not be represented as dictionaries. Also, properties passed by reference (
Object
,
Dictionary
,
Array
, and packed arrays) are copied by reference, not duplicated.
bool
is_instance_of
(value:
Variant
, type:
Variant
)
🔗
Returns
true
if
value
is an instance of
type
. The
type
value must be one of the following:
A constant from the
Variant.Type
enumeration, for example
@GlobalScope.TYPE_INT
.
An
Object
-derived class which exists in
ClassDB
, for example
Node
.
A
Script
(you can use any class, including inner one).
Unlike the right operand of the
is
operator,
type
can be a non-constant value. The
is
operator supports more features (such as typed arrays). Use the operator instead of this method if you do not need to check the type dynamically.
Examples:
print
(
is_instance_of
(
a
,
TYPE_INT
))
print
(
is_instance_of
(
a
,
Node
))
print
(
is_instance_of
(
a
,
MyClass
))
print
(
is_instance_of
(
a
,
MyClass
.
InnerClass
))
Copy to clipboard
Note:
If
value
and/or
type
are freed objects (see
@GlobalScope.is_instance_valid()
), or
type
is not one of the above options, this method will raise a runtime error.
See also
@GlobalScope.typeof()
,
type_exists()
,
Array.is_same_typed()
(and other
Array
methods).
int
len
(var:
Variant
)
🔗
Returns the length of the given Variant
var
. The length can be the character count of a
String
or
StringName
, the element count of any array type, or the size of a
Dictionary
. For every other Variant type, a run-time error is generated and execution is stopped.
var
a
=
[
1
,
2
,
3
,
4
]
len
(
a
)
# Returns 4
var
b
=
"Hello!"
len
(
b
)
# Returns 6
Copy to clipboard
Resource
load
(path:
String
)
🔗
Returns a
Resource
from the filesystem located at the absolute
path
. Unless it's already referenced elsewhere (such as in another script or in the scene), the resource is loaded from disk on function call, which might cause a slight delay, especially when loading large scenes. To avoid unnecessary delays when loading something multiple times, either store the resource in a variable or use
preload()
. This method is equivalent of using
ResourceLoader.load()
with
ResourceLoader.CACHE_MODE_REUSE
.
Note:
Resource paths can be obtained by right-clicking on a resource in the FileSystem dock and choosing "Copy Path", or by dragging the file from the FileSystem dock into the current script.
# Load a scene called "main" located in the root of the project directory and cache it in a variable.
var
main
=
load
(
"res://main.tscn"
)
# main will contain a PackedScene resource.
Copy to clipboard
Important:
Relative paths are
not
relative to the script calling this method, instead it is prefixed with
"res://"
. Loading from relative paths might not work as expected.
This function is a simplified version of
ResourceLoader.load()
, which can be used for more advanced scenarios.
Note:
Files have to be imported into the engine first to load them using this function. If you want to load
Image
s at run-time, you may use
Image.load()
. If you want to import audio files, you can use the snippet described in
AudioStreamMP3.data
.
Note:
If
ProjectSettings.editor/export/convert_text_resources_to_binary
is
true
,
load()
will not be able to read converted files in an exported project. If you rely on run-time loading of files present within the PCK, set
ProjectSettings.editor/export/convert_text_resources_to_binary
to
false
.
int
ord
(char:
String
)
🔗
Returns an integer representing the Unicode code point of the given character
char
, which should be a string of length 1.
print
(
ord
(
"A"
))
# Prints 65
print
(
ord
(
"🤖"
))
# Prints 129302
Copy to clipboard
This is the inverse of
char()
. See also
String.chr()
and
String.unicode_at()
.
Resource
preload
(path:
String
)
🔗
Returns a
Resource
from the filesystem located at
path
. During run-time, the resource is loaded when the script is being parsed. This function effectively acts as a reference to that resource. Note that this function requires
path
to be a constant
String
. If you want to load a resource from a dynamic/variable path, use
load()
.
Note:
Resource paths can be obtained by right-clicking on a resource in the Assets Panel and choosing "Copy Path", or by dragging the file from the FileSystem dock into the current script.
# Create instance of a scene.
var
diamond
=
preload
(
"res://diamond.tscn"
)
.
instantiate
()
Copy to clipboard
Note:
preload()
is a keyword, not a function. So you cannot access it as a
Callable
.
void
print_debug
(...)
vararg
🔗
Like
@GlobalScope.print()
, but includes the current stack frame when running with the debugger turned on.
The output in the console may look like the following:
Test print
At: res://test.gd:15:_process()
Copy to clipboard
See also
print_stack()
,
get_stack()
, and
Engine.capture_script_backtraces()
.
Note:
By default, backtraces are only available in editor builds and debug builds. To enable them for release builds as well, you need to enable
ProjectSettings.debug/settings/gdscript/always_track_call_stacks
.
void
print_stack
()
🔗
Prints a stack trace at the current code location.
The output in the console may look like the following:
Frame 0 - res://test.gd:16 in function '_process'
Copy to clipboard
See also
print_debug()
,
get_stack()
, and
Engine.capture_script_backtraces()
.
Note:
By default, backtraces are only available in editor builds and debug builds. To enable them for release builds as well, you need to enable
ProjectSettings.debug/settings/gdscript/always_track_call_stacks
.
Array
range
(...)
vararg
🔗
Returns an array with the given range.
range()
can be called in three ways:
range(n:
int)
: Starts from 0, increases by steps of 1, and stops
before
n
. The argument
n
is
exclusive
.
range(b:
int,
n:
int)
: Starts from
b
, increases by steps of 1, and stops
before
n
. The arguments
b
and
n
are
inclusive
and
exclusive
, respectively.
range(b:
int,
n:
int,
s:
int)
: Starts from
b
, increases/decreases by steps of
s
, and stops
before
n
. The arguments
b
and
n
are
inclusive
and
exclusive
, respectively. The argument
s
can
be negative, but not
0
. If
s
is
0
, an error message is printed.
range()
converts all arguments to
int
before processing.
Note:
Returns an empty array if no value meets the value constraint (e.g.
range(2,
5,
-1)
or
range(5,
5,
1)
).
Examples:
print
(
range
(
4
))
# Prints [0, 1, 2, 3]
print
(
range
(
2
,
5
))
# Prints [2, 3, 4]
print
(
range
(
0
,
6
,
2
))
# Prints [0, 2, 4]
print
(
range
(
4
,
1
,
-
1
))
# Prints [4, 3, 2]
Copy to clipboard
To iterate over an
Array
backwards, use:
var
array
=
[
3
,
6
,
9
]
for
i
in
range
(
array
.
size
()
-
1
,
-
1
,
-
1
):
print
(
array
[
i
])
Copy to clipboard
Output:
9
6
3
Copy to clipboard
To iterate over
float
, convert them in the loop.
for
i
in
range
(
3
,
0
,
-
1
):
print
(
i
/
10.0
)
Copy to clipboard
Output:
0.3
0.2
0.1
Copy to clipboard
bool
type_exists
(type:
StringName
)
🔗
Returns
true
if the given
Object
-derived class exists in
ClassDB
. Note that
Variant
data types are not registered in
ClassDB
.
type_exists
(
"Sprite2D"
)
# Returns true
type_exists
(
"NonExistentClass"
)
# Returns false
Copy to clipboard
Previous
Next
User-contributed notes
Please read the
User-contributed notes policy
before submitting a comment.

Classification Response Finish Reason

stop

Classification Response Content

["docs_chunks", "api_mapping"]

Classification Response Reasoning Content

The user wants to classify the provided Markdown file into one or more target tables: "docs_chunks", "api_mapping", "label_prototypes".
The file is a Godot Engine documentation page for the `@GDScript` class.
It contains:
- Description
- Tutorials
- Methods (list of methods with signatures)
- Constants (PI, TAU, INF, NAN)
- Annotations (many `@export_*`, `@tool`, `@rpc`, etc.)
- Method Descriptions (detailed descriptions for each method)

This is clearly documentation content. It describes API methods, constants, and annotations for the `@GDScript` class.
Therefore, it should be classified as "docs_chunks" and "api_mapping".
Wait, the prompt says: "Valid values are: ["docs_chunks", "api_mapping", "label_prototypes"]"
Rules:
- Use [] only if the file is not useful documentation content.
- Use one or more valid table names when conversion is needed.
- Do not include explanations, markdown fences, or any text outside JSON.

Is it "docs_chunks"? Yes, it's a chunk of documentation.
Is it "api_mapping"? Yes, it maps API methods/constants/annotations to their descriptions.
I will output `["docs_chunks", "api_mapping"]`.

Let's double check the exact format. "Return exactly one JSON array."
So `["docs_chunks", "api_mapping"]` is correct.
No other text.
Done. 
Wait, should I include "label_prototypes"? Probably not, it's not about labels.
I'll stick with `["docs_chunks", "api_mapping"]`.
Checking rules: "Use one or more valid table names when conversion is needed."
The file is documentation, so it fits.
Output matches requirement.
Proceed. 
One minor point: sometimes these tasks expect just `["docs_chunks"]` or `["api_mapping"]`. Given it's a class reference page with methods and constants, `["docs_chunks", "api_mapping"]` is safe. I'll output exactly that.
Actually, the prompt says "Classify this Markdown into zero or more target tables."
I will return `["docs_chunks", "api_mapping"]`.
Done. 
Let's generate. 
Output: `["docs_chunks", "api_mapping"]`
Wait, is there any chance it's just `["docs_chunks"]`? The prompt says "Valid values are: ["docs_chunks", "api_mapping", "label_prototypes"]". I'll provide both as it contains API mapping info.
I'll just output `["docs_chunks", "api_mapping"]`.
Done. 
Final check of the prompt: "Return exactly one JSON array. Valid values are: ["docs_chunks", "api_mapping", "label_prototypes"]"
All good. 
Proceeds. 
Output matches. 
[Done] 
`["docs_chunks", "api_mapping"]`
Wait, let's think if "api_mapping" is appropriate. It maps method names to descriptions. Yes.
I will output `["docs_chunks", "api_mapping"]`.
No extra text.
Ready. 
Output Generation. 
`["docs_chunks", "api_mapping"]`
(Self-Correction/Refinement during thought)
Sometimes these classification tasks are strict. I'll just output `["docs_chunks", "api_mapping"]`. It's safe.
Actually, looking at similar tasks, `["docs_chunks"]` is often enough for documentation pages, but `api_mapping` is for API references. This is an API reference page. I'll stick with both.
Final: `["docs_chunks", "api_mapping"]`
Proceeds. 
Output matches requirement.
Done. 
[Output Generation] -> `["docs_chunks", "api_mapping"]`
Wait, the prompt says "Return only valid JSON. No markdown. No prose. No thinking text."
I will output exactly `["docs_chunks", "api_mapping"]`.
Done. 
(Self-Correction/Verification)
Could it be just `["docs_chunks"]`? The prompt says "Use one or more valid table names when conversion is needed." I'll provide both. It's fine.
Final Answer: `["docs_chunks", "api_mapping"]`
Proceeds. 
[Output] `["docs_chunks", "api_mapping"]`
Done. 
(Note: I'll make sure there are no backticks or markdown formatting around the JSON as requested: "No markdown.")
Result: `["docs_chunks", "api_mapping"]`
Done. 
[Final Check]
File content: Godot Engine 4.6 documentation for @GDScript class. Contains methods, constants, annotations, descriptions.
Tables: docs_chunks, api_mapping, label_prototypes.
Classification: docs_chunks, api_mapping.
JSON: ["docs_chunks", "api_mapping"]
Matches rules.
Proceeds. 
Output Generation. 
`["docs_chunks", "api_mapping"]`
Done. 
[Final Output Generation] (matches exactly)
`["docs_chunks", "api_mapping"]`
(No extra spaces or newlines)
Done. 
[Output]
["docs_chunks", "api_mapping"]

Raw Classification Response

{
  "finish_reason": "stop",
  "content": "[\"docs_chunks\", \"api_mapping\"]",
  "reasoning_content": "The user wants to classify the provided Markdown file into one or more target tables: \"docs_chunks\", \"api_mapping\", \"label_prototypes\".\nThe file is a Godot Engine documentation page for the `@GDScript` class.\nIt contains:\n- Description\n- Tutorials\n- Methods (list of methods with signatures)\n- Constants (PI, TAU, INF, NAN)\n- Annotations (many `@export_*`, `@tool`, `@rpc`, etc.)\n- Method Descriptions (detailed descriptions for each method)\n\nThis is clearly documentation content. It describes API methods, constants, and annotations for the `@GDScript` class.\nTherefore, it should be classified as \"docs_chunks\" and \"api_mapping\".\nWait, the prompt says: \"Valid values are: [\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]\"\nRules:\n- Use [] only if the file is not useful documentation content.\n- Use one or more valid table names when conversion is needed.\n- Do not include explanations, markdown fences, or any text outside JSON.\n\nIs it \"docs_chunks\"? Yes, it's a chunk of documentation.\nIs it \"api_mapping\"? Yes, it maps API methods/constants/annotations to their descriptions.\nI will output `[\"docs_chunks\", \"api_mapping\"]`.\n\nLet's double check the exact format. \"Return exactly one JSON array.\"\nSo `[\"docs_chunks\", \"api_mapping\"]` is correct.\nNo other text.\nDone. \nWait, should I include \"label_prototypes\"? Probably not, it's not about labels.\nI'll stick with `[\"docs_chunks\", \"api_mapping\"]`.\nChecking rules: \"Use one or more valid table names when conversion is needed.\"\nThe file is documentation, so it fits.\nOutput matches requirement.\nProceed. \nOne minor point: sometimes these tasks expect just `[\"docs_chunks\"]` or `[\"api_mapping\"]`. Given it's a class reference page with methods and constants, `[\"docs_chunks\", \"api_mapping\"]` is safe. I'll output exactly that.\nActually, the prompt says \"Classify this Markdown into zero or more target tables.\"\nI will return `[\"docs_chunks\", \"api_mapping\"]`.\nDone. \nLet's generate. \nOutput: `[\"docs_chunks\", \"api_mapping\"]`\nWait, is there any chance it's just `[\"docs_chunks\"]`? The prompt says \"Valid values are: [\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]\". I'll provide both as it contains API mapping info.\nI'll just output `[\"docs_chunks\", \"api_mapping\"]`.\nDone. \nFinal check of the prompt: \"Return exactly one JSON array. Valid values are: [\"docs_chunks\", \"api_mapping\", \"label_prototypes\"]\"\nAll good. \nProceeds. \nOutput matches. \n[Done] \n`[\"docs_chunks\", \"api_mapping\"]`\nWait, let's think if \"api_mapping\" is appropriate. It maps method names to descriptions. Yes.\nI will output `[\"docs_chunks\", \"api_mapping\"]`.\nNo extra text.\nReady. \nOutput Generation. \n`[\"docs_chunks\", \"api_mapping\"]`\n(Self-Correction/Refinement during thought)\nSometimes these classification tasks are strict. I'll just output `[\"docs_chunks\", \"api_mapping\"]`. It's safe.\nActually, looking at similar tasks, `[\"docs_chunks\"]` is often enough for documentation pages, but `api_mapping` is for API references. This is an API reference page. I'll stick with both.\nFinal: `[\"docs_chunks\", \"api_mapping\"]`\nProceeds. \nOutput matches requirement.\nDone. \n[Output Generation] -> `[\"docs_chunks\", \"api_mapping\"]`\nWait, the prompt says \"Return only valid JSON. No markdown. No prose. No thinking text.\"\nI will output exactly `[\"docs_chunks\", \"api_mapping\"]`.\nDone. \n(Self-Correction/Verification)\nCould it be just `[\"docs_chunks\"]`? The prompt says \"Use one or more valid table names when conversion is needed.\" I'll provide both. It's fine.\nFinal Answer: `[\"docs_chunks\", \"api_mapping\"]`\nProceeds. \n[Output] `[\"docs_chunks\", \"api_mapping\"]`\nDone. \n(Note: I'll make sure there are no backticks or markdown formatting around the JSON as requested: \"No markdown.\")\nResult: `[\"docs_chunks\", \"api_mapping\"]`\nDone. \n[Final Check]\nFile content: Godot Engine 4.6 documentation for @GDScript class. Contains methods, constants, annotations, descriptions.\nTables: docs_chunks, api_mapping, label_prototypes.\nClassification: docs_chunks, api_mapping.\nJSON: [\"docs_chunks\", \"api_mapping\"]\nMatches rules.\nProceeds. \nOutput Generation. \n`[\"docs_chunks\", \"api_mapping\"]`\nDone. \n[Final Output Generation] (matches exactly)\n`[\"docs_chunks\", \"api_mapping\"]`\n(No extra spaces or newlines)\nDone. \n[Output]\n[\"docs_chunks\", \"api_mapping\"]\n"
}

Conversion Debug

1. pages/about__complying_with_licenses__d36558dd.md::docs_chunks

stage: conversion
api_url: [redacted]
model: [redacted]
table: docs_chunks
markdown_length: 5417
prompt_length: 6944
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 193
  },
  {
    "role": "user",
    "content_length": 6944
  }
]

Full Conversion Prompt Sent To Qwen

Table: docs_chunks
Return a JSON array of documentation chunk records.
Required fields and exact rules:
  - chunk_id (str): MUST match regex ^godot-\w+:\S+. Use a deterministic value like godot-stable:pages/about__intro.md#section-0001. Never return chunk_0 or plain numeric IDs.
  - doc_version (str): docs version such as stable, latest, 4.6, or unknown.
  - source_url (str): original docs URL if known, otherwise empty string.
  - source_file (str): exact local markdown path provided by the caller.
  - source_sha256 (str): exact sha256 provided by the caller.
  - doc_type (str): exactly one of class_reference, tutorial, migration, engine_details, about, other. Never use article.
  - symbol (str): class/API symbol or empty string.
  - section_path (list[str]): heading hierarchy.
  - heading (str): section heading.
  - content (str): searchable body text.
  - code_blocks (list[str]): extracted code blocks.
  - language_tags (list[str]): detected code languages.
  - godot_version_tags (list[str]): version hints.
  - api_symbols (list[str]): detected Godot symbols.
  - token_count (int): estimated token count.
  - metadata (dict): any extra metadata.
Return only valid JSON. No markdown. No comments.

Target table: docs_chunks
Source file that MUST be written into source_file fields: pages/about__complying_with_licenses__d36558dd.md
Source sha256 that MUST be written into source_sha256 fields when the field exists: 2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3

--- MARKDOWN ---
# Source: https://docs.godotengine.org/en/stable/about/complying_with_licenses.html

Godot Engine 4.6 documentation in English
Complying with licenses
Edit on GitHub
Learn how to contribute!
Complying with licenses

Warning
The recommendations in this page
are not legal advice.
They are provided
in good faith to help users navigate license attribution requirements.
What are licenses?

Godot is created and distributed under the
MIT License
.
It doesn't have a sole owner, as every contributor that submits code to
the project does it under this same license and keeps ownership of their
contribution.
The license is the legal requirement for you (or your company) to use and
distribute the software (and derivative projects, including games made with it).
Your game or project can have a different license, but it still needs to comply
with the original one.
Note
This section covers compliance with licenses from a user perspective.
If you are interested in licence compliance as a contributor, you can find
guidelines
here
.
Tip
Alongside the Godot license text, remember to also list third-party notices
for assets you're using, such as textures, models, sounds, music and fonts.
This includes free assets, which often come with licenses that require
attribution.
Requirements

In the case of the MIT license, the only requirement is to include the license
text somewhere in your game or derivative project.
This text reads as follows:
This game uses Godot Engine, available under the following license:

Copyright (c) 2014-present Godot Engine contributors.
Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Copy to clipboard
Beside its own MIT license, Godot includes code from a number of third-party
libraries. See
Third-party licenses
for details.
Note
Your games do not need to be under the same license. You are free to release
your Godot projects under any license and to create commercial games with
the engine.
Inclusion

The license text must be made available to the user. The license doesn't specify
how the text has to be included, but here are the most common approaches (you
only need to implement one of them, not all).
Credits screen

Include the above license text somewhere in the credits screen. It can be at the
bottom after showing the rest of the credits. Most large studios use this
approach with open source licenses.
Licenses screen

Some games have a special menu (often in the settings) to display licenses.
This menu is typically accessed with a button called
Third-party Licenses
or
Open Source Licenses
.
Output log

Printing the license text using the
print()
function may be enough on platforms where a global output log is readable.
This is the case on desktop platforms, Android and HTML5 (but not iOS).
Accompanying file

If the game is distributed on desktop platforms, a file containing the license
text can be added to the software that is installed to the user PC.
Printed manual

If the game includes a printed manual, the license text can be included there.
Link to the license

The Godot Engine developers consider that a link to
godotengine.org/license
in your game documentation or credits would be an acceptable way to satisfy
the license terms.
Tip
Godot provides several methods to get license information in the
Engine
singleton. This allows you to source the
license information directly from the engine binary, which prevents the
information from becoming outdated if you update engine versions.
For the engine itself:
Engine.get_license_text
For third-party components used by the engine:
Engine.get_license_info
Engine.get_copyright_info
Third-party licenses

Godot itself contains software written by
third parties
,
which is compatible with, but not covered by Godot's MIT license.
Many of these dependencies are distributed under permissive open source licenses
which require attribution by explicitly citing their copyright statement and
license text in the final product's documentation.
Given the scope of the Godot project, this is fairly difficult to do thoroughly.
For the Godot editor, the full documentation of third-party copyrights and
licenses is provided in the
COPYRIGHT.txt
file.
A good option for end users to document third-party licenses is to include this
file in your project's distribution, which you can e.g. rename to
GODOT_COPYRIGHT.txt
to prevent any confusion with your own code and assets.
/no_think

Conversion Response Finish Reason

stop

Conversion Response Content

[
  {
    "chunk_id": "godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/complying_with_licenses.html",
    "source_file": "pages/about__complying_with_licenses__d36558dd.md",
    "source_sha256": "2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3",
    "doc_type": "about",
    "symbol": "",
    "section_path": ["Complying with licenses"],
    "heading": "Complying with licenses",
    "content": "Learn how to contribute! Complying with licenses Warning The recommendations in this page are not legal advice. They are provided in good faith to help users navigate license attribution requirements.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": ["4.6", "stable"],
    "api_symbols": [],
    "token_count": 65,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0002",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/complying_with_licenses.html",
    "source_file": "pages/about__complying_with_licenses__d36558dd.md",
    "source_sha256": "2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3",
    "doc_type": "about",
    "symbol": "",
    "section_path": ["Complying with licenses", "What are licenses?"],
    "heading": "What are licenses?",
    "content": "Godot is created and distributed under the MIT License. It doesn't have a sole owner, as every contributor that submits code to the project does it under this same license and keeps ownership of their contribution. The license is the legal requirement for you (or your company) to use and distribute the software (and derivative projects, including games made with it). Your game or project can have a different license, but it still needs to comply with the original one. Note This section covers compliance with licenses from a user perspective. If you are interested in licence compliance as a contributor, you can find guidelines here. Tip Alongside the Godot license text, remember to also list third-party notices for assets you're using, such as textures, models, sounds, music and fonts. This includes free assets, which often come with licenses that require attribution.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": ["4.6", "stable"],
    "api_symbols": [],
    "token_count": 115,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0003",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/complying_with_licenses.html",
    "source_file": "pages/about__complying_with_licenses__d36558dd.md",
    "source_sha256": "2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3",
    "doc_type": "about",
    "symbol": "",
    "section_path": ["Complying with licenses", "Requirements"],
    "heading": "Requirements",
    "content": "In the case of the MIT license, the only requirement is to include the license text somewhere in your game or derivative project. This text reads as follows: Beside its own MIT license, Godot includes code from a number of third-party libraries. See Third-party licenses for details. Note Your games do not need to be under the same license. You are free to release your Godot projects under any license and to create commercial games with the engine.",
    "code_blocks": [
      "This game uses Godot Engine, available under the following license:\n\nCopyright (c) 2014-present Godot Engine contributors.\nCopyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE."
    ],
    "language_tags": ["text"],
    "godot_version_tags": ["4.6", "stable"],
    "api_symbols": [],
    "token_count": 185,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0004",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/complying_with_licenses.html",
    "source_file": "pages/about__complying_with_licenses__d36558dd.md",
    "source_sha256": "2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3",
    "doc_type": "about",
    "symbol": "",
    "section_path": ["Complying with licenses", "Inclusion"],
    "heading": "Inclusion",
    "content": "The license text must be made available to the user. The license doesn't specify how the text has to be included, but here are the most common approaches (you only need to implement one of them, not all).",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": ["4.6", "stable"],
    "api_symbols": [],
    "token_count": 45,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0005",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/complying_with_licenses.html",
    "source_file": "pages/about__complying_with_licenses__d36558dd.md",
    "source_sha256": "2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3",
    "doc_type": "about",
    "symbol": "",
    "section_path": ["Complying with licenses", "Inclusion", "Credits screen"],
    "heading": "Credits screen",
    "content": "Include the above license text somewhere in the credits screen. It can be at the bottom after showing the rest of the credits. Most large studios use this approach with open source licenses.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": ["4.6", "stable"],
    "api_symbols": [],
    "token_count": 35,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0006",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/complying_with_licenses.html",
    "source_file": "pages/about__complying_with_licenses__d36558dd.md",
    "source_sha256": "2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3",
    "doc_type": "about",
    "symbol": "",
    "section_path": ["Complying with licenses", "Inclusion", "Licenses screen"],
    "heading": "Licenses screen",
    "content": "Some games have a special menu (often in the settings) to display licenses. This menu is typically accessed with a button called Third-party Licenses or Open Source Licenses.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": ["4.6", "stable"],
    "api_symbols": [],
    "token_count": 35,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0007",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/complying_with_licenses.html",
    "source_file": "pages/about__complying_with_licenses__d36558dd.md",
    "source_sha256": "2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3",
    "doc_type": "about",
    "symbol": "",
    "section_path": ["Complying with licenses", "Inclusion", "Output log"],
    "heading": "Output log",
    "content": "Printing the license text using the print() function may be enough on platforms where a global output log is readable. This is the case on desktop platforms, Android and HTML5 (but not iOS).",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": ["4.6", "stable"],
    "api_symbols": ["print"],
    "token_count": 35,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0008",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/complying_with_licenses.html",
    "source_file": "pages/about__complying_with_licenses__d36558dd.md",
    "source_sha256": "2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3",
    "doc_type": "about",
    "symbol": "",
    "section_path": ["Complying with licenses", "Inclusion", "Accompanying file"],
    "heading": "Accompanying file",
    "content": "If the game is distributed on desktop platforms, a file containing the license text can be added to the software that is installed to the user PC.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": ["4.6", "stable"],
    "api_symbols": [],
    "token_count": 30,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0009",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/complying_with_licenses.html",
    "source_file": "pages/about__complying_with_licenses__d36558dd.md",
    "source_sha256": "2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3",
    "doc_type": "about",
    "symbol": "",
    "section_path": ["Complying with licenses", "Inclusion", "Printed manual"],
    "heading": "Printed manual",
    "content": "If the game includes a printed manual, the license text can be included there.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": ["4.6", "stable"],
    "api_symbols": [],
    "token_count": 25,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0010",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/complying_with_licenses.html",
    "source_file": "pages/about__complying_with_licenses__d36558dd.md",
    "source_sha256": "2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3",
    "doc_type": "about",
    "symbol": "",
    "section_path": ["Complying with licenses", "Inclusion", "Link to the license"],
    "heading": "Link to the license",
    "content": "The Godot Engine developers consider that a link to godotengine.org/license in your game documentation or credits would be an acceptable way to satisfy the license terms. Tip Godot provides several methods to get license information in the Engine singleton. This allows you to source the license information directly from the engine binary, which prevents the information from becoming outdated if you update engine versions. For the engine itself: Engine.get_license_text For third-party components used by the engine: Engine.get_license_info Engine.get_copyright_info",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": ["4.6", "stable"],
    "api_symbols": ["Engine.get_license_text", "Engine.get_license_info", "Engine.get_copyright_info"],
    "token_count": 95,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0011",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/complying_with_licenses.html",
    "source_file": "pages/about__complying_with_licenses__d36558dd.md",
    "source_sha256": "2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3",
    "doc_type": "about",
    "symbol": "",
    "section_path": ["Complying with licenses", "Third-party licenses"],
    "heading": "Third-party licenses",
    "content": "Godot itself contains software written by third parties, which is compatible with, but not covered by Godot's MIT license. Many of these dependencies are distributed under permissive open source licenses which require attribution by explicitly citing their copyright statement and license text in the final product's documentation. Given the scope of the Godot project, this is fairly difficult to do thoroughly. For the Godot editor, the full documentation of third-party copyrights and licenses is provided in the COPYRIGHT.txt file. A good option for end users to document third-party licenses is to include this file in your project's distribution, which you can e.g. rename to GODOT_COPYRIGHT.txt to prevent any confusion with your own code and assets.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": ["4.6", "stable"],
    "api_symbols": [],
    "token_count": 115,
    "metadata": {}
  }
]

Conversion Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Table:** `docs_chunks`
   - **Required Fields:** `chunk_id`, `doc_version`, `source_url`, `source_file`, `source_sha256`, `doc_type`, `symbol`, `section_path`, `heading`, `content`, `code_blocks`, `language_tags`, `godot_version_tags`, `api_symbols`, `token_count`, `metadata`
   - **Rules:**
     - `chunk_id`: Must match `^godot-\w+:\S+`. Use deterministic like `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001`. Never `chunk_0` or plain numeric.
     - `doc_version`: e.g., `stable`, `latest`, `4.6`, `unknown`.
     - `source_url`: original docs URL if known, else `""`.
     - `source_file`: MUST be `pages/about__complying_with_licenses__d36558dd.md`
     - `source_sha256`: MUST be `2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3`
     - `doc_type`: exactly one of `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. Never `article`.
     - `symbol`: class/API symbol or `""`.
     - `section_path`: list[str] heading hierarchy.
     - `heading`: section heading.
     - `content`: searchable body text.
     - `code_blocks`: list[str] extracted code blocks.
     - `language_tags`: list[str] detected code languages.
     - `godot_version_tags`: list[str] version hints.
     - `api_symbols`: list[str] detected Godot symbols.
     - `token_count`: int estimated token count.
     - `metadata`: dict extra metadata.
   - **Input Markdown:** A single page about "Complying with licenses" from Godot docs. Contains sections: "What are licenses?", "Requirements", "Inclusion", "Credits screen", "Licenses screen", "Output log", "Accompanying file", "Printed manual", "Link to the license", "Third-party licenses". Contains a code block (the MIT license text). Mentions `Engine.get_license_text`, `Engine.get_license_info`, `Engine.get_copyright_info`. Version mentioned: 4.6, stable.
   - **Output Format:** JSON array of records. No markdown fences. No comments.

2.  **Determine Chunking Strategy:**
   The prompt asks for "documentation chunk records". I should split the markdown into logical chunks based on headings. I'll create one record per major section to keep it manageable, or maybe just one record for the whole page if it's short, but splitting by headings is usually better for RAG. Let's split by the main headings provided in the markdown.
   Headings found:
   - Complying with licenses (Title)
   - What are licenses?
   - Requirements
   - Inclusion
   - Credits screen
   - Licenses screen
   - Output log
   - Accompanying file
   - Printed manual
   - Link to the license
   - Third-party licenses

   I'll create chunks for each section. I need to ensure `chunk_id` matches the regex. I'll use `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001`, etc.
   `doc_version`: `stable` (from URL `en/stable/`)
   `source_url`: `https://docs.godotengine.org/en/stable/about/complying_with_licenses.html`
   `source_file`: `pages/about__complying_with_licenses__d36558dd.md`
   `source_sha256`: `2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3`
   `doc_type`: `about` (fits best)
   `symbol`: `""` (it's a general docs page, not a class ref)
   `section_path`: array of headings leading to this section.
   `heading`: current section heading.
   `content`: text of the section.
   `code_blocks`: extract the MIT license block.
   `language_tags`: `["text"]` or `["license"]` or `[""]`. I'll use `["text"]`.
   `godot_version_tags`: `["4.6", "stable"]`
   `api_symbols`: `["Engine.get_license_text", "Engine.get_license_info", "Engine.get_copyright_info"]`
   `token_count`: estimate ~150-300 per chunk. I'll put a reasonable number like 200.
   `metadata`: `{}` or some extra info.

   Let's structure the chunks carefully. I'll make one chunk per major section to keep it clean. Actually, the prompt says "Return a JSON array of documentation chunk records." It doesn't specify how many. I'll generate one record per logical section found in the markdown.

   Sections to process:
   1. Complying with licenses (Intro/Warning/Note/Tip)
   2. What are licenses?
   3. Requirements
   4. Inclusion
   5. Credits screen
   6. Licenses screen
   7. Output log
   8. Accompanying file
   9. Printed manual
   10. Link to the license
   11. Third-party licenses

   Wait, the markdown has a code block under "Requirements". I'll attach it to that chunk or the first one. I'll put it in the "Requirements" chunk.
   I'll extract the exact text for each chunk.

   Let's draft the JSON records.

   **Chunk 1:**
   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001`
   - heading: `Complying with licenses`
   - section_path: `["Complying with licenses"]`
   - content: `Learn how to contribute! Complying with licenses Warning The recommendations in this page are not legal advice. They are provided in good faith to help users navigate license attribution requirements.`
   - code_blocks: `[]`
   - language_tags: `[]`
   - api_symbols: `[]`
   - token_count: 60
   - metadata: `{}`

   **Chunk 2:**
   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0002`
   - heading: `What are licenses?`
   - section_path: `["Complying with licenses", "What are licenses?"]`
   - content: `Godot is created and distributed under the MIT License. It doesn't have a sole owner, as every contributor that submits code to the project does it under this same license and keeps ownership of their contribution. The license is the legal requirement for you (or your company) to use and distribute the software (and derivative projects, including games made with it). Your game or project can have a different license, but it still needs to comply with the original one. Note This section covers compliance with licenses from a user perspective. If you are interested in licence compliance as a contributor, you can find guidelines here. Tip Alongside the Godot license text, remember to also list third-party notices for assets you're using, such as textures, models, sounds, music and fonts. This includes free assets, which often come with licenses that require attribution.`
   - code_blocks: `[]`
   - language_tags: `[]`
   - api_symbols: `[]`
   - token_count: 110
   - metadata: `{}`

   **Chunk 3:**
   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0003`
   - heading: `Requirements`
   - section_path: `["Complying with licenses", "Requirements"]`
   - content: `In the case of the MIT license, the only requirement is to include the license text somewhere in your game or derivative project. This text reads as follows: [License Text] Beside its own MIT license, Godot includes code from a number of third-party libraries. See Third-party licenses for details. Note Your games do not need to be under the same license. You are free to release your Godot projects under any license and to create commercial games with the engine.`
   - code_blocks: `[ "This game uses Godot Engine, available under the following license:\n\nCopyright (c) 2014-present Godot Engine contributors.\nCopyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE." ]`
   - language_tags: `["text"]`
   - api_symbols: `[]`
   - token_count: 180
   - metadata: `{}`

   **Chunk 4:**
   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0004`
   - heading: `Inclusion`
   - section_path: `["Complying with licenses", "Inclusion"]`
   - content: `The license text must be made available to the user. The license doesn't specify how the text has to be included, but here are the most common approaches (you only need to implement one of them, not all).`
   - code_blocks: `[]`
   - language_tags: `[]`
   - api_symbols: `[]`
   - token_count: 45
   - metadata: `{}`

   **Chunk 5:**
   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0005`
   - heading: `Credits screen`
   - section_path: `["Complying with licenses", "Inclusion", "Credits screen"]`
   - content: `Include the above license text somewhere in the credits screen. It can be at the bottom after showing the rest of the credits. Most large studios use this approach with open source licenses.`
   - code_blocks: `[]`
   - language_tags: `[]`
   - api_symbols: `[]`
   - token_count: 35
   - metadata: `{}`

   **Chunk 6:**
   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0006`
   - heading: `Licenses screen`
   - section_path: `["Complying with licenses", "Inclusion", "Licenses screen"]`
   - content: `Some games have a special menu (often in the settings) to display licenses. This menu is typically accessed with a button called Third-party Licenses or Open Source Licenses.`
   - code_blocks: `[]`
   - language_tags: `[]`
   - api_symbols: `[]`
   - token_count: 35
   - metadata: `{}`

   **Chunk 7:**
   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0007`
   - heading: `Output log`
   - section_path: `["Complying with licenses", "Inclusion", "Output log"]`
   - content: `Printing the license text using the print() function may be enough on platforms where a global output log is readable. This is the case on desktop platforms, Android and HTML5 (but not iOS).`
   - code_blocks: `[]`
   - language_tags: `[]`
   - api_symbols: `["print"]`
   - token_count: 35
   - metadata: `{}`

   **Chunk 8:**
   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0008`
   - heading: `Accompanying file`
   - section_path: `["Complying with licenses", "Inclusion", "Accompanying file"]`
   - content: `If the game is distributed on desktop platforms, a file containing the license text can be added to the software that is installed to the user PC.`
   - code_blocks: `[]`
   - language_tags: `[]`
   - api_symbols: `[]`
   - token_count: 30
   - metadata: `{}`

   **Chunk 9:**
   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0009`
   - heading: `Printed manual`
   - section_path: `["Complying with licenses", "Inclusion", "Printed manual"]`
   - content: `If the game includes a printed manual, the license text can be included there.`
   - code_blocks: `[]`
   - language_tags: `[]`
   - api_symbols: `[]`
   - token_count: 25
   - metadata: `{}`

   **Chunk 10:**
   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0010`
   - heading: `Link to the license`
   - section_path: `["Complying with licenses", "Inclusion", "Link to the license"]`
   - content: `The Godot Engine developers consider that a link to godotengine.org/license in your game documentation or credits would be an acceptable way to satisfy the license terms. Tip Godot provides several methods to get license information in the Engine singleton. This allows you to source the license information directly from the engine binary, which prevents the information from becoming outdated if you update engine versions. For the engine itself: Engine.get_license_text For third-party components used by the engine: Engine.get_license_info Engine.get_copyright_info`
   - code_blocks: `[]`
   - language_tags: `[]`
   - api_symbols: `["Engine.get_license_text", "Engine.get_license_info", "Engine.get_copyright_info"]`
   - token_count: 90
   - metadata: `{}`

   **Chunk 11:**
   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0011`
   - heading: `Third-party licenses`
   - section_path: `["Complying with licenses", "Third-party licenses"]`
   - content: `Godot itself contains software written by third parties, which is compatible with, but not covered by Godot's MIT license. Many of these dependencies are distributed under permissive open source licenses which require attribution by explicitly citing their copyright statement and license text in the final product's documentation. Given the scope of the Godot project, this is fairly difficult to do thoroughly. For the Godot editor, the full documentation of third-party copyrights and licenses is provided in the COPYRIGHT.txt file. A good option for end users to document third-party licenses is to include this file in your project's distribution, which you can e.g. rename to GODOT_COPYRIGHT.txt to prevent any confusion with your own code and assets.`
   - code_blocks: `[]`
   - language_tags: `[]`
   - api_symbols: `[]`
   - token_count: 110
   - metadata: `{}`

   Check constraints:
   - `chunk_id` matches `^godot-\w+:\S+` -> `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001` etc. Matches.
   - `doc_version`: `stable`
   - `source_url`: `https://docs.godotengine.org/en/stable/about/complying_with_licenses.html`
   - `source_file`: `pages/about__complying_with_licenses__d36558dd.md`
   - `source_sha256`: `2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3`
   - `doc_type`: `about`
   - `symbol`: `""`
   - `section_path`: list of strings
   - `heading`: string
   - `content`: string
   - `code_blocks`: list of strings
   - `language_tags`: list of strings
   - `godot_version_tags`: list of strings -> `["4.6", "stable"]` for all, or maybe just `["stable"]`. I'll add `["4.6", "stable"]` to all or just the first. I'll put it in all for consistency, or leave empty if not explicitly in text. The text says "Godot Engine 4.6 documentation in English". I'll add `["4.6", "stable"]` to `godot_version_tags`.
   - `api_symbols`: list of strings
   - `token_count`: int
   - `metadata`: dict

   I will construct the JSON array carefully. I'll make sure all fields are present. I'll double-check the regex for chunk_id: `^godot-\w+:\S+`. `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001` matches.
   I'll ensure no markdown formatting in the output.
   I'll verify the exact source file and sha256 are used.
   I'll verify `doc_type` is exactly one of the allowed values. `about` is allowed.
   I'll verify `symbol` is empty string.
   I'll verify `section_path` is a list of strings.
   I'll verify `code_blocks` contains the exact license text.
   I'll verify `language_tags` contains `["text"]` or `["license"]`. I'll use `["text"]`.
   I'll verify `godot_version_tags` contains `["4.6", "stable"]`.
   I'll verify `api_symbols` contains the engine methods.
   I'll verify `token_count` is an integer.
   I'll verify `metadata` is a dict.

   One minor thing: The prompt says "Return a JSON array of documentation chunk records." It doesn't specify how many chunks. I'll stick with the section-based chunks. It's standard.
   I will format the JSON carefully.
   Let's assemble. 
   I'll make sure to escape quotes in the license text properly for JSON.
   I'll check the exact text for the license block to ensure it matches.
   "This game uses Godot Engine, available under the following license:\n\nCopyright (c) 2014-present Godot Engine contributors.\nCopyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE."
   This matches.

   All fields look good. I will generate the JSON now.
   One detail: `godot_version_tags` should probably be `["4.6", "stable"]` for each chunk, or I can just put it in the first one. I'll put it in all for consistency, or leave it as `["4.6", "stable"]` in all. It's fine.
   I'll ensure `doc_type` is `about`.
   I'll ensure `symbol` is `""`.
   I'll ensure `section_path` is correct.
   I'll ensure `heading` matches exactly.
   I'll ensure `content` is clean text.
   I'll ensure `code_blocks` is a list of strings.
   I'll ensure `language_tags` is a list of strings.
   I'll ensure `api_symbols` is a list of strings.
   I'll ensure `token_count` is int.
   I'll ensure `metadata` is dict.

   Ready. Output matches requirements. No markdown fences. Just JSON array.
   I will produce it now. 
   Self-Correction/Refinement during thought: 
   The prompt says "Never return chunk_0 or plain numeric IDs." My IDs are `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001`, etc. This matches `^godot-\w+:\S+`.
   I'll make sure the JSON is strictly valid.
   I'll combine everything into a single JSON array.
   All good.
   Output generation. 
   [Proceeds] 
   *Self-Correction/Verification during generation prep*:
   Check `doc_type` allowed values: `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. `about` is correct.
   Check `source_file`: `pages/about__complying_with_licenses__d36558dd.md` (exact match)
   Check `source_sha256`: `2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3` (exact match)
   Check `chunk_id` regex: `^godot-\w+:\S+` -> `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001` matches.
   All constraints met.
   I will output the JSON array now. 
   Note: I'll make sure to escape newlines in the license block properly for JSON.
   I'll produce the exact JSON.✅
   Output matches. 
   [Done] 
   *Output Generation* (matches the final JSON)
   ```json
   [
     { ... },
     ...
   ]
   ```
   No markdown fences. Just raw JSON.
   Proceeds. 
   [Output Generation] -> *See response.* 
   *(Self-Correction/Note during thought)*: I should verify that `section_path` is a list of strings representing the heading hierarchy. For the first chunk, it's `["Complying with licenses"]`. For the second, `["Complying with licenses", "What are licenses?"]`, etc. This is correct.
   I will ensure all fields are present in every record.
   All good. 
   Output matches request.✅
   [Final Check of the Prompt]: "Return ONLY a JSON array — no markdown code fences, no explanation. /no_think"
   I will output raw JSON.
   Proceeds. 
   [Output Generation] -> *Proceeds*

Raw Conversion Response

{
  "finish_reason": "stop",
  "content": "[\n  {\n    \"chunk_id\": \"godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/complying_with_licenses.html\",\n    \"source_file\": \"pages/about__complying_with_licenses__d36558dd.md\",\n    \"source_sha256\": \"2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\"Complying with licenses\"],\n    \"heading\": \"Complying with licenses\",\n    \"content\": \"Learn how to contribute! Complying with licenses Warning The recommendations in this page are not legal advice. They are provided in good faith to help users navigate license attribution requirements.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\"4.6\", \"stable\"],\n    \"api_symbols\": [],\n    \"token_count\": 65,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0002\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/complying_with_licenses.html\",\n    \"source_file\": \"pages/about__complying_with_licenses__d36558dd.md\",\n    \"source_sha256\": \"2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\"Complying with licenses\", \"What are licenses?\"],\n    \"heading\": \"What are licenses?\",\n    \"content\": \"Godot is created and distributed under the MIT License. It doesn't have a sole owner, as every contributor that submits code to the project does it under this same license and keeps ownership of their contribution. The license is the legal requirement for you (or your company) to use and distribute the software (and derivative projects, including games made with it). Your game or project can have a different license, but it still needs to comply with the original one. Note This section covers compliance with licenses from a user perspective. If you are interested in licence compliance as a contributor, you can find guidelines here. Tip Alongside the Godot license text, remember to also list third-party notices for assets you're using, such as textures, models, sounds, music and fonts. This includes free assets, which often come with licenses that require attribution.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\"4.6\", \"stable\"],\n    \"api_symbols\": [],\n    \"token_count\": 115,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0003\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/complying_with_licenses.html\",\n    \"source_file\": \"pages/about__complying_with_licenses__d36558dd.md\",\n    \"source_sha256\": \"2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\"Complying with licenses\", \"Requirements\"],\n    \"heading\": \"Requirements\",\n    \"content\": \"In the case of the MIT license, the only requirement is to include the license text somewhere in your game or derivative project. This text reads as follows: Beside its own MIT license, Godot includes code from a number of third-party libraries. See Third-party licenses for details. Note Your games do not need to be under the same license. You are free to release your Godot projects under any license and to create commercial games with the engine.\",\n    \"code_blocks\": [\n      \"This game uses Godot Engine, available under the following license:\\n\\nCopyright (c) 2014-present Godot Engine contributors.\\nCopyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.\\n\\nPermission is hereby granted, free of charge, to any person obtaining a copy\\nof this software and associated documentation files (the \\\"Software\\\"), to deal\\nin the Software without restriction, including without limitation the rights\\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\ncopies of the Software, and to permit persons to whom the Software is\\nfurnished to do so, subject to the following conditions:\\n\\nThe above copyright notice and this permission notice shall be included in all\\ncopies or substantial portions of the Software.\\n\\nTHE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\nSOFTWARE.\"\n    ],\n    \"language_tags\": [\"text\"],\n    \"godot_version_tags\": [\"4.6\", \"stable\"],\n    \"api_symbols\": [],\n    \"token_count\": 185,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0004\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/complying_with_licenses.html\",\n    \"source_file\": \"pages/about__complying_with_licenses__d36558dd.md\",\n    \"source_sha256\": \"2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\"Complying with licenses\", \"Inclusion\"],\n    \"heading\": \"Inclusion\",\n    \"content\": \"The license text must be made available to the user. The license doesn't specify how the text has to be included, but here are the most common approaches (you only need to implement one of them, not all).\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\"4.6\", \"stable\"],\n    \"api_symbols\": [],\n    \"token_count\": 45,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0005\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/complying_with_licenses.html\",\n    \"source_file\": \"pages/about__complying_with_licenses__d36558dd.md\",\n    \"source_sha256\": \"2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\"Complying with licenses\", \"Inclusion\", \"Credits screen\"],\n    \"heading\": \"Credits screen\",\n    \"content\": \"Include the above license text somewhere in the credits screen. It can be at the bottom after showing the rest of the credits. Most large studios use this approach with open source licenses.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\"4.6\", \"stable\"],\n    \"api_symbols\": [],\n    \"token_count\": 35,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0006\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/complying_with_licenses.html\",\n    \"source_file\": \"pages/about__complying_with_licenses__d36558dd.md\",\n    \"source_sha256\": \"2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\"Complying with licenses\", \"Inclusion\", \"Licenses screen\"],\n    \"heading\": \"Licenses screen\",\n    \"content\": \"Some games have a special menu (often in the settings) to display licenses. This menu is typically accessed with a button called Third-party Licenses or Open Source Licenses.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\"4.6\", \"stable\"],\n    \"api_symbols\": [],\n    \"token_count\": 35,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0007\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/complying_with_licenses.html\",\n    \"source_file\": \"pages/about__complying_with_licenses__d36558dd.md\",\n    \"source_sha256\": \"2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\"Complying with licenses\", \"Inclusion\", \"Output log\"],\n    \"heading\": \"Output log\",\n    \"content\": \"Printing the license text using the print() function may be enough on platforms where a global output log is readable. This is the case on desktop platforms, Android and HTML5 (but not iOS).\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\"4.6\", \"stable\"],\n    \"api_symbols\": [\"print\"],\n    \"token_count\": 35,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0008\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/complying_with_licenses.html\",\n    \"source_file\": \"pages/about__complying_with_licenses__d36558dd.md\",\n    \"source_sha256\": \"2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\"Complying with licenses\", \"Inclusion\", \"Accompanying file\"],\n    \"heading\": \"Accompanying file\",\n    \"content\": \"If the game is distributed on desktop platforms, a file containing the license text can be added to the software that is installed to the user PC.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\"4.6\", \"stable\"],\n    \"api_symbols\": [],\n    \"token_count\": 30,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0009\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/complying_with_licenses.html\",\n    \"source_file\": \"pages/about__complying_with_licenses__d36558dd.md\",\n    \"source_sha256\": \"2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\"Complying with licenses\", \"Inclusion\", \"Printed manual\"],\n    \"heading\": \"Printed manual\",\n    \"content\": \"If the game includes a printed manual, the license text can be included there.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\"4.6\", \"stable\"],\n    \"api_symbols\": [],\n    \"token_count\": 25,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0010\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/complying_with_licenses.html\",\n    \"source_file\": \"pages/about__complying_with_licenses__d36558dd.md\",\n    \"source_sha256\": \"2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\"Complying with licenses\", \"Inclusion\", \"Link to the license\"],\n    \"heading\": \"Link to the license\",\n    \"content\": \"The Godot Engine developers consider that a link to godotengine.org/license in your game documentation or credits would be an acceptable way to satisfy the license terms. Tip Godot provides several methods to get license information in the Engine singleton. This allows you to source the license information directly from the engine binary, which prevents the information from becoming outdated if you update engine versions. For the engine itself: Engine.get_license_text For third-party components used by the engine: Engine.get_license_info Engine.get_copyright_info\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\"4.6\", \"stable\"],\n    \"api_symbols\": [\"Engine.get_license_text\", \"Engine.get_license_info\", \"Engine.get_copyright_info\"],\n    \"token_count\": 95,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0011\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/complying_with_licenses.html\",\n    \"source_file\": \"pages/about__complying_with_licenses__d36558dd.md\",\n    \"source_sha256\": \"2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\"Complying with licenses\", \"Third-party licenses\"],\n    \"heading\": \"Third-party licenses\",\n    \"content\": \"Godot itself contains software written by third parties, which is compatible with, but not covered by Godot's MIT license. Many of these dependencies are distributed under permissive open source licenses which require attribution by explicitly citing their copyright statement and license text in the final product's documentation. Given the scope of the Godot project, this is fairly difficult to do thoroughly. For the Godot editor, the full documentation of third-party copyrights and licenses is provided in the COPYRIGHT.txt file. A good option for end users to document third-party licenses is to include this file in your project's distribution, which you can e.g. rename to GODOT_COPYRIGHT.txt to prevent any confusion with your own code and assets.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\"4.6\", \"stable\"],\n    \"api_symbols\": [],\n    \"token_count\": 115,\n    \"metadata\": {}\n  }\n]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Table:** `docs_chunks`\n   - **Required Fields:** `chunk_id`, `doc_version`, `source_url`, `source_file`, `source_sha256`, `doc_type`, `symbol`, `section_path`, `heading`, `content`, `code_blocks`, `language_tags`, `godot_version_tags`, `api_symbols`, `token_count`, `metadata`\n   - **Rules:**\n     - `chunk_id`: Must match `^godot-\\w+:\\S+`. Use deterministic like `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001`. Never `chunk_0` or plain numeric.\n     - `doc_version`: e.g., `stable`, `latest`, `4.6`, `unknown`.\n     - `source_url`: original docs URL if known, else `\"\"`.\n     - `source_file`: MUST be `pages/about__complying_with_licenses__d36558dd.md`\n     - `source_sha256`: MUST be `2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3`\n     - `doc_type`: exactly one of `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. Never `article`.\n     - `symbol`: class/API symbol or `\"\"`.\n     - `section_path`: list[str] heading hierarchy.\n     - `heading`: section heading.\n     - `content`: searchable body text.\n     - `code_blocks`: list[str] extracted code blocks.\n     - `language_tags`: list[str] detected code languages.\n     - `godot_version_tags`: list[str] version hints.\n     - `api_symbols`: list[str] detected Godot symbols.\n     - `token_count`: int estimated token count.\n     - `metadata`: dict extra metadata.\n   - **Input Markdown:** A single page about \"Complying with licenses\" from Godot docs. Contains sections: \"What are licenses?\", \"Requirements\", \"Inclusion\", \"Credits screen\", \"Licenses screen\", \"Output log\", \"Accompanying file\", \"Printed manual\", \"Link to the license\", \"Third-party licenses\". Contains a code block (the MIT license text). Mentions `Engine.get_license_text`, `Engine.get_license_info`, `Engine.get_copyright_info`. Version mentioned: 4.6, stable.\n   - **Output Format:** JSON array of records. No markdown fences. No comments.\n\n2.  **Determine Chunking Strategy:**\n   The prompt asks for \"documentation chunk records\". I should split the markdown into logical chunks based on headings. I'll create one record per major section to keep it manageable, or maybe just one record for the whole page if it's short, but splitting by headings is usually better for RAG. Let's split by the main headings provided in the markdown.\n   Headings found:\n   - Complying with licenses (Title)\n   - What are licenses?\n   - Requirements\n   - Inclusion\n   - Credits screen\n   - Licenses screen\n   - Output log\n   - Accompanying file\n   - Printed manual\n   - Link to the license\n   - Third-party licenses\n\n   I'll create chunks for each section. I need to ensure `chunk_id` matches the regex. I'll use `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001`, etc.\n   `doc_version`: `stable` (from URL `en/stable/`)\n   `source_url`: `https://docs.godotengine.org/en/stable/about/complying_with_licenses.html`\n   `source_file`: `pages/about__complying_with_licenses__d36558dd.md`\n   `source_sha256`: `2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3`\n   `doc_type`: `about` (fits best)\n   `symbol`: `\"\"` (it's a general docs page, not a class ref)\n   `section_path`: array of headings leading to this section.\n   `heading`: current section heading.\n   `content`: text of the section.\n   `code_blocks`: extract the MIT license block.\n   `language_tags`: `[\"text\"]` or `[\"license\"]` or `[\"\"]`. I'll use `[\"text\"]`.\n   `godot_version_tags`: `[\"4.6\", \"stable\"]`\n   `api_symbols`: `[\"Engine.get_license_text\", \"Engine.get_license_info\", \"Engine.get_copyright_info\"]`\n   `token_count`: estimate ~150-300 per chunk. I'll put a reasonable number like 200.\n   `metadata`: `{}` or some extra info.\n\n   Let's structure the chunks carefully. I'll make one chunk per major section to keep it clean. Actually, the prompt says \"Return a JSON array of documentation chunk records.\" It doesn't specify how many. I'll generate one record per logical section found in the markdown.\n\n   Sections to process:\n   1. Complying with licenses (Intro/Warning/Note/Tip)\n   2. What are licenses?\n   3. Requirements\n   4. Inclusion\n   5. Credits screen\n   6. Licenses screen\n   7. Output log\n   8. Accompanying file\n   9. Printed manual\n   10. Link to the license\n   11. Third-party licenses\n\n   Wait, the markdown has a code block under \"Requirements\". I'll attach it to that chunk or the first one. I'll put it in the \"Requirements\" chunk.\n   I'll extract the exact text for each chunk.\n\n   Let's draft the JSON records.\n\n   **Chunk 1:**\n   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001`\n   - heading: `Complying with licenses`\n   - section_path: `[\"Complying with licenses\"]`\n   - content: `Learn how to contribute! Complying with licenses Warning The recommendations in this page are not legal advice. They are provided in good faith to help users navigate license attribution requirements.`\n   - code_blocks: `[]`\n   - language_tags: `[]`\n   - api_symbols: `[]`\n   - token_count: 60\n   - metadata: `{}`\n\n   **Chunk 2:**\n   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0002`\n   - heading: `What are licenses?`\n   - section_path: `[\"Complying with licenses\", \"What are licenses?\"]`\n   - content: `Godot is created and distributed under the MIT License. It doesn't have a sole owner, as every contributor that submits code to the project does it under this same license and keeps ownership of their contribution. The license is the legal requirement for you (or your company) to use and distribute the software (and derivative projects, including games made with it). Your game or project can have a different license, but it still needs to comply with the original one. Note This section covers compliance with licenses from a user perspective. If you are interested in licence compliance as a contributor, you can find guidelines here. Tip Alongside the Godot license text, remember to also list third-party notices for assets you're using, such as textures, models, sounds, music and fonts. This includes free assets, which often come with licenses that require attribution.`\n   - code_blocks: `[]`\n   - language_tags: `[]`\n   - api_symbols: `[]`\n   - token_count: 110\n   - metadata: `{}`\n\n   **Chunk 3:**\n   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0003`\n   - heading: `Requirements`\n   - section_path: `[\"Complying with licenses\", \"Requirements\"]`\n   - content: `In the case of the MIT license, the only requirement is to include the license text somewhere in your game or derivative project. This text reads as follows: [License Text] Beside its own MIT license, Godot includes code from a number of third-party libraries. See Third-party licenses for details. Note Your games do not need to be under the same license. You are free to release your Godot projects under any license and to create commercial games with the engine.`\n   - code_blocks: `[ \"This game uses Godot Engine, available under the following license:\\n\\nCopyright (c) 2014-present Godot Engine contributors.\\nCopyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.\\n\\nPermission is hereby granted, free of charge, to any person obtaining a copy\\nof this software and associated documentation files (the \\\"Software\\\"), to deal\\nin the Software without restriction, including without limitation the rights\\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\ncopies of the Software, and to permit persons to whom the Software is\\nfurnished to do so, subject to the following conditions:\\n\\nThe above copyright notice and this permission notice shall be included in all\\ncopies or substantial portions of the Software.\\n\\nTHE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\nSOFTWARE.\" ]`\n   - language_tags: `[\"text\"]`\n   - api_symbols: `[]`\n   - token_count: 180\n   - metadata: `{}`\n\n   **Chunk 4:**\n   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0004`\n   - heading: `Inclusion`\n   - section_path: `[\"Complying with licenses\", \"Inclusion\"]`\n   - content: `The license text must be made available to the user. The license doesn't specify how the text has to be included, but here are the most common approaches (you only need to implement one of them, not all).`\n   - code_blocks: `[]`\n   - language_tags: `[]`\n   - api_symbols: `[]`\n   - token_count: 45\n   - metadata: `{}`\n\n   **Chunk 5:**\n   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0005`\n   - heading: `Credits screen`\n   - section_path: `[\"Complying with licenses\", \"Inclusion\", \"Credits screen\"]`\n   - content: `Include the above license text somewhere in the credits screen. It can be at the bottom after showing the rest of the credits. Most large studios use this approach with open source licenses.`\n   - code_blocks: `[]`\n   - language_tags: `[]`\n   - api_symbols: `[]`\n   - token_count: 35\n   - metadata: `{}`\n\n   **Chunk 6:**\n   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0006`\n   - heading: `Licenses screen`\n   - section_path: `[\"Complying with licenses\", \"Inclusion\", \"Licenses screen\"]`\n   - content: `Some games have a special menu (often in the settings) to display licenses. This menu is typically accessed with a button called Third-party Licenses or Open Source Licenses.`\n   - code_blocks: `[]`\n   - language_tags: `[]`\n   - api_symbols: `[]`\n   - token_count: 35\n   - metadata: `{}`\n\n   **Chunk 7:**\n   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0007`\n   - heading: `Output log`\n   - section_path: `[\"Complying with licenses\", \"Inclusion\", \"Output log\"]`\n   - content: `Printing the license text using the print() function may be enough on platforms where a global output log is readable. This is the case on desktop platforms, Android and HTML5 (but not iOS).`\n   - code_blocks: `[]`\n   - language_tags: `[]`\n   - api_symbols: `[\"print\"]`\n   - token_count: 35\n   - metadata: `{}`\n\n   **Chunk 8:**\n   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0008`\n   - heading: `Accompanying file`\n   - section_path: `[\"Complying with licenses\", \"Inclusion\", \"Accompanying file\"]`\n   - content: `If the game is distributed on desktop platforms, a file containing the license text can be added to the software that is installed to the user PC.`\n   - code_blocks: `[]`\n   - language_tags: `[]`\n   - api_symbols: `[]`\n   - token_count: 30\n   - metadata: `{}`\n\n   **Chunk 9:**\n   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0009`\n   - heading: `Printed manual`\n   - section_path: `[\"Complying with licenses\", \"Inclusion\", \"Printed manual\"]`\n   - content: `If the game includes a printed manual, the license text can be included there.`\n   - code_blocks: `[]`\n   - language_tags: `[]`\n   - api_symbols: `[]`\n   - token_count: 25\n   - metadata: `{}`\n\n   **Chunk 10:**\n   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0010`\n   - heading: `Link to the license`\n   - section_path: `[\"Complying with licenses\", \"Inclusion\", \"Link to the license\"]`\n   - content: `The Godot Engine developers consider that a link to godotengine.org/license in your game documentation or credits would be an acceptable way to satisfy the license terms. Tip Godot provides several methods to get license information in the Engine singleton. This allows you to source the license information directly from the engine binary, which prevents the information from becoming outdated if you update engine versions. For the engine itself: Engine.get_license_text For third-party components used by the engine: Engine.get_license_info Engine.get_copyright_info`\n   - code_blocks: `[]`\n   - language_tags: `[]`\n   - api_symbols: `[\"Engine.get_license_text\", \"Engine.get_license_info\", \"Engine.get_copyright_info\"]`\n   - token_count: 90\n   - metadata: `{}`\n\n   **Chunk 11:**\n   - chunk_id: `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0011`\n   - heading: `Third-party licenses`\n   - section_path: `[\"Complying with licenses\", \"Third-party licenses\"]`\n   - content: `Godot itself contains software written by third parties, which is compatible with, but not covered by Godot's MIT license. Many of these dependencies are distributed under permissive open source licenses which require attribution by explicitly citing their copyright statement and license text in the final product's documentation. Given the scope of the Godot project, this is fairly difficult to do thoroughly. For the Godot editor, the full documentation of third-party copyrights and licenses is provided in the COPYRIGHT.txt file. A good option for end users to document third-party licenses is to include this file in your project's distribution, which you can e.g. rename to GODOT_COPYRIGHT.txt to prevent any confusion with your own code and assets.`\n   - code_blocks: `[]`\n   - language_tags: `[]`\n   - api_symbols: `[]`\n   - token_count: 110\n   - metadata: `{}`\n\n   Check constraints:\n   - `chunk_id` matches `^godot-\\w+:\\S+` -> `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001` etc. Matches.\n   - `doc_version`: `stable`\n   - `source_url`: `https://docs.godotengine.org/en/stable/about/complying_with_licenses.html`\n   - `source_file`: `pages/about__complying_with_licenses__d36558dd.md`\n   - `source_sha256`: `2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3`\n   - `doc_type`: `about`\n   - `symbol`: `\"\"`\n   - `section_path`: list of strings\n   - `heading`: string\n   - `content`: string\n   - `code_blocks`: list of strings\n   - `language_tags`: list of strings\n   - `godot_version_tags`: list of strings -> `[\"4.6\", \"stable\"]` for all, or maybe just `[\"stable\"]`. I'll add `[\"4.6\", \"stable\"]` to all or just the first. I'll put it in all for consistency, or leave empty if not explicitly in text. The text says \"Godot Engine 4.6 documentation in English\". I'll add `[\"4.6\", \"stable\"]` to `godot_version_tags`.\n   - `api_symbols`: list of strings\n   - `token_count`: int\n   - `metadata`: dict\n\n   I will construct the JSON array carefully. I'll make sure all fields are present. I'll double-check the regex for chunk_id: `^godot-\\w+:\\S+`. `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001` matches.\n   I'll ensure no markdown formatting in the output.\n   I'll verify the exact source file and sha256 are used.\n   I'll verify `doc_type` is exactly one of the allowed values. `about` is allowed.\n   I'll verify `symbol` is empty string.\n   I'll verify `section_path` is a list of strings.\n   I'll verify `code_blocks` contains the exact license text.\n   I'll verify `language_tags` contains `[\"text\"]` or `[\"license\"]`. I'll use `[\"text\"]`.\n   I'll verify `godot_version_tags` contains `[\"4.6\", \"stable\"]`.\n   I'll verify `api_symbols` contains the engine methods.\n   I'll verify `token_count` is an integer.\n   I'll verify `metadata` is a dict.\n\n   One minor thing: The prompt says \"Return a JSON array of documentation chunk records.\" It doesn't specify how many chunks. I'll stick with the section-based chunks. It's standard.\n   I will format the JSON carefully.\n   Let's assemble. \n   I'll make sure to escape quotes in the license text properly for JSON.\n   I'll check the exact text for the license block to ensure it matches.\n   \"This game uses Godot Engine, available under the following license:\\n\\nCopyright (c) 2014-present Godot Engine contributors.\\nCopyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.\\n\\nPermission is hereby granted, free of charge, to any person obtaining a copy\\nof this software and associated documentation files (the \\\"Software\\\"), to deal\\nin the Software without restriction, including without limitation the rights\\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\ncopies of the Software, and to permit persons to whom the Software is\\nfurnished to do so, subject to the following conditions:\\n\\nThe above copyright notice and this permission notice shall be included in all\\ncopies or substantial portions of the Software.\\n\\nTHE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\nSOFTWARE.\"\n   This matches.\n\n   All fields look good. I will generate the JSON now.\n   One detail: `godot_version_tags` should probably be `[\"4.6\", \"stable\"]` for each chunk, or I can just put it in the first one. I'll put it in all for consistency, or leave it as `[\"4.6\", \"stable\"]` in all. It's fine.\n   I'll ensure `doc_type` is `about`.\n   I'll ensure `symbol` is `\"\"`.\n   I'll ensure `section_path` is correct.\n   I'll ensure `heading` matches exactly.\n   I'll ensure `content` is clean text.\n   I'll ensure `code_blocks` is a list of strings.\n   I'll ensure `language_tags` is a list of strings.\n   I'll ensure `api_symbols` is a list of strings.\n   I'll ensure `token_count` is int.\n   I'll ensure `metadata` is dict.\n\n   Ready. Output matches requirements. No markdown fences. Just JSON array.\n   I will produce it now. \n   Self-Correction/Refinement during thought: \n   The prompt says \"Never return chunk_0 or plain numeric IDs.\" My IDs are `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001`, etc. This matches `^godot-\\w+:\\S+`.\n   I'll make sure the JSON is strictly valid.\n   I'll combine everything into a single JSON array.\n   All good.\n   Output generation. \n   [Proceeds] \n   *Self-Correction/Verification during generation prep*:\n   Check `doc_type` allowed values: `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. `about` is correct.\n   Check `source_file`: `pages/about__complying_with_licenses__d36558dd.md` (exact match)\n   Check `source_sha256`: `2594f1e735cae7d004e632558e2fd4dacbf4317dfce8a2f5dce6cc4ddc2a54c3` (exact match)\n   Check `chunk_id` regex: `^godot-\\w+:\\S+` -> `godot-stable:pages/about__complying_with_licenses__d36558dd.md#section-0001` matches.\n   All constraints met.\n   I will output the JSON array now. \n   Note: I'll make sure to escape newlines in the license block properly for JSON.\n   I'll produce the exact JSON.✅\n   Output matches. \n   [Done] \n   *Output Generation* (matches the final JSON)\n   ```json\n   [\n     { ... },\n     ...\n   ]\n   ```\n   No markdown fences. Just raw JSON.\n   Proceeds. \n   [Output Generation] -> *See response.* \n   *(Self-Correction/Note during thought)*: I should verify that `section_path` is a list of strings representing the heading hierarchy. For the first chunk, it's `[\"Complying with licenses\"]`. For the second, `[\"Complying with licenses\", \"What are licenses?\"]`, etc. This is correct.\n   I will ensure all fields are present in every record.\n   All good. \n   Output matches request.✅\n   [Final Check of the Prompt]: \"Return ONLY a JSON array — no markdown code fences, no explanation. /no_think\"\n   I will output raw JSON.\n   Proceeds. \n   [Output Generation] -> *Proceeds*\n"
}

2. pages/about__docs_changelog__67dbc069.md::docs_chunks

stage: conversion
api_url: [redacted]
model: [redacted]
table: docs_chunks
markdown_length: 5972
prompt_length: 7490
response_saved: False

Request Message Summary

[
  {
    "role": "system",
    "content_length": 193
  },
  {
    "role": "user",
    "content_length": 7490
  }
]

Full Conversion Prompt Sent To Qwen

Table: docs_chunks
Return a JSON array of documentation chunk records.
Required fields and exact rules:
  - chunk_id (str): MUST match regex ^godot-\w+:\S+. Use a deterministic value like godot-stable:pages/about__intro.md#section-0001. Never return chunk_0 or plain numeric IDs.
  - doc_version (str): docs version such as stable, latest, 4.6, or unknown.
  - source_url (str): original docs URL if known, otherwise empty string.
  - source_file (str): exact local markdown path provided by the caller.
  - source_sha256 (str): exact sha256 provided by the caller.
  - doc_type (str): exactly one of class_reference, tutorial, migration, engine_details, about, other. Never use article.
  - symbol (str): class/API symbol or empty string.
  - section_path (list[str]): heading hierarchy.
  - heading (str): section heading.
  - content (str): searchable body text.
  - code_blocks (list[str]): extracted code blocks.
  - language_tags (list[str]): detected code languages.
  - godot_version_tags (list[str]): version hints.
  - api_symbols (list[str]): detected Godot symbols.
  - token_count (int): estimated token count.
  - metadata (dict): any extra metadata.
Return only valid JSON. No markdown. No comments.

Target table: docs_chunks
Source file that MUST be written into source_file fields: pages/about__docs_changelog__67dbc069.md
Source sha256 that MUST be written into source_sha256 fields when the field exists: 1dc4c3783f53314fdf8e969455c9eb98d099f67b74384a84d8f866c239ea22db

--- MARKDOWN ---
# Source: https://docs.godotengine.org/en/stable/about/docs_changelog.html

Godot Engine 4.6 documentation in English
Documentation changelog
Edit on GitHub
Learn how to contribute!
Documentation changelog

The documentation is continually being improved. New releases
include new pages, fixes and updates to existing pages, and many updates
to the
class reference
. Below is a list of new pages
added since version 3.0.
Note
This document only contains new pages, so not all changes are reflected.
Many pages have been substantially updated but are not reflected in this document.
New pages since version 4.4

Editor

Using the engine compilation configuration editor
GDExtension

GDExtension C example
Migrating

Upgrading from Godot 4.4 to Godot 4.5
Scripting

Logging
New pages since version 4.3

2D

Introduction to 2D
3D

Third-person camera with spring arm
Debug

Output panel
Editor

Using the XR editor
Migrating

Upgrading from Godot 4.3 to Godot 4.4
Performance

Reducing stutter from shader (pipeline) compilations
Physics

Physics Interpolation
Quick start guide
Introduction
Using physics interpolation
Advanced physics interpolation
2D and 3D physics interpolation
Rendering

Overview of renderers
Shaders

Built-in functions
New pages since version 4.2

About

System requirements
2D

2D Parallax
Contributing

Handling compatibility breakages
GDExtension

The .gdextension file
Adding documentation
Migrating

Upgrading from Godot 4.2 to Godot 4.3
Rendering

The Compositor
XR

A better XR start script
AR / Passthrough
Where to go from here
OpenXR Settings
OpenXR composition layers
OpenXR body tracking
New pages since version 4.1

C#

C# diagnostics
Development

2D coordinate systems and 2D transforms
Migrating

Upgrading from Godot 4.1 to Godot 4.2
I/O

Runtime file loading and saving
Platform-specific

Godot Android library
New pages since version 4.0

Development

Internal rendering architecture
Using sanitizers
Migrating

Upgrading from Godot 4.0 to Godot 4.1
Physics

Troubleshooting physics issues
New pages since version 3.6

2D

2D antialiasing
3D

3D antialiasing
Faking global illumination
Introduction to global illumination
Mesh level of detail (LOD)
Occlusion culling
Signed distance field global illumination (SDFGI)
Using decals
Visibility ranges (HLOD)
Volumetric fog and fog volumes
Variable rate shading
Physical light and camera units
Animation

Creating movies
Assets pipeline

Retargeting 3D Skeletons
Development

Custom platform ports
Migrating

Upgrading from Godot 3 to Godot 4
Physics

Large world coordinates
Scripting

Custom performance monitors
C# collections
C# global classes
C# Variant
Shaders

Using compute shaders
XR

Introducing XR tools
The XR action map
Deploying to Android
New pages since version 3.5

None.
New pages since version 3.4

3D

3D text
Animation

Playing videos
Editor

Managing editor features
New pages since version 3.3

GDScript

GDScript documentation comments
New pages since version 3.2

3D

3D rendering limitations
About

Troubleshooting
List of features
Godot release policy
Best practices

Version control systems
Development

Error macros
Validation layers
GDScript grammar
Configuring an IDE:
Code::Blocks
Editor

Default editor shortcuts
Using the Web editor
Export

Exporting for dedicated servers
Input

Controllers, gamepads, and joysticks
Math

Random number generation
Platform-specific

Plugins for iOS
Creating iOS plugins
HTML5 shell class reference
Physics

Collision shapes (2D)
Collision shapes (3D)
Shaders

Shaders style guide
Scripting

Debugger panel
Creating script templates
Evaluating expressions
What is GDExtension?
GDScript warning system
(split from
Static typing in GDScript
)
User Interface (UI)

Control node gallery
New pages since version 3.1

Project workflow

Gradle builds for Android
2D

2D sprite animation
Audio

Recording with microphone
Sync the gameplay with audio and music
Math

Beziers, curves and paths
Interpolation
Inputs

Input examples
Internationalization

Localization using gettext (PO files)
Shading

Your First Shader Series:
Introduction to shaders
Your first 2D shader
Your first 3D shader
Your second 3D shader
Using VisualShaders
Networking

WebRTC
Plugins

Godot Android plugins
Inspector plugins
Visual Shader plugins
Multi-threading

Using multiple threads
Creating content

Procedural geometry series:
Procedural geometry
Using the ArrayMesh
Using the SurfaceTool
Using the MeshDataTool
Using ImmediateMesh
Optimization

Optimization using MultiMeshes
Optimization using Servers
Legal

Complying with licenses
New pages since version 3.0

Step by step

Using signals
Exporting
Scripting

Static typing in GDScript
Project workflow

Best Practices:
Introduction
Applying object-oriented principles in Godot
Scene organization
When to use scenes versus scripts
Autoloads versus regular nodes
When and how to avoid using nodes for everything
Godot interfaces
Godot notifications
Data preferences
Logic preferences
2D

2D lights and shadows
2D meshes
3D

Prototyping levels with CSG
Animating thousands of fish with MultiMeshInstance3D
Controlling thousands of fish with Particles
Physics

Ragdoll system
Using SoftBody3D
Animation

2D skeletons
Using AnimationTree
GUI

Using Containers
Viewports

Using a SubViewport as a texture
Custom post-processing
Shading

Converting GLSL to Godot shaders
Advanced post-processing
Shading Reference:
Introduction to shaders
Shading language
Spatial shaders
CanvasItem shaders
Particle shaders
Plugins

Making main screen plugins
3D gizmo plugins
Platform-specific

Custom HTML page for Web export
Multi-threading

Thread-safe APIs
Creating content

Making trees
Miscellaneous

Fixing jitter, stutter and input lag
Running code in the editor
Change scenes manually
Compiling

Optimizing a build for size
Compiling with PCK encryption key
Engine development

Binding to external libraries
/no_think

Conversion Response Content

The response has not been saved yet. The raw response is empty due to timeout/deferred or call interruption.

3. pages/aboutfaq32bebcf7.md::docs_chunks

stage: conversion
api_url: [redacted]
model: [redacted]
table: docs_chunks
markdown_length: 26639
prompt_length: 28146
response_saved: False

[
  {
    "role": "system",
    "content_length": 193
  },
  {
    "role": "user",
    "content_length": 28146
  }
]

Full Conversion Prompt Sent To Qwen

Table: docs_chunks
Return a JSON array of documentation chunk records.
Required fields and exact rules:
  - chunk_id (str): MUST match regex ^godot-\w+:\S+. Use a deterministic value like godot-stable:pages/about__intro.md#section-0001. Never return chunk_0 or plain numeric IDs.
  - doc_version (str): docs version such as stable, latest, 4.6, or unknown.
  - source_url (str): original docs URL if known, otherwise empty string.
  - source_file (str): exact local markdown path provided by the caller.
  - source_sha256 (str): exact sha256 provided by the caller.
  - doc_type (str): exactly one of class_reference, tutorial, migration, engine_details, about, other. Never use article.
  - symbol (str): class/API symbol or empty string.
  - section_path (list[str]): heading hierarchy.
  - heading (str): section heading.
  - content (str): searchable body text.
  - code_blocks (list[str]): extracted code blocks.
  - language_tags (list[str]): detected code languages.
  - godot_version_tags (list[str]): version hints.
  - api_symbols (list[str]): detected Godot symbols.
  - token_count (int): estimated token count.
  - metadata (dict): any extra metadata.
Return only valid JSON. No markdown. No comments.

Target table: docs_chunks
Source file that MUST be written into source_file fields: pages/about__faq__32bebcf7.md
Source sha256 that MUST be written into source_sha256 fields when the field exists: 7a30e8a1ff01f74c3bce7268d5abb84275574a851ad187fcef09109d7fce0062

--- MARKDOWN ---
# Source: https://docs.godotengine.org/en/stable/about/faq.html

Godot Engine 4.6 documentation in English
Frequently asked questions
Edit on GitHub
Learn how to contribute!
Frequently asked questions

What can I do with Godot? How much does it cost? What are the license terms?

Godot is
Free and open source Software
available under the
OSI-approved
MIT license. This means it is
free as in "free speech" as well as in "free beer."
In short:
You are free to download and use Godot for any purpose: personal, non-profit, commercial, or otherwise.
You are free to modify, distribute, redistribute, and remix Godot to your heart's content, for any reason,
both non-commercially and commercially.
All the contents of this accompanying documentation are published under the permissive Creative Commons
Attribution 3.0 (
CC BY 3.0
) license, with attribution
to "Juan Linietsky, Ariel Manzur and the Godot Engine community."
Logos and icons are generally under the same Creative Commons license. Note
that some third-party libraries included with Godot's source code may have
different licenses.
For full details, look at the
COPYRIGHT.txt
as well as the
LICENSE.txt
and
logo LICENSE.txt
files
in the Godot repository.
Also, see
the license page on the Godot website
.
Which platforms are supported by Godot?

For the editor:
Windows
macOS
Linux, *BSD
Android (experimental)
Web
(experimental)
For exporting your games:
Windows
macOS
Linux, *BSD
Android
iOS
Web
Both 32- and 64-bit binaries are supported where it makes sense, with 64
being the default. Official macOS builds support Apple Silicon natively as well as x86_64.
Some users also report building and using Godot successfully on ARM-based
systems with Linux, like the Raspberry Pi.
For information about console support, see the
Godot website
.
For more on this, see the sections on
exporting
and
compiling Godot yourself
.
Note
Godot 3 also had support for Universal Windows Platform (UWP). This platform
port was removed in Godot 4 due to lack of maintenance, and it being
deprecated by Microsoft. It is still available in the current stable release
of Godot 3 for interested users.
Which programming languages are supported in Godot?

The officially supported languages for Godot are GDScript, C#, and C++.
See the subcategories for each language in the
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.
While scripting languages tend to be less performant than lower-level languages in
the long run, for prototyping, developing Minimum Viable Products (MVPs), and
focusing on Time-To-Market (TTM), GDScript will provide a fast, friendly, and capable
way of developing your games.
Note that C# support is still relatively new, and as such, you may encounter
some issues along the way. C# support is also currently missing on the web
platform. Our friendly and hard-working development community is always
ready to tackle new problems as they arise, but since this is an open source
project, we recommend that you first do some due diligence yourself. Searching
through discussions on
open issues
is a great way to start your troubleshooting.
As for new languages, support is possible via third parties with GDExtensions. (See the question
about plugins below). Work is currently underway, for example, on unofficial bindings for Godot
to
Python
and
Nim
.
What is GDScript and why should I use it?

GDScript is Godot's integrated scripting language. It was built from the ground
up to maximize Godot's potential in the least amount of code, affording both novice
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 and a complete overview of the power GDScript offers
you, check out the
GDScript scripting guide
.
There are several reasons to use GDScript, but the most salient reason is the overall
reduction of complexity
.
The original intent of creating a tightly integrated, custom scripting language for
Godot was two-fold: first, it reduces the amount of time necessary to get up and running
with Godot, giving developers a rapid way of exposing themselves to the engine with a
focus on productivity; second, it reduces the overall burden of maintenance, attenuates
the dimensionality of issues, and allows the developers of the engine to focus on squashing
bugs and improving features related to the engine core, rather than spending a lot of time
trying to get a small set of incremental features working across a large set of languages.
Since Godot is an open source project, it was imperative from the start to prioritize a
more integrated and seamless experience over attracting additional users by supporting
more familiar programming languages, especially when supporting those more familiar
languages would result in a worse experience. We understand if you would rather use
another language in Godot (see the list of supported options above). That being said, if
you haven't given GDScript a try, try it for
three days
. Just like Godot,
once you see how powerful it is and how rapid your development becomes, we think GDScript
will grow on you.
More information about getting comfortable with GDScript or dynamically typed
languages can be found in the
GDScript: An introduction to dynamic languages
tutorial.
What were the motivations behind creating GDScript?

In the early days, the engine used the
Lua
scripting
language. Lua can be fast thanks to LuaJIT, but creating bindings to an object-oriented
system (by using fallbacks) was complex and slow and took an enormous
amount of code. After some experiments with
Python
,
that also proved difficult to embed.
The main reasons for creating a custom scripting language for Godot were:
Poor threading support in most script VMs, and Godot uses threads
(Lua, Python, Squirrel, JavaScript, ActionScript, etc.).
Poor class-extending support in most script VMs, and adapting to
the way Godot works is highly inefficient (Lua, Python, JavaScript).
Many existing languages have horrible interfaces for binding to C++, resulting in a
large amount of code, bugs, bottlenecks, and general inefficiency (Lua, Python,
Squirrel, JavaScript, etc.). We wanted to focus on a great engine, not a great number
of integrations.
No native vector types (Vector3, Transform3D, etc.), resulting in highly
reduced performance when using custom types (Lua, Python, Squirrel,
JavaScript, ActionScript, etc.).
Garbage collector results in stalls or unnecessarily large memory
usage (Lua, Python, JavaScript, ActionScript, etc.).
Difficulty integrating with the code editor for providing code
completion, live editing, etc. (all of them).
GDScript was designed to curtail the issues above, and more.
Which programming language is fastest?

In most games, the
scripting language
itself is not the cause of performance
problems. Instead, performance is slowed by inefficient algorithms (which are
slow in all languages), by GPU performance, or by the common C++ engine code
like physics or navigation. All languages supported by Godot are fast enough for
general-purpose scripting. You should choose a language based on other factors,
like ease-of-use, familiarity, platform support, or language features.
In general, the performance of C# and GDScript is within the same order of
magnitude, and C++ is faster than both.
Comparing GDScript performance to C# is tricky, since C# can be faster in some
specific cases. The C#
language
itself tends to be faster than GDScript, which
means that C# can be faster in situations with few calls to Godot engine code.
However, C# can be slower than GDScript when making many Godot API calls, due
to the cost of
marshalling
. C#'s performance can also be brought down by garbage
collection which occurs at random and unpredictable moments. This can result in
stuttering issues in complex projects, and is not exclusive to Godot.
C++, using
GDExtension
, will almost always be
faster than either C# or GDScript. However, C++ is less easy to use than C# or
GDScript, and is slower to develop with.
You can also use multiple languages within a single project, with
cross-language scripting
, or by using
GDExtension and scripting languages together. Be aware that doing so comes with
its own complications.
What 3D model formats does Godot support?

You can find detailed information on supported formats, how to export them from
your 3D modeling software, and how to import them for Godot in the
Importing 3D scenes
documentation.
Will [insert closed SDK such as FMOD, GameWorks, etc.] be supported in Godot?

The aim of Godot is to create a free and open source MIT-licensed engine that
is modular and extendable. There are no plans for the core engine development
community to support any third-party, closed-source/proprietary SDKs, as integrating
with these would go against Godot's ethos.
That said, because Godot is open source and modular, nothing prevents you or
anyone else interested in adding those libraries as a module and shipping your
game with them, as either open- or closed-source.
To see how support for your SDK of choice could still be provided, look at the
Plugins question below.
If you know of a third-party SDK that is not supported by Godot but that offers
free and open source integration, consider starting the integration work yourself.
Godot is not owned by one person; it belongs to the community, and it grows along
with ambitious community contributors like you.
How can I extend Godot?

For extending Godot, like creating Godot Editor plugins or adding support
for additional languages, take a look at
EditorPlugins
and tool scripts.
Also, see the official blog post on GDExtension, a way to develop native extensions for Godot:
Introducing GDNative's successor, GDExtension
You can also take a look at the GDScript implementation, the Godot modules,
as well as the
Jolt physics engine integration
for Godot. This would be a good starting point to see how another
third-party library integrates with Godot.
How do I install the Godot editor on my system (for desktop integration)?

Since you don't need to actually install Godot on your system to run it,
this means desktop integration is not performed automatically.
There are two ways to overcome this. You can install Godot from
Steam
(all platforms),
Scoop
(Windows),
Homebrew
(macOS)
or
Flathub
(Linux).
This will automatically perform the required steps for desktop integration.
Alternatively, you can manually perform the steps that an installer would do for you:
Windows

Move the Godot executable to a stable location (i.e. outside of your Downloads folder),
so you don't accidentally move it and break the shortcut in the future.
Right-click the Godot executable and choose
Create Shortcut
.
Move the created shortcut to
%APPDATA%\Microsoft\Windows\Start
Menu\Programs
.
This is the user-wide location for shortcuts that will appear in the Start menu.
You can also pin Godot in the task bar by right-clicking the executable and choosing
Pin to Task Bar
.
macOS

Drag the extracted Godot application to
/Applications/Godot.app
, then drag it
to the Dock if desired. Spotlight will be able to find Godot as long as it's in
/Applications
or
~/Applications
.
Linux

Move the Godot binary to a stable location (i.e. outside of your Downloads folder),
so you don't accidentally move it and break the shortcut in the future.
Rename and move the Godot binary to a location present in your
PATH
environment variable.
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
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=
line in the
.desktop
file linked below to contain the full
absolute
path
to the Godot binary.
Save
this .desktop file
to
$HOME/.local/share/applications/
. If you have administrator privileges,
you can also save the
.desktop
file to
/usr/local/share/applications
to make the shortcut available for all users.
Is the Godot editor a portable application?

In its default configuration, Godot is
semi-portable
. Its executable can run
from any location (including non-writable locations) and never requires
administrator privileges.
However, configuration files will be written to the user-wide configuration or
data directory. This is usually a good approach, but this means configuration files
will not carry across machines if you copy the folder containing the Godot executable.
See
File paths in Godot projects
for more information.
If
true
portable operation is desired (e.g. for use on a USB stick),
follow the steps in
Self-contained mode
.
Why does Godot aim to keep its core feature set small?

Godot intentionally does not include features that can be implemented by add-ons
unless they are used very often. One example of something not used often is
advanced artificial intelligence functionality.
There are several reasons for this:
Code maintenance and surface for bugs.
Every time we accept new code in
the Godot repository, existing contributors often take the responsibility of
maintaining it. Some contributors don't always stick around after getting
their code merged, which can make it difficult for us to maintain the code in
question. This can lead to poorly maintained features with bugs that are never
fixed. On top of that, the "API surface" that needs to be tested and checked
for regressions keeps increasing over time.
Ease of contribution.
By keeping the codebase small and tidy, it can remain
fast and easy to compile from source. This makes it easier for new
contributors to get started with Godot, without requiring them to purchase
high-end hardware.
Keeping the binary size small for the editor.
Not everyone has a fast Internet
connection. Ensuring that everyone can download the Godot editor, extract it
and run it in less than 5 minutes makes Godot more accessible to developers in
all countries.
Keeping the binary size small for export templates.
This directly impacts the
size of projects exported with Godot. On mobile and web platforms, keeping
file sizes low is important to ensure fast installation and loading on
underpowered devices. Again, there are many countries where high-speed
Internet is not readily available. To add to this, strict data usage caps are
often in effect in those countries.
For all the reasons above, we have to be selective of what we can accept as core
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
to optimize the distribution size of your project.)
How should assets be created to handle multiple resolutions and aspect ratios?

This question pops up often and it's probably thanks to the misunderstanding
created by Apple when they originally doubled the resolution of their devices.
It made people think that having the same assets in different resolutions was a
good idea, so many continued towards that path. That originally worked to a
point and only for Apple devices, but then several Android and Apple devices
with different resolutions and aspect ratios were created, with a very wide
range of sizes and DPIs.
The most common and proper way to achieve this is to, instead, use a single base
resolution for the game and only handle different screen aspect ratios. This is
mostly needed for 2D, as in 3D, it's just a matter of camera vertical or
horizontal FOV.
Choose a single base resolution for your game. Even if there are
devices that go up to 1440p and devices that go down to 400p, regular
hardware scaling in your device will take care of this at little or
no performance cost. The most common choices are either near 1080p
(1920x1080) or 720p (1280x720). Keep in mind the higher the
resolution, the larger your assets, the more memory they will take
and the longer the time it will take for loading.
Use the stretch options in Godot; canvas items stretching while keeping
aspect ratios works best. Check the
Multiple resolutions
tutorial
on how to achieve this.
Determine a minimum resolution and then decide if you want your game
to stretch vertically or horizontally for different aspect ratios, or
if there is one aspect ratio and you want black bars to appear
instead. This is also explained in
Multiple resolutions
.
For user interfaces, use the
anchoring
to determine where controls should stay and move. If UIs are more
complex, consider learning about Containers.
And that's it! Your game should work in multiple resolutions.
When is the next release of Godot out?

When it's ready! See
When is the next release out?
for more
information.
Which Godot version should I use for a new project?

We recommend using Godot 4.x for new projects, but depending on the feature set
you need, it may be better to use 3.x instead. See
Which version should I use for a new project?
for more information.
Should I upgrade my project to use new Godot versions?

Some new versions are safer to upgrade to than others. In general, whether you
should upgrade depends on your project's circumstances. See
Should I upgrade my project to use new engine versions?
for more information.
Should I use the Forward+, Mobile, or Compatibility renderer?

You can find a detailed comparison of the renderers in
Overview of renderers
.
I would like to contribute! How can I get started?

Awesome! As an open source project, Godot thrives off of the innovation and
the ambition of developers like you.
The best way to start contributing to Godot is by using it and reporting
any
issues
that you might experience.
A good bug report with clear reproduction steps helps your fellow contributors
fix bugs quickly and efficiently. You can also report issues you find in the
online documentation
.
If you feel ready to submit your first PR, pick any issue that resonates with you from
one of the links above and try your hand at fixing it. You will need to learn how to
compile the engine from sources, or how to build the documentation. You also need to
get familiar with Git, a version control system that Godot developers use.
We explain how to work with the engine source, how to edit the documentation, and
what other ways to contribute are there in our
documentation for contributors
.
I have a great idea for Godot. How can I share it?

We are always looking for suggestions about how to improve the engine. User feedback
is the main driving force behind our decision-making process, and limitations that
you might face while working on your project are a great data point for us when considering
engine enhancements.
If you experience a usability problem or are missing a feature in the current version of
Godot, start by discussing it with our
community
.
There may be other, perhaps better, ways to achieve the desired result that community members
could suggest. And you can learn if other users experience the same issue, and figure out
a good solution together.
If you come up with a well-defined idea for the engine, feel free to open a
proposal issue
.
Try to be specific and concrete while describing your problem and your proposed
solution — only actionable proposals can be considered. It is not required, but
if you want to implement it yourself, that's always appreciated!
If you only have a general idea without specific details, you can open a
proposal discussion
.
These can be anything you want, and allow for a free-form discussion in search of
a solution. Once you find one, a proposal issue can be opened.
Please, read the
readme
document before creating a proposal to learn more about the process.
Is it possible to use Godot to create non-game applications?

Yes! Godot features an extensive built-in UI system, and its small distribution
size can make it a suitable alternative to frameworks like Electron or Qt.
See
Creating applications
for more information.
Is it possible to use Godot as a library?

If you are looking to make a game with Godot, keep in mind Godot is designed
to be used with its editor. We recommend you give it a try, as it
will most likely save you time in the long term.
For more specialized applications, it can make sense to look into using
Godot as a library. Since Godot 4.6, there is
experimental
support
for using Godot as a static or shared library in the form of LibGodot.
This is currently supported on Windows, macOS, and Linux. Support for
Android and iOS is planned for a future release.
You can find sample applications that use Godot as a library in the
migeran/libgodot_project GitHub repository
.
What user interface toolkit does Godot use?

Godot does not use a standard
GUI
toolkit
like GTK, Qt or wxWidgets. Instead, Godot uses its own user interface toolkit,
which is always rendered using hardware acceleration. There is no built-in software
fallback, although external solutions that emulate graphics APIs on the CPU can be used.
This toolkit is exposed in the form of Control nodes, which are used to render
the editor (which is written in C++). These Control nodes can also be used in projects
from any scripting language supported by Godot.
This custom toolkit makes it possible to benefit from hardware acceleration and
have a consistent appearance across all platforms. On top of that, it doesn't
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 be
embedded into other applications
(experimental). However, the preferred way to use it is to
use Godot to create non-game applications with the editor
.
Why does Godot use the SCons build system?

Godot uses the
SCons
build system. There are no
plans to switch to a different build system in the near future. There are many
reasons why we have chosen SCons over other alternatives. For example:
Godot can be compiled for a dozen different platforms: all PC
platforms, all mobile platforms, many consoles, and WebAssembly.
Developers often need to compile for several of the platforms
at
the same time
, or even different targets of the same platform. They
can't afford reconfiguring and rebuilding the project each time.
SCons can do this with no sweat, without breaking the builds.
SCons will
never
break a build no matter how many changes,
configurations, additions, removals etc.
Godot's build process is not simple. Several files are generated by
code (binders), others are parsed (shaders), and others need to offer
customization (
modules
). This requires
complex logic which is easier to write in an actual programming language (like Python)
rather than using a mostly macro-based language only meant for building.
Godot's build process makes heavy use of cross-compiling tools. Each
platform has a specific detection process, and all these must be
handled as specific cases with special code written for each.
Please try to keep an open mind and get at least a little familiar with SCons if
you are planning to build Godot yourself.
Why does Godot not use STL (Standard Template Library)?

Like many other libraries (Qt as an example), Godot does not make use of STL
(with a few exceptions such as threading primitives). We believe STL is a great
general-purpose library, but we had special requirements for Godot.
STL templates create very large symbols, which results in huge debug binaries. We use few
templates with very short names instead.
Most of our containers cater to special needs, like Vector, which uses copy on write and we
use to pass data around, or the RID system, which requires O(1) access time for performance.
Likewise, our hash map implementations are designed to integrate seamlessly with internal
engine types.
Our containers have memory tracking built-in, which helps better track memory usage.
For large arrays, we use pooled memory, which can be mapped to either a preallocated buffer
or virtual memory.
We use our custom String type, as the one provided by STL is too basic and lacks proper
internationalization support.
Check out
Godot's container types
for alternatives.
Why does Godot not use exceptions?

We believe games should not crash, no matter what. If an unexpected
situation happens, Godot will print an error (which can be traced even to
script), but then it will try to recover as gracefully as possible and keep
going.
Additionally, exceptions significantly increase the binary size for the
executable and result in increased compile times.
Does Godot use an ECS (Entity Component System)?

Godot does
not
use an ECS and relies on inheritance instead. While there
is no universally better approach, we found that using an inheritance-based approach
resulted in better usability while still being fast enough for most use cases.
That said, nothing prevents you from making use of composition in your project
by creating child Nodes with individual scripts. These nodes can then be added and
removed at runtime to dynamically add and remove behaviors.
More information about Godot's design choices can be found in
this article
.
Why does Godot not force users to implement DOD (Data-Oriented Design)?

While Godot internally attempts to use cache coherency as much as possible,
we believe users don't need to be forced to use DOD practices.
DOD is mostly a cache coherency optimization that can only provide
significant performance improvements when dealing with dozens of
thousands of objects which are processed every frame with little
modification. That is, if you are moving a few hundred sprites or enemies
per frame, DOD won't result in a meaningful improvement in performance. In
such a case, you should consider a different approach to optimization.
The vast majority of games do not need this and Godot provides handy helpers
to do the job for most cases when you do.
If a game needs to process such a large amount of objects, our recommendation
is to use C++ and GDExtensions for performance-heavy tasks and GDScript (or C#)
for the rest of the game.
How can I support Godot development or contribute?

See
How to contribute
.
Who is working on Godot? How can I contact you?

See the corresponding page on the
Godot website
.
/no_think

Conversion Response Content

The response has not been saved yet. The raw response is empty due to timeout/deferred or call interruption.

4. pages/aboutintroduction344b3840.md::docs_chunks

stage: conversion
api_url: [redacted]
model: [redacted]
table: docs_chunks
markdown_length: 4294
prompt_length: 5810
response_saved: True

[
  {
    "role": "system",
    "content_length": 193
  },
  {
    "role": "user",
    "content_length": 5810
  }
]

Full Conversion Prompt Sent To Qwen

Table: docs_chunks
Return a JSON array of documentation chunk records.
Required fields and exact rules:
  - chunk_id (str): MUST match regex ^godot-\w+:\S+. Use a deterministic value like godot-stable:pages/about__intro.md#section-0001. Never return chunk_0 or plain numeric IDs.
  - doc_version (str): docs version such as stable, latest, 4.6, or unknown.
  - source_url (str): original docs URL if known, otherwise empty string.
  - source_file (str): exact local markdown path provided by the caller.
  - source_sha256 (str): exact sha256 provided by the caller.
  - doc_type (str): exactly one of class_reference, tutorial, migration, engine_details, about, other. Never use article.
  - symbol (str): class/API symbol or empty string.
  - section_path (list[str]): heading hierarchy.
  - heading (str): section heading.
  - content (str): searchable body text.
  - code_blocks (list[str]): extracted code blocks.
  - language_tags (list[str]): detected code languages.
  - godot_version_tags (list[str]): version hints.
  - api_symbols (list[str]): detected Godot symbols.
  - token_count (int): estimated token count.
  - metadata (dict): any extra metadata.
Return only valid JSON. No markdown. No comments.

Target table: docs_chunks
Source file that MUST be written into source_file fields: pages/about__introduction__344b3840.md
Source sha256 that MUST be written into source_sha256 fields when the field exists: f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d

--- MARKDOWN ---
# Source: https://docs.godotengine.org/en/stable/about/introduction.html

Godot Engine 4.6 documentation in English
Introduction
Edit on GitHub
Learn how to contribute!
Introduction

GDScript
C#
func
_ready
():
print
(
"Hello world!"
)
Copy to clipboard
public
override
void
_Ready
()
{
GD
.
Print
(
"Hello world!"
);
}
Copy to clipboard
Welcome to the official documentation of
Godot Engine
, the free and open source
community-driven 2D and 3D game engine! Behind this mouthful, you will find a
powerful yet user-friendly tool that you can use to develop any kind of game,
for any platform and with no usage restriction whatsoever.
This page gives a broad overview of the engine and of this documentation,
so that you know where to start if you are a beginner or
where to look if you need information on a specific feature.
Before you start

The
Tutorials and resources
page lists
video tutorials contributed by the community. If you prefer video to text,
consider checking them out. Otherwise,
Getting Started
is a great starting point.
In case you have trouble with one of the tutorials or your project,
you can find help on the various
Community channels
,
especially the Godot
Discord
community and
Forum
.
About Godot Engine

A game engine is a complex tool and difficult to present in a few words.
Here's a quick synopsis, which you are free to reuse
if you need a quick write-up about Godot Engine:
Godot Engine is a feature-packed, cross-platform game engine to create 2D
and 3D games from a unified interface. It provides a comprehensive set of
common tools, so that users can focus on making games without having to
reinvent the wheel. Games can be exported with one click to a number of
platforms, including the major desktop platforms (Linux, macOS, Windows),
mobile platforms (Android, iOS), as well as Web-based platforms and consoles.
Godot is completely free and open source under the
permissive MIT
license
. No strings attached, no royalties,
nothing. Users' games are theirs, down to the last line of engine code.
Godot's development is fully independent and community-driven, empowering
users to help shape their engine to match their expectations.
It is supported by the
Godot Foundation
not-for-profit.
Organization of the documentation

This documentation is organized into several sections:
About
contains this introduction as well as
information about the engine, its history, its licensing, authors, etc. It
also contains the
Frequently asked questions
.
Getting Started
contains all necessary information on using the engine to
make games. It starts with the
Introduction
section which
should be the entry point for all new users.
This is the best place to start
if you're new!
The
Manual
can be read or referenced as needed,
in any order. It contains feature-specific tutorials and documentation.
Engine details
contains sections intended for advanced users and contributors,
with information on compiling the engine, working on the editor,
or developing C++ modules.
Community
is dedicated to the life of Godot's community and contains a list of
recommended third-party tutorials and materials outside of this documentation.
It also provides details on the Asset Library. It also used to list Godot
communities, which are now listed on the
Godot website
.
Finally, the
Class reference
documents the full Godot API,
also available directly within the engine's script editor.
You can find information on all classes, functions, signals and so on here.
In addition to this documentation, you may also want to take a look at the
various
Godot demo projects
.
About this documentation

Members of the Godot Engine community continuously write, correct, edit, and
improve this documentation. We are always looking for more help. You can also
contribute by opening Github issues or translating the documentation into your language.
If you are interested in helping, see
How to contribute
and
Writing documentation
,
or get in touch with the
Documentation team
on
Godot Contributors Chat
.
All documentation content is licensed under the permissive Creative Commons Attribution 3.0
(
CC BY 3.0
) license,
with attribution to "
Juan Linietsky, Ariel Manzur, and the Godot Engine community
"
unless otherwise noted.
Have fun reading and making games with Godot Engine!
/no_think

Conversion Response Finish Reason

stop

Conversion Response Content

[
  {
    "chunk_id": "godot-stable:pages/about__introduction__344b3840.md#section-0001",
    "doc_version": "4.6",
    "source_url": "https://docs.godotengine.org/en/stable/about/introduction.html",
    "source_file": "pages/about__introduction__344b3840.md",
    "source_sha256": "f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d",
    "doc_type": "about",
    "symbol": "",
    "section_path": [
      "Introduction"
    ],
    "heading": "Introduction",
    "content": "GDScript\nC#\nfunc _ready():\n    print(\"Hello world!\")\n\npublic override void _Ready()\n{\n    GD.Print(\"Hello world!\");\n}\n\nWelcome to the official documentation of Godot Engine, the free and open source community-driven 2D and 3D game engine! Behind this mouthful, you will find a powerful yet user-friendly tool that you can use to develop any kind of game, for any platform and with no usage restriction whatsoever.\nThis page gives a broad overview of the engine and of this documentation, so that you know where to start if you are a beginner or where to look if you need information on a specific feature.",
    "code_blocks": [
      "func _ready():\n    print(\"Hello world!\")",
      "public override void _Ready()\n{\n    GD.Print(\"Hello world!\");\n}"
    ],
    "language_tags": [
      "gdscript",
      "csharp"
    ],
    "godot_version_tags": [
      "4.6"
    ],
    "api_symbols": [
      "_ready",
      "_Ready",
      "GD.Print",
      "print"
    ],
    "token_count": 165,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__introduction__344b3840.md#section-0002",
    "doc_version": "4.6",
    "source_url": "https://docs.godotengine.org/en/stable/about/introduction.html",
    "source_file": "pages/about__introduction__344b3840.md",
    "source_sha256": "f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d",
    "doc_type": "about",
    "symbol": "",
    "section_path": [
      "Introduction",
      "Before you start"
    ],
    "heading": "Before you start",
    "content": "The Tutorials and resources page lists video tutorials contributed by the community. If you prefer video to text, consider checking them out. Otherwise, Getting Started is a great starting point.\nIn case you have trouble with one of the tutorials or your project, you can find help on the various Community channels, especially the Godot Discord community and Forum.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": [
      "4.6"
    ],
    "api_symbols": [],
    "token_count": 110,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__introduction__344b3840.md#section-0003",
    "doc_version": "4.6",
    "source_url": "https://docs.godotengine.org/en/stable/about/introduction.html",
    "source_file": "pages/about__introduction__344b3840.md",
    "source_sha256": "f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d",
    "doc_type": "about",
    "symbol": "",
    "section_path": [
      "Introduction",
      "About Godot Engine"
    ],
    "heading": "About Godot Engine",
    "content": "A game engine is a complex tool and difficult to present in a few words. Here's a quick synopsis, which you are free to reuse if you need a quick write-up about Godot Engine:\nGodot Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so that users can focus on making games without having to reinvent the wheel. Games can be exported with one click to a number of platforms, including the major desktop platforms (Linux, macOS, Windows), mobile platforms (Android, iOS), as well as Web-based platforms and consoles.\nGodot is completely free and open source under the permissive MIT license. No strings attached, no royalties, nothing. Users' games are theirs, down to the last line of engine code.\nGodot's development is fully independent and community-driven, empowering users to help shape their engine to match their expectations.\nIt is supported by the Godot Foundation not-for-profit.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": [
      "4.6"
    ],
    "api_symbols": [],
    "token_count": 185,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__introduction__344b3840.md#section-0004",
    "doc_version": "4.6",
    "source_url": "https://docs.godotengine.org/en/stable/about/introduction.html",
    "source_file": "pages/about__introduction__344b3840.md",
    "source_sha256": "f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d",
    "doc_type": "about",
    "symbol": "",
    "section_path": [
      "Introduction",
      "Organization of the documentation"
    ],
    "heading": "Organization of the documentation",
    "content": "This documentation is organized into several sections:\nAbout contains this introduction as well as information about the engine, its history, its licensing, authors, etc. It also contains the Frequently asked questions.\nGetting Started contains all necessary information on using the engine to make games. It starts with the Introduction section which should be the entry point for all new users. This is the best place to start if you're new!\nThe Manual can be read or referenced as needed, in any order. It contains feature-specific tutorials and documentation.\nEngine details contains sections intended for advanced users and contributors, with information on compiling the engine, working on the editor, or developing C++ modules.\nCommunity is dedicated to the life of Godot's community and contains a list of recommended third-party tutorials and materials outside of this documentation. It also provides details on the Asset Library. It also used to list Godot communities, which are now listed on the Godot website.\nFinally, the Class reference documents the full Godot API, also available directly within the engine's script editor.\nYou can find information on all classes, functions, signals and so on here.\nIn addition to this documentation, you may also want to take a look at the various Godot demo projects.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": [
      "4.6"
    ],
    "api_symbols": [],
    "token_count": 210,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__introduction__344b3840.md#section-0005",
    "doc_version": "4.6",
    "source_url": "https://docs.godotengine.org/en/stable/about/introduction.html",
    "source_file": "pages/about__introduction__344b3840.md",
    "source_sha256": "f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d",
    "doc_type": "about",
    "symbol": "",
    "section_path": [
      "Introduction",
      "About this documentation"
    ],
    "heading": "About this documentation",
    "content": "Members of the Godot Engine community continuously write, correct, edit, and improve this documentation. We are always looking for more help. You can also contribute by opening Github issues or translating the documentation into your language.\nIf you are interested in helping, see How to contribute and Writing documentation, or get in touch with the Documentation team on Godot Contributors Chat.\nAll documentation content is licensed under the permissive Creative Commons Attribution 3.0 (CC BY 3.0) license, with attribution to \"Juan Linietsky, Ariel Manzur, and the Godot Engine community\" unless otherwise noted.\nHave fun reading and making games with Godot Engine!",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": [
      "4.6"
    ],
    "api_symbols": [],
    "token_count": 155,
    "metadata": {}
  }
]

Conversion Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Target Table:** `docs_chunks`
   - **Required Fields:** `chunk_id`, `doc_version`, `source_url`, `source_file`, `source_sha256`, `doc_type`, `symbol`, `section_path`, `heading`, `content`, `code_blocks`, `language_tags`, `godot_version_tags`, `api_symbols`, `token_count`, `metadata`
   - **Rules:**
     - `chunk_id`: Must match `^godot-\w+:\S+`. Use deterministic like `godot-stable:pages/about__intro.md#section-0001`. Never `chunk_0` or plain numeric.
     - `doc_version`: e.g., `stable`, `latest`, `4.6`, `unknown`.
     - `source_url`: original docs URL if known, else `""`.
     - `source_file`: MUST be `pages/about__introduction__344b3840.md`.
     - `source_sha256`: MUST be `f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d`.
     - `doc_type`: exactly one of `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. Never `article`.
     - `symbol`: class/API symbol or `""`.
     - `section_path`: list of strings (heading hierarchy).
     - `heading`: section heading.
     - `content`: searchable body text.
     - `code_blocks`: list of strings.
     - `language_tags`: list of strings.
     - `godot_version_tags`: list of strings.
     - `api_symbols`: list of strings.
     - `token_count`: int.
     - `metadata`: dict.
   - **Input Markdown:** Contains an introduction page for Godot Engine 4.6. It has sections: "Introduction", "Before you start", "About Godot Engine", "Organization of the documentation", "About this documentation". It includes code blocks for GDScript and C#.
   - **Output Format:** JSON array only. No markdown fences. No comments.

2.  **Determine Chunking Strategy:**
   The prompt asks for "documentation chunk records". I should split the markdown into logical chunks based on headings. I'll create one record per major section to keep it structured, or maybe just one record for the whole page if it's short, but splitting by headings is safer for RAG. Let's split by the main headings provided in the markdown:
   - Chunk 1: Introduction (main heading)
   - Chunk 2: Before you start
   - Chunk 3: About Godot Engine
   - Chunk 4: Organization of the documentation
   - Chunk 5: About this documentation

   Wait, the prompt says "Return a JSON array of documentation chunk records." I'll generate one record per section to be safe, or maybe just one comprehensive record. Given the strict schema, I'll create one record per section. Actually, it's often better to just output one record for the whole page if it's a single document, but splitting is fine. I'll stick to one record per section to demonstrate the schema properly, or just one record for the entire text. Let's do one record per section for clarity, but I need to make sure `chunk_id` matches the regex. I'll generate 5 records.

   Let's extract data for each section:
   - `doc_version`: "4.6" (from "Godot Engine 4.6 documentation")
   - `source_url`: "https://docs.godotengine.org/en/stable/about/introduction.html"
   - `source_file`: "pages/about__introduction__344b3840.md"
   - `source_sha256`: "f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d"
   - `doc_type`: "about"
   - `symbol`: ""
   - `section_path`: ["Introduction"] etc.
   - `heading`: matches section_path[0] or the actual heading.
   - `content`: text under the heading.
   - `code_blocks`: extract from the markdown.
   - `language_tags`: ["gdscript", "csharp"]
   - `godot_version_tags`: ["4.6"]
   - `api_symbols`: ["_ready", "_Ready", "GD.Print", "print"]
   - `token_count`: estimate (e.g., 150 per chunk)
   - `metadata`: {}

   Let's carefully parse the markdown to extract content for each chunk.

   **Chunk 1: Introduction**
   Heading: "Introduction"
   Content: "GDScript\nC#\nfunc _ready():\n    print(\"Hello world!\")\n\npublic override void _Ready()\n{\n    GD.Print(\"Hello world!\");\n}\n\nWelcome to the official documentation of Godot Engine, the free and open source community-driven 2D and 3D game engine! Behind this mouthful, you will find a powerful yet user-friendly tool that you can use to develop any kind of game, for any platform and with no usage restriction whatsoever.\nThis page gives a broad overview of the engine and of this documentation, so that you know where to start if you are a beginner or where to look if you need information on a specific feature."
   Code blocks: ["func _ready():\n    print(\"Hello world!\")", "public override void _Ready()\n{\n    GD.Print(\"Hello world!\");\n}"]
   Language tags: ["gdscript", "csharp"]
   API symbols: ["_ready", "_Ready", "GD.Print", "print"]
   Section path: ["Introduction"]
   Chunk ID: `godot-stable:pages/about__introduction__344b3840.md#section-0001`

   **Chunk 2: Before you start**
   Heading: "Before you start"
   Content: "The Tutorials and resources page lists video tutorials contributed by the community. If you prefer video to text, consider checking them out. Otherwise, Getting Started is a great starting point.\nIn case you have trouble with one of the tutorials or your project, you can find help on the various Community channels, especially the Godot Discord community and Forum."
   Code blocks: []
   Language tags: []
   API symbols: []
   Section path: ["Introduction", "Before you start"]
   Chunk ID: `godot-stable:pages/about__introduction__344b3840.md#section-0002`

   **Chunk 3: About Godot Engine**
   Heading: "About Godot Engine"
   Content: "A game engine is a complex tool and difficult to present in a few words. Here's a quick synopsis, which you are free to reuse if you need a quick write-up about Godot Engine:\nGodot Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so that users can focus on making games without having to reinvent the wheel. Games can be exported with one click to a number of platforms, including the major desktop platforms (Linux, macOS, Windows), mobile platforms (Android, iOS), as well as Web-based platforms and consoles.\nGodot is completely free and open source under the permissive MIT license. No strings attached, no royalties, nothing. Users' games are theirs, down to the last line of engine code.\nGodot's development is fully independent and community-driven, empowering users to help shape their engine to match their expectations.\nIt is supported by the Godot Foundation not-for-profit."
   Code blocks: []
   Language tags: []
   API symbols: []
   Section path: ["Introduction", "About Godot Engine"]
   Chunk ID: `godot-stable:pages/about__introduction__344b3840.md#section-0003`

   **Chunk 4: Organization of the documentation**
   Heading: "Organization of the documentation"
   Content: "This documentation is organized into several sections:\nAbout contains this introduction as well as information about the engine, its history, its licensing, authors, etc. It also contains the Frequently asked questions.\nGetting Started contains all necessary information on using the engine to make games. It starts with the Introduction section which should be the entry point for all new users. This is the best place to start if you're new!\nThe Manual can be read or referenced as needed, in any order. It contains feature-specific tutorials and documentation.\nEngine details contains sections intended for advanced users and contributors, with information on compiling the engine, working on the editor, or developing C++ modules.\nCommunity is dedicated to the life of Godot's community and contains a list of recommended third-party tutorials and materials outside of this documentation. It also provides details on the Asset Library. It also used to list Godot communities, which are now listed on the Godot website.\nFinally, the Class reference documents the full Godot API, also available directly within the engine's script editor.\nYou can find information on all classes, functions, signals and so on here.\nIn addition to this documentation, you may also want to take a look at the various Godot demo projects."
   Code blocks: []
   Language tags: []
   API symbols: []
   Section path: ["Introduction", "Organization of the documentation"]
   Chunk ID: `godot-stable:pages/about__introduction__344b3840.md#section-0004`

   **Chunk 5: About this documentation**
   Heading: "About this documentation"
   Content: "Members of the Godot Engine community continuously write, correct, edit, and improve this documentation. We are always looking for more help. You can also contribute by opening Github issues or translating the documentation into your language.\nIf you are interested in helping, see How to contribute and Writing documentation, or get in touch with the Documentation team on Godot Contributors Chat.\nAll documentation content is licensed under the permissive Creative Commons Attribution 3.0 (CC BY 3.0) license, with attribution to \"Juan Linietsky, Ariel Manzur, and the Godot Engine community\" unless otherwise noted.\nHave fun reading and making games with Godot Engine!"
   Code blocks: []
   Language tags: []
   API symbols: []
   Section path: ["Introduction", "About this documentation"]
   Chunk ID: `godot-stable:pages/about__introduction__344b3840.md#section-0005`

   Let's verify fields against requirements:
   - `chunk_id`: matches `^godot-\w+:\S+` -> `godot-stable:pages/about__introduction__344b3840.md#section-0001` etc. Good.
   - `doc_version`: "4.6" or "stable". I'll use "4.6".
   - `source_url`: "https://docs.godotengine.org/en/stable/about/introduction.html"
   - `source_file`: "pages/about__introduction__344b3840.md"
   - `source_sha256`: "f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d"
   - `doc_type`: "about"
   - `symbol`: ""
   - `section_path`: list of strings
   - `heading`: string
   - `content`: string
   - `code_blocks`: list of strings
   - `language_tags`: list of strings
   - `godot_version_tags`: list of strings
   - `api_symbols`: list of strings
   - `token_count`: int (I'll estimate ~100-200 per chunk)
   - `metadata`: dict

   I will construct the JSON array carefully. I'll make sure all fields are present and correctly typed.
   One detail: `code_blocks` in the markdown are formatted with newlines. I'll preserve them as strings.
   `language_tags`: ["gdscript", "csharp"]
   `godot_version_tags`: ["4.6"]
   `api_symbols`: ["_ready", "_Ready", "GD.Print", "print"]
   `token_count`: I'll put reasonable estimates like 150, 120, 180, 200, 160.
   `metadata`: {}

   Let's draft the JSON.
   Check regex for chunk_id: `^godot-\w+:\S+` -> `godot-stable:pages/about__introduction__344b3840.md#section-0001` matches.
   All good.

   I will generate the JSON array now.
   One minor thing: The prompt says "Never return chunk_0 or plain numeric IDs." My IDs follow the pattern.
   I'll ensure strict JSON formatting.
   I'll combine everything into a single array.
   Ready. 
   Output matches requirements.
   Proceeds. 
   Self-Correction/Refinement during thought: 
   Should I include the code blocks in the first chunk only? Yes, they appear under "Introduction".
   I'll make sure `content` doesn't include the markdown formatting artifacts like `` or `Copy to clipboard`.
   I'll clean up the content strings slightly to be plain text as requested ("searchable body text").
   All fields are strictly typed.
   I will produce the JSON now. 
   Structure:
   [
     { ... },
     { ... },
     ...
   ]
   No markdown fences.
   Done. 
   Output generation. 
   [Proceeds]

Raw Conversion Response

{
  "finish_reason": "stop",
  "content": "[\n  {\n    \"chunk_id\": \"godot-stable:pages/about__introduction__344b3840.md#section-0001\",\n    \"doc_version\": \"4.6\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/introduction.html\",\n    \"source_file\": \"pages/about__introduction__344b3840.md\",\n    \"source_sha256\": \"f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\n      \"Introduction\"\n    ],\n    \"heading\": \"Introduction\",\n    \"content\": \"GDScript\\nC#\\nfunc _ready():\\n    print(\\\"Hello world!\\\")\\n\\npublic override void _Ready()\\n{\\n    GD.Print(\\\"Hello world!\\\");\\n}\\n\\nWelcome to the official documentation of Godot Engine, the free and open source community-driven 2D and 3D game engine! Behind this mouthful, you will find a powerful yet user-friendly tool that you can use to develop any kind of game, for any platform and with no usage restriction whatsoever.\\nThis page gives a broad overview of the engine and of this documentation, so that you know where to start if you are a beginner or where to look if you need information on a specific feature.\",\n    \"code_blocks\": [\n      \"func _ready():\\n    print(\\\"Hello world!\\\")\",\n      \"public override void _Ready()\\n{\\n    GD.Print(\\\"Hello world!\\\");\\n}\"\n    ],\n    \"language_tags\": [\n      \"gdscript\",\n      \"csharp\"\n    ],\n    \"godot_version_tags\": [\n      \"4.6\"\n    ],\n    \"api_symbols\": [\n      \"_ready\",\n      \"_Ready\",\n      \"GD.Print\",\n      \"print\"\n    ],\n    \"token_count\": 165,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__introduction__344b3840.md#section-0002\",\n    \"doc_version\": \"4.6\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/introduction.html\",\n    \"source_file\": \"pages/about__introduction__344b3840.md\",\n    \"source_sha256\": \"f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\n      \"Introduction\",\n      \"Before you start\"\n    ],\n    \"heading\": \"Before you start\",\n    \"content\": \"The Tutorials and resources page lists video tutorials contributed by the community. If you prefer video to text, consider checking them out. Otherwise, Getting Started is a great starting point.\\nIn case you have trouble with one of the tutorials or your project, you can find help on the various Community channels, especially the Godot Discord community and Forum.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\n      \"4.6\"\n    ],\n    \"api_symbols\": [],\n    \"token_count\": 110,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__introduction__344b3840.md#section-0003\",\n    \"doc_version\": \"4.6\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/introduction.html\",\n    \"source_file\": \"pages/about__introduction__344b3840.md\",\n    \"source_sha256\": \"f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\n      \"Introduction\",\n      \"About Godot Engine\"\n    ],\n    \"heading\": \"About Godot Engine\",\n    \"content\": \"A game engine is a complex tool and difficult to present in a few words. Here's a quick synopsis, which you are free to reuse if you need a quick write-up about Godot Engine:\\nGodot Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so that users can focus on making games without having to reinvent the wheel. Games can be exported with one click to a number of platforms, including the major desktop platforms (Linux, macOS, Windows), mobile platforms (Android, iOS), as well as Web-based platforms and consoles.\\nGodot is completely free and open source under the permissive MIT license. No strings attached, no royalties, nothing. Users' games are theirs, down to the last line of engine code.\\nGodot's development is fully independent and community-driven, empowering users to help shape their engine to match their expectations.\\nIt is supported by the Godot Foundation not-for-profit.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\n      \"4.6\"\n    ],\n    \"api_symbols\": [],\n    \"token_count\": 185,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__introduction__344b3840.md#section-0004\",\n    \"doc_version\": \"4.6\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/introduction.html\",\n    \"source_file\": \"pages/about__introduction__344b3840.md\",\n    \"source_sha256\": \"f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\n      \"Introduction\",\n      \"Organization of the documentation\"\n    ],\n    \"heading\": \"Organization of the documentation\",\n    \"content\": \"This documentation is organized into several sections:\\nAbout contains this introduction as well as information about the engine, its history, its licensing, authors, etc. It also contains the Frequently asked questions.\\nGetting Started contains all necessary information on using the engine to make games. It starts with the Introduction section which should be the entry point for all new users. This is the best place to start if you're new!\\nThe Manual can be read or referenced as needed, in any order. It contains feature-specific tutorials and documentation.\\nEngine details contains sections intended for advanced users and contributors, with information on compiling the engine, working on the editor, or developing C++ modules.\\nCommunity is dedicated to the life of Godot's community and contains a list of recommended third-party tutorials and materials outside of this documentation. It also provides details on the Asset Library. It also used to list Godot communities, which are now listed on the Godot website.\\nFinally, the Class reference documents the full Godot API, also available directly within the engine's script editor.\\nYou can find information on all classes, functions, signals and so on here.\\nIn addition to this documentation, you may also want to take a look at the various Godot demo projects.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\n      \"4.6\"\n    ],\n    \"api_symbols\": [],\n    \"token_count\": 210,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__introduction__344b3840.md#section-0005\",\n    \"doc_version\": \"4.6\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/introduction.html\",\n    \"source_file\": \"pages/about__introduction__344b3840.md\",\n    \"source_sha256\": \"f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\n      \"Introduction\",\n      \"About this documentation\"\n    ],\n    \"heading\": \"About this documentation\",\n    \"content\": \"Members of the Godot Engine community continuously write, correct, edit, and improve this documentation. We are always looking for more help. You can also contribute by opening Github issues or translating the documentation into your language.\\nIf you are interested in helping, see How to contribute and Writing documentation, or get in touch with the Documentation team on Godot Contributors Chat.\\nAll documentation content is licensed under the permissive Creative Commons Attribution 3.0 (CC BY 3.0) license, with attribution to \\\"Juan Linietsky, Ariel Manzur, and the Godot Engine community\\\" unless otherwise noted.\\nHave fun reading and making games with Godot Engine!\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\n      \"4.6\"\n    ],\n    \"api_symbols\": [],\n    \"token_count\": 155,\n    \"metadata\": {}\n  }\n]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Target Table:** `docs_chunks`\n   - **Required Fields:** `chunk_id`, `doc_version`, `source_url`, `source_file`, `source_sha256`, `doc_type`, `symbol`, `section_path`, `heading`, `content`, `code_blocks`, `language_tags`, `godot_version_tags`, `api_symbols`, `token_count`, `metadata`\n   - **Rules:**\n     - `chunk_id`: Must match `^godot-\\w+:\\S+`. Use deterministic like `godot-stable:pages/about__intro.md#section-0001`. Never `chunk_0` or plain numeric.\n     - `doc_version`: e.g., `stable`, `latest`, `4.6`, `unknown`.\n     - `source_url`: original docs URL if known, else `\"\"`.\n     - `source_file`: MUST be `pages/about__introduction__344b3840.md`.\n     - `source_sha256`: MUST be `f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d`.\n     - `doc_type`: exactly one of `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. Never `article`.\n     - `symbol`: class/API symbol or `\"\"`.\n     - `section_path`: list of strings (heading hierarchy).\n     - `heading`: section heading.\n     - `content`: searchable body text.\n     - `code_blocks`: list of strings.\n     - `language_tags`: list of strings.\n     - `godot_version_tags`: list of strings.\n     - `api_symbols`: list of strings.\n     - `token_count`: int.\n     - `metadata`: dict.\n   - **Input Markdown:** Contains an introduction page for Godot Engine 4.6. It has sections: \"Introduction\", \"Before you start\", \"About Godot Engine\", \"Organization of the documentation\", \"About this documentation\". It includes code blocks for GDScript and C#.\n   - **Output Format:** JSON array only. No markdown fences. No comments.\n\n2.  **Determine Chunking Strategy:**\n   The prompt asks for \"documentation chunk records\". I should split the markdown into logical chunks based on headings. I'll create one record per major section to keep it structured, or maybe just one record for the whole page if it's short, but splitting by headings is safer for RAG. Let's split by the main headings provided in the markdown:\n   - Chunk 1: Introduction (main heading)\n   - Chunk 2: Before you start\n   - Chunk 3: About Godot Engine\n   - Chunk 4: Organization of the documentation\n   - Chunk 5: About this documentation\n\n   Wait, the prompt says \"Return a JSON array of documentation chunk records.\" I'll generate one record per section to be safe, or maybe just one comprehensive record. Given the strict schema, I'll create one record per section. Actually, it's often better to just output one record for the whole page if it's a single document, but splitting is fine. I'll stick to one record per section to demonstrate the schema properly, or just one record for the entire text. Let's do one record per section for clarity, but I need to make sure `chunk_id` matches the regex. I'll generate 5 records.\n\n   Let's extract data for each section:\n   - `doc_version`: \"4.6\" (from \"Godot Engine 4.6 documentation\")\n   - `source_url`: \"https://docs.godotengine.org/en/stable/about/introduction.html\"\n   - `source_file`: \"pages/about__introduction__344b3840.md\"\n   - `source_sha256`: \"f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d\"\n   - `doc_type`: \"about\"\n   - `symbol`: \"\"\n   - `section_path`: [\"Introduction\"] etc.\n   - `heading`: matches section_path[0] or the actual heading.\n   - `content`: text under the heading.\n   - `code_blocks`: extract from the markdown.\n   - `language_tags`: [\"gdscript\", \"csharp\"]\n   - `godot_version_tags`: [\"4.6\"]\n   - `api_symbols`: [\"_ready\", \"_Ready\", \"GD.Print\", \"print\"]\n   - `token_count`: estimate (e.g., 150 per chunk)\n   - `metadata`: {}\n\n   Let's carefully parse the markdown to extract content for each chunk.\n\n   **Chunk 1: Introduction**\n   Heading: \"Introduction\"\n   Content: \"GDScript\\nC#\\nfunc _ready():\\n    print(\\\"Hello world!\\\")\\n\\npublic override void _Ready()\\n{\\n    GD.Print(\\\"Hello world!\\\");\\n}\\n\\nWelcome to the official documentation of Godot Engine, the free and open source community-driven 2D and 3D game engine! Behind this mouthful, you will find a powerful yet user-friendly tool that you can use to develop any kind of game, for any platform and with no usage restriction whatsoever.\\nThis page gives a broad overview of the engine and of this documentation, so that you know where to start if you are a beginner or where to look if you need information on a specific feature.\"\n   Code blocks: [\"func _ready():\\n    print(\\\"Hello world!\\\")\", \"public override void _Ready()\\n{\\n    GD.Print(\\\"Hello world!\\\");\\n}\"]\n   Language tags: [\"gdscript\", \"csharp\"]\n   API symbols: [\"_ready\", \"_Ready\", \"GD.Print\", \"print\"]\n   Section path: [\"Introduction\"]\n   Chunk ID: `godot-stable:pages/about__introduction__344b3840.md#section-0001`\n\n   **Chunk 2: Before you start**\n   Heading: \"Before you start\"\n   Content: \"The Tutorials and resources page lists video tutorials contributed by the community. If you prefer video to text, consider checking them out. Otherwise, Getting Started is a great starting point.\\nIn case you have trouble with one of the tutorials or your project, you can find help on the various Community channels, especially the Godot Discord community and Forum.\"\n   Code blocks: []\n   Language tags: []\n   API symbols: []\n   Section path: [\"Introduction\", \"Before you start\"]\n   Chunk ID: `godot-stable:pages/about__introduction__344b3840.md#section-0002`\n\n   **Chunk 3: About Godot Engine**\n   Heading: \"About Godot Engine\"\n   Content: \"A game engine is a complex tool and difficult to present in a few words. Here's a quick synopsis, which you are free to reuse if you need a quick write-up about Godot Engine:\\nGodot Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so that users can focus on making games without having to reinvent the wheel. Games can be exported with one click to a number of platforms, including the major desktop platforms (Linux, macOS, Windows), mobile platforms (Android, iOS), as well as Web-based platforms and consoles.\\nGodot is completely free and open source under the permissive MIT license. No strings attached, no royalties, nothing. Users' games are theirs, down to the last line of engine code.\\nGodot's development is fully independent and community-driven, empowering users to help shape their engine to match their expectations.\\nIt is supported by the Godot Foundation not-for-profit.\"\n   Code blocks: []\n   Language tags: []\n   API symbols: []\n   Section path: [\"Introduction\", \"About Godot Engine\"]\n   Chunk ID: `godot-stable:pages/about__introduction__344b3840.md#section-0003`\n\n   **Chunk 4: Organization of the documentation**\n   Heading: \"Organization of the documentation\"\n   Content: \"This documentation is organized into several sections:\\nAbout contains this introduction as well as information about the engine, its history, its licensing, authors, etc. It also contains the Frequently asked questions.\\nGetting Started contains all necessary information on using the engine to make games. It starts with the Introduction section which should be the entry point for all new users. This is the best place to start if you're new!\\nThe Manual can be read or referenced as needed, in any order. It contains feature-specific tutorials and documentation.\\nEngine details contains sections intended for advanced users and contributors, with information on compiling the engine, working on the editor, or developing C++ modules.\\nCommunity is dedicated to the life of Godot's community and contains a list of recommended third-party tutorials and materials outside of this documentation. It also provides details on the Asset Library. It also used to list Godot communities, which are now listed on the Godot website.\\nFinally, the Class reference documents the full Godot API, also available directly within the engine's script editor.\\nYou can find information on all classes, functions, signals and so on here.\\nIn addition to this documentation, you may also want to take a look at the various Godot demo projects.\"\n   Code blocks: []\n   Language tags: []\n   API symbols: []\n   Section path: [\"Introduction\", \"Organization of the documentation\"]\n   Chunk ID: `godot-stable:pages/about__introduction__344b3840.md#section-0004`\n\n   **Chunk 5: About this documentation**\n   Heading: \"About this documentation\"\n   Content: \"Members of the Godot Engine community continuously write, correct, edit, and improve this documentation. We are always looking for more help. You can also contribute by opening Github issues or translating the documentation into your language.\\nIf you are interested in helping, see How to contribute and Writing documentation, or get in touch with the Documentation team on Godot Contributors Chat.\\nAll documentation content is licensed under the permissive Creative Commons Attribution 3.0 (CC BY 3.0) license, with attribution to \\\"Juan Linietsky, Ariel Manzur, and the Godot Engine community\\\" unless otherwise noted.\\nHave fun reading and making games with Godot Engine!\"\n   Code blocks: []\n   Language tags: []\n   API symbols: []\n   Section path: [\"Introduction\", \"About this documentation\"]\n   Chunk ID: `godot-stable:pages/about__introduction__344b3840.md#section-0005`\n\n   Let's verify fields against requirements:\n   - `chunk_id`: matches `^godot-\\w+:\\S+` -> `godot-stable:pages/about__introduction__344b3840.md#section-0001` etc. Good.\n   - `doc_version`: \"4.6\" or \"stable\". I'll use \"4.6\".\n   - `source_url`: \"https://docs.godotengine.org/en/stable/about/introduction.html\"\n   - `source_file`: \"pages/about__introduction__344b3840.md\"\n   - `source_sha256`: \"f6f475530882770c0c5d8e65102df587bc04d92fd761f96a0c596633f93d7f1d\"\n   - `doc_type`: \"about\"\n   - `symbol`: \"\"\n   - `section_path`: list of strings\n   - `heading`: string\n   - `content`: string\n   - `code_blocks`: list of strings\n   - `language_tags`: list of strings\n   - `godot_version_tags`: list of strings\n   - `api_symbols`: list of strings\n   - `token_count`: int (I'll estimate ~100-200 per chunk)\n   - `metadata`: dict\n\n   I will construct the JSON array carefully. I'll make sure all fields are present and correctly typed.\n   One detail: `code_blocks` in the markdown are formatted with newlines. I'll preserve them as strings.\n   `language_tags`: [\"gdscript\", \"csharp\"]\n   `godot_version_tags`: [\"4.6\"]\n   `api_symbols`: [\"_ready\", \"_Ready\", \"GD.Print\", \"print\"]\n   `token_count`: I'll put reasonable estimates like 150, 120, 180, 200, 160.\n   `metadata`: {}\n\n   Let's draft the JSON.\n   Check regex for chunk_id: `^godot-\\w+:\\S+` -> `godot-stable:pages/about__introduction__344b3840.md#section-0001` matches.\n   All good.\n\n   I will generate the JSON array now.\n   One minor thing: The prompt says \"Never return chunk_0 or plain numeric IDs.\" My IDs follow the pattern.\n   I'll ensure strict JSON formatting.\n   I'll combine everything into a single array.\n   Ready. \n   Output matches requirements.\n   Proceeds. \n   Self-Correction/Refinement during thought: \n   Should I include the code blocks in the first chunk only? Yes, they appear under \"Introduction\".\n   I'll make sure `content` doesn't include the markdown formatting artifacts like `` or `Copy to clipboard`.\n   I'll clean up the content strings slightly to be plain text as requested (\"searchable body text\").\n   All fields are strictly typed.\n   I will produce the JSON now. \n   Structure:\n   [\n     { ... },\n     { ... },\n     ...\n   ]\n   No markdown fences.\n   Done. \n   Output generation. \n   [Proceeds]\n"
}

5. pages/about__list_of_features__273abdc4.md::docs_chunks

stage: conversion
api_url: [redacted]
model: [redacted]
table: docs_chunks
markdown_length: 29009
prompt_length: 30529
response_saved: False

Request Message Summary

[
  {
    "role": "system",
    "content_length": 193
  },
  {
    "role": "user",
    "content_length": 30529
  }
]

Full Conversion Prompt Sent To Qwen

Table: docs_chunks
Return a JSON array of documentation chunk records.
Required fields and exact rules:
  - chunk_id (str): MUST match regex ^godot-\w+:\S+. Use a deterministic value like godot-stable:pages/about__intro.md#section-0001. Never return chunk_0 or plain numeric IDs.
  - doc_version (str): docs version such as stable, latest, 4.6, or unknown.
  - source_url (str): original docs URL if known, otherwise empty string.
  - source_file (str): exact local markdown path provided by the caller.
  - source_sha256 (str): exact sha256 provided by the caller.
  - doc_type (str): exactly one of class_reference, tutorial, migration, engine_details, about, other. Never use article.
  - symbol (str): class/API symbol or empty string.
  - section_path (list[str]): heading hierarchy.
  - heading (str): section heading.
  - content (str): searchable body text.
  - code_blocks (list[str]): extracted code blocks.
  - language_tags (list[str]): detected code languages.
  - godot_version_tags (list[str]): version hints.
  - api_symbols (list[str]): detected Godot symbols.
  - token_count (int): estimated token count.
  - metadata (dict): any extra metadata.
Return only valid JSON. No markdown. No comments.

Target table: docs_chunks
Source file that MUST be written into source_file fields: pages/about__list_of_features__273abdc4.md
Source sha256 that MUST be written into source_sha256 fields when the field exists: 0d827d8e1964bba0f57b76d6f6efa27e72e166000daaae439c319b58ee698980

--- MARKDOWN ---
# Source: https://docs.godotengine.org/en/stable/about/list_of_features.html

Godot Engine 4.6 documentation in English
List of features
Edit on GitHub
Learn how to contribute!
List of features

This page aims to list
all
features currently supported by Godot.
Note
This page lists features supported by the current stable version of
Godot. Some of these features are not available in the
3.x release series
.
Platforms

See also
See
System requirements
for hardware and software version requirements.
Note
For information about console support, see the
Godot website
.
Can run both the editor and exported projects:
Windows (x86 and ARM, 64-bit and 32-bit).
macOS (x86 and ARM, 64-bit only).
Linux (x86 and ARM, 64-bit and 32-bit).
Binaries are statically linked and can run on any distribution if compiled
on an old enough base distribution.
Official binaries are compiled using the
Godot Engine buildroot
,
allowing for binaries that work across common Linux distributions.
Android (editor support is experimental).
Web browsers
. Experimental in 4.0,
using Godot 3.x is recommended instead when targeting HTML5.
Note
Linux supports rv64 (RISC-V), ppc64 & ppc32 (PowerPC), and loongarch64. However
you must compile the editor for that platform (as well as export templates)
yourself, no official downloads are currently provided. RISC-V compiling
instructions can be found on the
Compiling for Linux, *BSD
page.
Runs exported projects:
iOS.
Godot aims to be as platform-independent as possible and can be
ported to new platforms
with relative ease.
Note
Projects written in C# using Godot 4 currently cannot be exported to the
web platform. To use C# on that platform, consider Godot 3 instead.
Android and iOS platform support is available as of Godot 4.2, but is
experimental and
some limitations apply
.
Editor

Features:
Scene tree editor.
Built-in script editor.
Support for
external script editors
such as
Visual Studio Code or Vim.
GDScript
debugger
.
Support for debugging in threads is available since 4.2.
Visual profiler with CPU and GPU time indications for each step of the
rendering pipeline.
Performance monitoring tools, including
custom performance monitors
.
Live script reloading.
Live scene editing.
Changes will reflect in the editor and will be kept after closing the running project.
Remote inspector.
Changes won't reflect in the editor and won't be kept after closing the running project.
Live camera replication.
Move the in-editor camera and see the result in the running project.
Built-in offline class reference documentation.
Use the editor in dozens of languages contributed by the community.
Plugins:
Editor plugins can be downloaded from the
asset library
to extend editor functionality.
Create your own plugins
using GDScript to add new
features or speed up your workflow.
Download projects from the asset library
in the Project Manager and import them directly.
Rendering

Godot 4 includes three renderers:
Forward+
. The most advanced renderer, suited for desktop platforms only.
Used by default on desktop platforms. This renderer uses
Vulkan
,
Direct3D 12
,
or
Metal
as the rendering driver, and it uses the
RenderingDevice
backend.
Mobile
. Fewer features, but renders simple scenes faster. Suited for mobile
and desktop platforms. Used by default on mobile platforms. This renderer uses
Vulkan
,
Direct3D 12
, or
Metal
as the rendering driver, and it uses
the
RenderingDevice
backend.
Compatibility
, sometimes called
GL Compatibility
. The least advanced
renderer, suited for low-end desktop and mobile platforms. Used by default on
the web platform. This renderer uses
OpenGL
as the rendering driver.
See
Overview of renderers
for a detailed comparison of the rendering methods.
2D graphics

Sprite, polygon and line rendering.
High-level tools to draw lines and polygons such as
Polygon2D
and
Line2D
, with support for texturing.
AnimatedSprite2D as a helper for creating animated sprites.
Parallax layers.
Pseudo-3D support including preview in the editor.
2D lighting
with normal maps and specular maps.
Point (omni/spot) and directional 2D lights.
Hard or soft shadows (adjustable on a per-light basis).
Custom shaders can access a real-time
SDF
representation of the 2D scene based on
LightOccluder2D
nodes,
which can be used for improved 2D lighting effects including 2D global illumination.
Font rendering
using bitmaps, rasterization using FreeType
or multi-channel signed distance fields (MSDF).
Bitmap fonts can be exported using tools like BMFont, or imported from images
(for fixed-width fonts only).
Dynamic fonts support monochrome fonts as well as colored fonts (e.g. for emoji).
Supported formats are TTF, OTF, WOFF1 and WOFF2.
Dynamic fonts support optional font outlines with adjustable width and color.
Dynamic fonts support variable fonts and OpenType features including ligatures.
Dynamic fonts support simulated bold and italic when the font file lacks
those styles.
Dynamic fonts support oversampling to keep fonts sharp at higher resolutions.
Dynamic fonts support subpixel positioning to make fonts crisper at low sizes.
Dynamic fonts support LCD subpixel optimizations to make fonts even crisper at low sizes.
Signed distance field fonts can be scaled at any resolution without
requiring re-rasterization. Multi-channel usage makes SDF fonts scale down
to lower sizes better compared to monochrome SDF fonts.
GPU-based
particles
with support for
custom particle shaders
.
CPU-based particles.
Optional
2D HDR rendering
for better glow capabilities.
2D tools

TileMaps
for 2D tile-based level design.
2D camera with built-in smoothing and drag margins.
Path2D node to represent a path in 2D space.
Can be drawn in the editor or generated procedurally.
PathFollow2D node to make nodes follow a Path2D.
2D geometry helper class
.
2D physics

Physics bodies:
Static bodies.
Animatable bodies (for objects moving only by script or animation, such as doors and platforms).
Rigid bodies.
Character bodies.
Joints.
Areas to detect bodies entering or leaving it.
Collision detection:
Built-in shapes: line, box, circle, capsule, world boundary (infinite plane).
Collision polygons (can be drawn manually or generated from a sprite in the editor).
3D graphics

HDR rendering with sRGB.
Perspective, orthographic and frustum-offset cameras.
When using the Forward+ renderer, a depth prepass is used to improve
performance in complex scenes by reducing the cost of overdraw.
Variable rate shading
on supported GPUs in Forward+ and Mobile.
Physically-based rendering (built-in material features):
Follows the Disney PBR model.
Supports Burley, Lambert, Lambert Wrap (half-Lambert) and Toon diffuse shading modes.
Supports Schlick-GGX, Toon and Disabled specular shading modes.
Uses a roughness-metallic workflow with support for ORM textures.
Uses horizon specular occlusion (Filament model) to improve material appearance.
Normal mapping.
Parallax/relief mapping with automatic level of detail based on distance.
Detail mapping for the albedo and normal maps.
Sub-surface scattering and transmittance.
Screen-space refraction with support for material roughness (resulting in blurry refraction).
Proximity fade (soft particles) and distance fade.
Distance fade can use alpha blending or dithering to avoid going through
the transparent pipeline.
Dithering can be determined on a per-pixel or per-object basis.
Real-time lighting:
Directional lights (sun/moon). Up to 4 per scene.
Omnidirectional lights.
Spot lights with adjustable cone angle and attenuation.
Specular, indirect light, and volumetric fog energy can be adjusted on a per-light basis.
Adjustable light "size" for fake area lights (will also make shadows blurrier).
Optional distance fade system to fade distant lights and their shadows, improving performance.
When using the Forward+ renderer (default on desktop), lights are
rendered with clustered forward optimizations to decrease their individual cost.
Clustered rendering also lifts any limits on the number of lights that can be used on a mesh.
When using the Mobile renderer, up to 8 omni lights and 8 spot lights can
be displayed per mesh resource. Baked lighting can be used to overcome this limit
if needed.
Shadow mapping:
DirectionalLight:
Orthogonal (fastest), PSSM 2-split and 4-split.
Supports blending between splits.
OmniLight:
Dual paraboloid (fast) or cubemap (slower but more accurate).
Supports colored projector textures in the form of panoramas.
SpotLight:
Single texture. Supports colored projector textures.
Shadow normal offset bias and shadow pancaking to decrease the amount of
visible shadow acne and peter-panning.
PCSS
-like shadow blur based on the
light size and distance from the surface the shadow is cast on.
Adjustable shadow blur on a per-light basis.
Global illumination with indirect lighting:
Baked lightmaps
(fast, but can't be updated at runtime).
Supports baking indirect light only or baking both direct and indirect lighting.
The bake mode can be adjusted on a per-light basis to allow for hybrid light
baking setups.
Supports lighting dynamic objects using automatic and manually placed probes.
Optionally supports directional lighting and rough reflections based on spherical
harmonics.
Lightmaps are baked on the GPU using compute shaders (much faster compared
to CPU lightmapping). Baking can only be performed from the editor,
not in exported projects.
Supports GPU-based
denoising
with JNLM, or CPU/GPU-based denoising with OIDN.
Voxel-based GI probes
. Supports
dynamic lights
and
dynamic occluders, while also supporting reflections.
Requires a fast baking step which can be performed in the editor or at
runtime (including from an exported project).
Signed-distance field GI
designed for large open worlds.
Supports dynamic lights, but not dynamic occluders. Supports reflections.
No baking required.
Screen-space indirect lighting (SSIL)
at half or full resolution. Fully real-time and supports any kind of emissive
light source (including decals).
VoxelGI and SDFGI use a deferred pass to allow for rendering GI at half
resolution to improve performance (while still having functional MSAA support).
Reflections:
Voxel-based reflections (when using GI probes) and SDF-based reflections
(when using signed distance field GI). Voxel-based reflections are visible
on transparent surfaces, while rough SDF-based reflections are visible
on transparent surfaces.
Fast baked reflections or slow real-time reflections using ReflectionProbe.
Parallax box correction can optionally be enabled.
Screen-space reflections with support for material roughness.
Reflection techniques can be mixed together for greater accuracy or scalability.
When using the Forward+ renderer (default on desktop), reflection probes are
rendered with clustered forward optimizations to decrease their individual cost.
Clustered rendering also lifts any limits on the number of reflection probes that can be used on a mesh.
When using the Mobile renderer, up to 8 reflection probes can be displayed per mesh
resource. When using the Compatibility renderer, up to 2 reflection probes can
be displayed per mesh resource.
Decals:
Supports albedo
, emissive,
ORM
,
and normal mapping.
Texture channels are smoothly overlaid on top of the underlying material,
with support for normal/ORM-only decals.
Support for normal fade to fade the decal depending on its incidence angle.
Does not rely on runtime mesh generation. This means decals can be used on
complex skinned meshes with no performance penalty, even if the decal moves every frame.
Support for nearest, bilinear, trilinear or anisotropic texture filtering (configured globally).
Optional distance fade system to fade distant decals, improving performance.
When using the Forward+ renderer (default on desktop), decals are
rendered with clustered forward optimizations to decrease their individual cost.
Clustered rendering also lifts any limits on the number of decals that can be used on a mesh.
When using the Mobile renderer, up to 8 decals can be displayed per mesh
resource.
Sky:
Panorama sky (using an HDRI).
Procedural sky and Physically-based sky that respond to the DirectionalLights in the scene.
Support for
custom sky shaders
, which can be animated.
The radiance map used for ambient and specular light can be updated in
real-time depending on the quality settings chosen.
Fog:
Exponential depth fog.
Exponential height fog.
Support for automatic fog color depending on the sky color (aerial perspective).
Support for sun scattering in the fog.
Support for controlling how much fog rendering should affect the sky, with
separate controls for traditional and volumetric fog.
Support for making specific materials ignore fog.
Volumetric fog:
Global
volumetric fog
that reacts to lights and shadows.
Volumetric fog can take indirect light into account when using VoxelGI or SDFGI.
Fog volume nodes that can be placed to add fog to specific areas (or remove fog from specific areas).
Supported shapes include box, ellipse, cone, cylinder, and 3D texture-based density maps.
Each fog volume can have its own custom shader.
Can be used together with traditional fog.
Particles:
GPU-based particles with support for subemitters (2D + 3D), trails (2D + 3D),
attractors (3D only) and collision (2D + 3D).
3D particle attractor shapes supported: box, sphere and 3D vector fields.
3D particle collision shapes supported: box, sphere, baked signed distance field
and real-time heightmap (suited for open world weather effects).
2D particle collision is handled using a signed distance field generated in real-time
based on
LightOccluder2D
nodes in the scene.
Trails can use the built-in ribbon trail and tube trail meshes, or custom
meshes with skeletons.
Support for custom particle shaders with manual emission.
CPU-based particles.
Post-processing:
Tonemapping (Linear, Reinhard, Filmic, ACES, AgX).
Automatic exposure adjustments based on viewport brightness (and manual exposure override).
Near and far depth of field with adjustable bokeh simulation (box, hexagon, circle).
Screen-space ambient occlusion (SSAO) at half or full resolution.
Glow/bloom with optional bicubic upscaling and several blend modes available:
Screen, Soft Light, Add, Replace, Mix.
Glow can have a colored dirt map texture, acting as a lens dirt effect.
Glow can be
used as a screen-space blur effect
.
Color correction using a one-dimensional ramp or a 3D LUT texture.
Roughness limiter to reduce the impact of specular aliasing.
Brightness, contrast and saturation adjustments.
Texture filtering:
Nearest, bilinear, trilinear or anisotropic filtering.
Filtering options are defined on a per-use basis, not a per-texture basis.
Texture compression:
Basis Universal (slow, but results in smaller files).
BPTC for high-quality compression (not supported on macOS).
ETC2 (not supported on macOS).
S3TC (not supported on mobile/Web platforms).
Antialiasing:
Temporal
antialiasing
(TAA).
AMD FidelityFX Super Resolution 2.2
antialiasing
(FSR2),
which can be used at native resolution as a form of high-quality temporal antialiasing.
Multi-sample antialiasing (MSAA), for both
2D antialiasing
and
3D antialiasing
.
Fast approximate antialiasing (FXAA).
Super-sample antialiasing (SSAA) using bilinear 3D scaling and a 3D resolution scale above 1.0.
Alpha antialiasing, MSAA alpha to coverage and alpha hashing on a per-material basis.
Resolution scaling:
Support for
rendering 3D at a lower resolution
while keeping 2D rendering at the original scale. This can be used to improve
performance on low-end systems or improve visuals on high-end systems.
Resolution scaling uses bilinear filtering, AMD FidelityFX Super Resolution
1.0 (FSR1) or AMD FidelityFX Super Resolution 2.2 (FSR2).
Texture mipmap LOD bias is adjusted automatically to improve quality at lower
resolution scales. It can also be modified with a manual offset.
Most effects listed above can be adjusted for better performance or to further
improve quality. This can be helpful when
using Godot for offline rendering
.
3D tools

Built-in meshes: cube, cylinder/cone, (hemi)sphere, prism, plane, quad, torus, ribbon, tube.
GridMaps
for 3D tile-based level design.
Constructive solid geometry
(intended for prototyping).
Tools for
procedural geometry generation
.
Path3D node to represent a path in 3D space.
Can be drawn in the editor or generated procedurally.
PathFollow3D node to make nodes follow a Path3D.
3D geometry helper class
.
Support for exporting the current scene as a glTF 2.0 file, both from the editor
and at runtime from an exported project.
3D physics

Physics bodies:
Static bodies.
Animatable bodies (for objects moving only by script or animation, such as doors and platforms).
Rigid bodies.
Character bodies.
Vehicle bodies (intended for arcade physics, not simulation).
Joints.
Soft bodies
.
Ragdolls
.
Areas to detect bodies entering or leaving it.
Collision detection:
Built-in shapes: cuboid, sphere, capsule, cylinder, world boundary (infinite plane).
Generate triangle collision shapes for any mesh from the editor.
Generate one or several convex collision shapes for any mesh from the editor.
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
.
Visual shader editor.
Support for
visual shader plugins
.
Scripting

General:
Object-oriented design pattern with scripts extending nodes.
Signals and groups for communicating between scripts.
Support for
cross-language scripting
.
Many 2D, 3D and 4D linear algebra data types such as vectors and transforms.
GDScript:
High-level interpreted language
with
optional static typing
.
Syntax inspired by Python. However, GDScript is
not
based on Python.
Syntax highlighting is provided on GitHub.
Use threads
to perform asynchronous actions
or make use of multiple processor cores.
C#:
Packaged in a separate binary to keep file sizes and dependencies down.
Supports .NET 8 and higher.
Full support for the C# 12.0 syntax and features.
Supports Windows, Linux, and macOS. Since Godot 4.2, experimental support for Android and iOS is also available.
On the iOS platform only some architectures are supported:
arm64
.
The web platform is currently unsupported. To use C# on that platform,
consider Godot 3 instead.
Using an external editor is recommended to benefit from IDE functionality.
GDExtension (C, C++, Rust, D, ...):
When you need it, link to native libraries for higher performance and third-party integrations.
For scripting game logic, GDScript or C# are recommended if their
performance is suitable.
Official GDExtension bindings for
C
and
C++
.
Use any build system and language features you wish.
Actively developed GDExtension bindings for
D
,
Swift
, and
Rust
bindings provided by the community. (Some of these bindings may be experimental and not production-ready).
Audio

Features:
Mono, stereo, 5.1 and 7.1 output.
Non-positional and positional playback in 2D and 3D.
Optional Doppler effect in 2D and 3D.
Support for re-routable
audio buses
and effects
with dozens of effects included.
Support for polyphony (playing several sounds from a single AudioStreamPlayer node).
Support for random volume and pitch.
Support for real-time pitch scaling.
Support for sequential/random sample selection, including repetition prevention
when using random sample selection.
Listener2D and Listener3D nodes to listen from a position different than the camera.
Support for
procedural audio generation
.
Audio input to record microphones.
Text to speech
using platform-provided TTS engines.
MIDI input.
No support for MIDI output yet.
APIs used:
Windows:
WASAPI.
macOS:
CoreAudio.
Linux:
PulseAudio or ALSA.
Import

Support for
custom import plugins
.
Formats:
Images:
See
Importing images
.
Audio:
WAV with optional IMA-ADPCM compression.
Ogg Vorbis.
MP3.
3D scenes:
See
Importing 3D scenes
.
glTF 2.0
(recommended)
.
.blend
(by calling Blender's glTF export functionality transparently).
FBX (by calling
FBX2glTF
transparently).
Collada (.dae).
Wavefront OBJ (static scenes only, can be loaded directly as a mesh or imported as a 3D scene).
Support for loading glTF 2.0 scenes at runtime, including from an exported project.
3D meshes use
Mikktspace
to generate tangents
on import, which ensures consistency with other 3D applications such as Blender.
Input

Input mapping system
using hardcoded input events
or remappable input actions.
Axis values can be mapped to two different actions with a configurable deadzone.
Use the same code to support both keyboards and gamepads.
Keyboard input.
Keys can be mapped in "physical" mode to be independent of the keyboard layout.
Mouse input.
The mouse cursor can be visible, hidden, captured or confined within the window.
When captured, raw input will be used on Windows and Linux to
sidestep the OS' mouse acceleration settings.
Gamepad input (up to 8 simultaneous controllers).
Pen/tablet input with pressure support.
Navigation

A* algorithm in
2D
and
3D
.
Navigation meshes with dynamic obstacle avoidance in
2D
and
3D
.
Generate navigation meshes from the editor or at runtime (including from an exported project).
Networking

Low-level TCP networking using
StreamPeer
and
TCPServer
.
Low-level UDP networking using
PacketPeer
and
UDPServer
.
Low-level HTTP requests using
HTTPClient
.
High-level HTTP requests using
HTTPRequest
.
Supports HTTPS out of the box using bundled certificates.
High-level multiplayer
API using UDP and ENet.
Automatic replication using remote procedure calls (RPCs).
Supports unreliable, reliable and ordered transfers.
WebSocket
client and server, available on all platforms.
WebRTC
client and server, available on all platforms.
Support for
UPnP
to sidestep the requirement to forward ports
when hosting a server behind a NAT.
Internationalization

Full support for Unicode including emoji.
Support for loading system fonts on Windows, macOS, and Linux.
By default, system fonts are used as a fallback to display unsupported
characters. This allows proper display of multilingual text without
having to bundle large font files with a project.
Store localization strings using
CSV
or
gettext
.
Support for generating gettext POT and PO files from the editor.
Use localized strings in your project automatically in GUI elements or by
using the
tr()
function.
Support for pluralization and translation contexts.
Support for
bidirectional typesetting
,
text shaping and OpenType localized forms.
Automatic UI mirroring for right-to-left locales.
Support for pseudolocalization to test your project for i18n-friendliness.
Windowing and OS integration

Spawn multiple independent windows within a single process.
Move, resize, minimize, and maximize windows spawned by the project.
Change the window title and icon.
Create transparent windows to use as overlays, with polygon-based
mouse passthrough support.
Request attention (will cause the title bar to blink on most platforms).
Fullscreen mode.
Uses borderless fullscreen by default on Windows for fast alt-tabbing,
but can optionally use exclusive fullscreen to reduce input lag.
Borderless windows (fullscreen or non-fullscreen).
Keep a window always on top.
Make a window ignore focus (useful for overlays).
Declare a window as a popup (hidden from task switcher)
or exclusive (prevents interacting with other windows from the same process).
Native file dialog support on Windows, macOS, Linux, and Android.
Tray icon support on Windows and macOS.
Global menu integration on macOS.
Client-side decorations on macOS.
Execute commands in a blocking or non-blocking manner (including running
multiple instances of the same project).
Open file paths and URLs using default or custom protocol handlers (if registered on the system).
Parse custom command line arguments.
Support for screen readers on Windows, macOS, and Linux.
Any Godot binary (editor or exported project) can be
used as a headless server
by starting it with the
--headless
command line argument.
This allows running the engine without a GPU or display server.
See also
See
Creating applications
for details on using these features.
Mobile

In-app purchases on
Android
and
iOS
.
Support for advertisements using third-party modules.
XR support (AR and VR)

Out of the box
support for OpenXR
.
Including support for popular desktop headsets like the Valve Index, WMR headsets, and Quest over Link.
Support for
Android-based headsets
using OpenXR through a plugin.
Including support for popular stand alone headsets like the Meta Quest 1/2/3 and Pro, Pico 4, Magic Leap 2, and Lynx R1.
Out of the box limited support for visionOS Apple headsets.
Currently only exporting an application for use on a flat plane within the
headset is supported. Immersive experiences are not supported.
Other devices supported through an XR plugin structure.
Various advanced toolkits are available that implement common features required by XR applications.
GUI system

Godot's GUI is built using the same Control nodes used to make games in Godot.
The editor UI can easily be extended in many ways using add-ons.
Nodes:
Buttons.
Checkboxes, check buttons, radio buttons.
Text entry using
LineEdit
(single line) and
TextEdit
(multiple lines).
TextEdit also supports code editing features such as displaying line numbers
and syntax highlighting.
Dropdown menus using
PopupMenu
and
OptionButton
.
Scrollbars.
Labels.
RichTextLabel for
text formatted using BBCode
,
with support for animated custom effects.
Trees (can also be used to represent tables).
Color picker with RGB and HSV modes.
Controls can be rotated and scaled.
Sizing:
Anchors to keep GUI elements in a specific corner, edge or centered.
Containers to place GUI elements automatically following certain rules.
Stack
layouts.
Grid
layouts.
Flow
layouts (similar to autowrapping text).
Margin
,
centered
and
aspect ratio
layouts.
Draggable splitter
layouts.
Scale to
multiple resolutions
using the
canvas_items
or
viewport
stretch modes.
Support any aspect ratio using anchors and the
expand
stretch aspect.
Theming:
Built-in theme editor.
Generate a theme based on the current editor theme settings.
Procedural vector-based theming using
StyleBoxFlat
.
Supports rounded/beveled corners, drop shadows, per-border widths and antialiasing.
Texture-based theming using
StyleBoxTexture
.
Godot's small distribution size can make it a suitable alternative to frameworks
like Electron or Qt.
Animation

Direct kinematics and inverse kinematics.
Support for animating any property with customizable interpolation.
Support for calling methods in animation tracks.
Support for playing sounds in animation tracks.
Support for Bézier curves in animation.
File formats

Scenes and resources can be saved in
text-based
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.
Read and write text or binary files using
FileAccess
.
Can optionally be compressed or encrypted.
Read and write
JSON
files.
Read and write INI-style configuration files using
ConfigFile
.
Can (de)serialize any Godot datatype, including Vector2/3, Color, ...
Read XML files using
XMLParser
.
Load and save images, audio/video, fonts and ZIP archives
in an exported project without having to go through Godot's import system.
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
that can be read
by the engine to support mods and DLCs.
Miscellaneous

Video playback
with built-in support for Ogg Theora.
Movie Maker mode
to record videos from a running
project with synchronized audio and perfect frame pacing.
Low-level access to servers
which allows bypassing
the scene tree's overhead when needed.
Command line interface
for automation.
Export and deploy projects using continuous integration platforms.
Shell completion scripts
are available for Bash, zsh and fish.
Print colored text to standard output on all platforms using
print_rich
.
The editor can
detect features used in a project and create a compilation profile
,
which can be used to create smaller export template binaries
with unneeded features disabled.
Support for
C++ modules
statically linked
into the engine binary.
Most built-in modules can be disabled at compile-time to reduce binary size
in custom builds. See
Optimizing a build for size
for details.
Engine and editor written in C++17.
Can be
compiled
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.
Builds can be fully reproducible.
Licensed under the permissive MIT license.
Open development process with
contributions welcome
.
See also
The
Godot proposals repository
lists features that have been requested by the community and may be implemented
in future Godot releases.
/no_think

Conversion Response Content

The response has not been saved yet. The raw response is empty due to a timeout/deferred or call interruption.

6. pages/about__release_policy__9f3af805.md::docs_chunks

stage: conversion
api_url: [redacted]
model: [redacted]
table: docs_chunks
markdown_length: 11710
prompt_length: 13228
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 193
  },
  {
    "role": "user",
    "content_length": 13228
  }
]

Full Conversion Prompt Sent To Qwen

Table: docs_chunks
Return a JSON array of documentation chunk records.
Required fields and exact rules:
  - chunk_id (str): MUST match regex ^godot-\w+:\S+. Use a deterministic value like godot-stable:pages/about__intro.md#section-0001. Never return chunk_0 or plain numeric IDs.
  - doc_version (str): docs version such as stable, latest, 4.6, or unknown.
  - source_url (str): original docs URL if known, otherwise empty string.
  - source_file (str): exact local markdown path provided by the caller.
  - source_sha256 (str): exact sha256 provided by the caller.
  - doc_type (str): exactly one of class_reference, tutorial, migration, engine_details, about, other. Never use article.
  - symbol (str): class/API symbol or empty string.
  - section_path (list[str]): heading hierarchy.
  - heading (str): section heading.
  - content (str): searchable body text.
  - code_blocks (list[str]): extracted code blocks.
  - language_tags (list[str]): detected code languages.
  - godot_version_tags (list[str]): version hints.
  - api_symbols (list[str]): detected Godot symbols.
  - token_count (int): estimated token count.
  - metadata (dict): any extra metadata.
Return only valid JSON. No markdown. No comments.

Target table: docs_chunks
Source file that MUST be written into source_file fields: pages/about__release_policy__9f3af805.md
Source sha256 that MUST be written into source_sha256 fields when the field exists: 97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc

--- MARKDOWN ---
# Source: https://docs.godotengine.org/en/stable/about/release_policy.html

Godot Engine 4.6 documentation in English
Godot release policy
Edit on GitHub
Learn how to contribute!
Godot release policy

Godot's release policy is in constant evolution. The description below
provides a general idea of what to expect, but what will actually
happen depends on the choices of core contributors and the needs of the
community at a given time.
Godot versioning

Godot loosely follows
Semantic Versioning
with a
major.minor.patch
versioning system, albeit with an interpretation of each
term adapted to the complexity of a game engine:
The
major
version is incremented when major compatibility breakages happen
which imply significant porting work to move projects from one major version
to another.
For example, porting Godot projects from Godot 3.x to Godot 4.x requires
running the project through a conversion tool, and then performing a number
of further adjustments manually for what the tool could not do automatically.
The
minor
version is incremented for feature releases that do not break
compatibility in a major way. Minor compatibility breakage in very specific
areas
may
happen in minor versions, but the vast majority of projects
should not be affected or require significant porting work.
This is because Godot, as a game engine, covers many areas like rendering,
physics, and scripting. Fixing bugs or implementing new features in one area
might sometimes require changing a feature's behavior or modifying a class's
interface, even if the rest of the engine API remains backwards compatible.
Tip
Upgrading to a new minor version is recommended for all users,
but some testing is necessary to ensure that your project still behaves as
expected.
The
patch
version is incremented for maintenance releases which focus on
fixing bugs and security issues, implementing new requirements for platform
support, and backporting safe usability enhancements. Patch releases are
backwards compatible.
Patch versions may include minor new features which do not impact the
existing API, and thus have no risk of impacting existing projects.
Tip
Updating to new patch versions is therefore considered safe and strongly
recommended to all users of a given stable branch.
We call
major.minor
combinations
stable branches
. Each stable branch
starts with a
major.minor
release (without the
0
for
patch
) and is
further developed for maintenance releases in a Git branch of the same name
(for example patch updates for the 4.0 stable branch are developed in the
4.0
Git branch).
Release support timeline

Stable branches are supported
at least
until the next stable branch is
released and has received its first patch update. In practice, we support
stable branches on a
best effort
basis for as long as they have active users
who need maintenance updates.
Whenever a new major version is released, we make the previous stable branch a
long-term supported release, and do our best to provide fixes for issues
encountered by users of that branch who cannot port complex projects to the new
major version. This was the case for the 2.1 branch, and is the case for the
3.x branch.
In a given minor release series, only the latest patch release receives support.
If you experience an issue using an older patch release, please upgrade to the
latest patch release of that series and test again before reporting an issue
on GitHub.
Version
Release date
Support level
Godot 4.7
(
master
)
Q2/Q3 2026 (estimate)
Development.
Receives new features, usability and
performance improvements, as well as bug fixes, while under development.
Godot 4.6
January 2026
Receives fixes for bugs and security issues, as well as
patches that enable platform support.
Godot 4.5
September 2025
Receives fixes for security and platform support issues only.
Godot 4.4
March 2025
No longer supported (last update: 4.4.1).
Godot 4.3
August 2024
No longer supported (last update: 4.3).
Godot 4.2
November 2023
No longer supported (last update: 4.2.2).
Godot 4.1
July 2023
No longer supported (last update: 4.1.4).
Godot 4.0
March 2023
No longer supported (last update: 4.0.4).
Godot 3.7
(
3.x
)
No ETA for now
Beta.
Receives new features, usability and performance
improvements, as well as bug fixes, while under development.
Godot 3.6
September 2024
Receives fixes for bugs and security issues, as well as
patches that enable platform support.
Godot 3.5
August 2022
No longer supported (last update: 3.5.3).
Godot 3.4
November 2021
No longer supported (last update: 3.4.5).
Godot 3.3
April 2021
No longer supported (last update: 3.3.4).
Godot 3.2
January 2020
No longer supported (last update: 3.2.3).
Godot 3.1
March 2019
No longer supported (last update: 3.1.2).
Godot 3.0
January 2018
No longer supported (last update: 3.0.6).
Godot 2.1
July 2016
No longer supported (last update: 2.1.6).
Godot 2.0
February 2016
No longer supported (last update: 2.0.4.1).
Godot 1.1
May 2015
No longer supported.
Godot 1.0
December 2014
No longer supported.
Legend:
Full support –
Partial support –
No support (end of life) –
Development version
Pre-release Godot versions aren't intended to be used in production and are
provided for testing purposes only.
See also
See
Upgrading from Godot 3 to Godot 4
for instructions on migrating a project
from Godot 3.x to 4.x.
Which version should I use for a new project?

We recommend using Godot 4.x for new projects, as the Godot 4.x series will be
supported long after 3.x stops receiving updates in the future. One caveat is
that a lot of third-party documentation hasn't been updated for Godot 4.x yet.
If you have to follow a tutorial designed for Godot 3.x, we recommend keeping
Upgrading from Godot 3 to Godot 4
open in a separate tab to check which methods
have been renamed (if you get a script error while trying to use a specific node
or method that was renamed in Godot 4.x).
If your project requires a feature that is missing in 4.x (such as GLES2/WebGL
1.0), you should use Godot 3.x for a new project instead.
Should I upgrade my project to use new engine versions?

Note
Upgrading software while working on a project is inherently risky, so
consider whether it's a good idea for your project before attempting an
upgrade. Also, make backups of your project or use version control to
prevent losing data in case the upgrade goes wrong.
That said, we do our best to keep minor and especially patch releases
compatible with existing projects.
The general recommendation is to upgrade your project to follow new
patch
releases, such as upgrading from 4.0.2 to 4.0.3. This ensures you get bug fixes,
security updates and platform support updates (which is especially important for
mobile platforms). You also get continued support, as only the last patch
release receives support on official community platforms.
For
minor
releases, you should determine whether it's a good idea to upgrade
on a case-by-case basis. We've made a lot of effort in making the upgrade
process as seamless as possible, but some breaking changes may be present in
minor releases, along with a greater risk of regressions. Some fixes included in
minor releases may also change a class' expected behavior as required to fix
some bugs. This is especially the case in classes marked as
experimental
in
the documentation.
Major
releases bring a lot of new functionality, but they also remove
previously existing functionality and may raise hardware requirements. They also
require much more work to upgrade to compared to minor releases. As a result, we
recommend sticking with the major release you've started your project with if
you are happy with how your project currently works. For example, if your
project was started with 3.5, we recommend upgrading to 3.5.2 and possibly 3.6
in the future, but not to 4.0+, unless your project really needs the new
features that come with 4.0+.
When is the next release out?

While Godot contributors aren't working under any deadlines, we strive to
publish minor releases relatively frequently.
In particular, after the very long release cycle for 4.0, we are pivoting to
a faster-paced development workflow, 4.1 released 4 months after 4.0, and 4.2
released 4 months after 4.1.
Frequent minor releases will enable us to ship new features faster (possibly
as experimental), get user feedback quickly, and iterate to improve those
features and their usability. Likewise, the general user experience will be
improved more steadily with a faster path to the end users.
Maintenance (patch) releases are released as needed with potentially very
short development cycles, to provide users of the current stable branch with
the latest bug fixes for their production needs.
There is currently no planned release date for the next 3.x minor version, 3.7.
The current stable release, 3.6, may be the last stable branch of Godot 3.x.
Godot 3.x is supported on a best-effort basis, as long as contributors continue
to maintain it.
What are the criteria for compatibility across engine versions?

Note
This section is intended to be used by contributors to determine which
changes are safe for a given release. The list is not exhaustive; it only
outlines the most common situations encountered during Godot's development.
The following changes are acceptable in patch releases:
Fixing a bug in a way that has no major negative impact on most projects, such
as a visual or physics bug. Godot's physics engine is not deterministic, so
physics bug fixes are not considered to break compatibility. If fixing a bug
has a negative impact that could impact a lot of projects, it should be made
optional (e.g. using a project setting or separate method).
Adding a new optional parameter to a method.
Small-scale editor usability tweaks.
Note that we tend to be more conservative with the fixes we allow in each
subsequent patch release. For instance, 4.0.1 may receive more impactful fixes
than 4.0.4 would.
The following changes are acceptable in minor releases, but not patch releases:
Significant new features.
Renaming a method parameter. In C#, method parameters can be passed by name
(but not in GDScript). As a result, this can break some projects that use C#.
Deprecating a method, member variable, or class. This is done by adding a
deprecated flag to its class reference, which will show up in the editor. When
a method is marked as deprecated, it's slated to be removed in the next
major
release.
Changes that affect the default project theme's visuals.
Bug fixes which significantly change the behavior or the output, with the aim
to meet user expectations better. In comparison, in patch releases, we may
favor keeping a buggy behavior so we don't break existing projects which
likely already rely on the bug or use a workaround.
Performance optimizations that result in visual changes.
The following changes are considered
compatibility-breaking
and can only be
performed in a new major release:
Renaming or removing a method, member variable, or class.
Modifying a node's inheritance tree by making it inherit from a different class.
Changing the default value of a project setting value in a way that affects existing
projects. To only affect new projects, the project manager should write a
modified
project.godot
instead.
Since Godot 5.0 hasn't been branched off yet, we currently discourage making
compatibility-breaking changes of this kind.
Note
When modifying a method's signature in any fashion (including adding an
optional parameter), a GDExtension compatibility method must be created.
This ensures that existing GDExtensions continue to work across patch and
minor releases, so that users don't have to recompile them.
See
Handling compatibility breakages
for more information.
/no_think

Conversion Response Finish Reason

stop

Conversion Response Content

[{"chunk_id":"godot-stable:pages/about__release_policy__9f3af805.md#section-0001","doc_version":"stable","source_url":"https://docs.godotengine.org/en/stable/about/release_policy.html","source_file":"pages/about__release_policy__9f3af805.md","source_sha256":"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc","doc_type":"about","symbol":"","section_path":["Godot release policy"],"heading":"Godot release policy","content":"Godot Engine 4.6 documentation in English\nGodot release policy\nEdit on GitHub\nLearn how to contribute!\nGodot release policy\n\nGodot's release policy is in constant evolution. The description below provides a general idea of what to expect, but what will actually happen depends on the choices of core contributors and the needs of the community at a given time.","code_blocks":[],"language_tags":[],"godot_version_tags":["4.6"],"api_symbols":[],"token_count":52,"metadata":{}},{"chunk_id":"godot-stable:pages/about__release_policy__9f3af805.md#section-0002","doc_version":"stable","source_url":"https://docs.godotengine.org/en/stable/about/release_policy.html","source_file":"pages/about__release_policy__9f3af805.md","source_sha256":"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc","doc_type":"about","symbol":"","section_path":["Godot versioning"],"heading":"Godot versioning","content":"Godot versioning\n\nGodot loosely follows Semantic Versioning with a major.minor.patch versioning system, albeit with an interpretation of each term adapted to the complexity of a game engine:\nThe major version is incremented when major compatibility breakages happen which imply significant porting work to move projects from one major version to another.\nFor example, porting Godot projects from Godot 3.x to Godot 4.x requires running the project through a conversion tool, and then performing a number of further adjustments manually for what the tool could not do automatically.\nThe minor version is incremented for feature releases that do not break compatibility in a major way. Minor compatibility breakage in very specific areas may happen in minor versions, but the vast majority of projects should not be affected or require significant porting work.\nThis is because Godot, as a game engine, covers many areas like rendering, physics, and scripting. Fixing bugs or implementing new features in one area might sometimes require changing a feature's behavior or modifying a class's interface, even if the rest of the engine API remains backwards compatible.\nTip\nUpgrading to a new minor version is recommended for all users, but some testing is necessary to ensure that your project still behaves as expected.\nThe patch version is incremented for maintenance releases which focus on fixing bugs and security issues, implementing new requirements for platform support, and backporting safe usability enhancements. Patch releases are backwards compatible.\nPatch versions may include minor new features which do not impact the existing API, and thus have no risk of impacting existing projects.\nTip\nUpdating to new patch versions is therefore considered safe and strongly recommended to all users of a given stable branch.\nWe call major.minor combinations stable branches. Each stable branch starts with a major.minor release (without the 0 for patch) and is further developed for maintenance releases in a Git branch of the same name (for example patch updates for the 4.0 stable branch are developed in the 4.0 Git branch).","code_blocks":[],"language_tags":[],"godot_version_tags":["3.x","4.x","4.0"],"api_symbols":[],"token_count":185,"metadata":{}},{"chunk_id":"godot-stable:pages/about__release_policy__9f3af805.md#section-0003","doc_version":"stable","source_url":"https://docs.godotengine.org/en/stable/about/release_policy.html","source_file":"pages/about__release_policy__9f3af805.md","source_sha256":"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc","doc_type":"about","symbol":"","section_path":["Release support timeline"],"heading":"Release support timeline","content":"Release support timeline\n\nStable branches are supported at least until the next stable branch is released and has received its first patch update. In practice, we support stable branches on a best effort basis for as long as they have active users who need maintenance updates.\nWhenever a new major version is released, we make the previous stable branch a long-term supported release, and do our best to provide fixes for issues encountered by users of that branch who cannot port complex projects to the new major version. This was the case for the 2.1 branch, and is the case for the 3.x branch.\nIn a given minor release series, only the latest patch release receives support. If you experience an issue using an older patch release, please upgrade to the latest patch release of that series and test again before reporting an issue on GitHub.\nVersion\tRelease date\tSupport level\nGodot 4.7\t( master )\tQ2/Q3 2026 (estimate)\tDevelopment. Receives new features, usability and performance improvements, as well as bug fixes, while under development.\nGodot 4.6\tJanuary 2026\tReceives fixes for bugs and security issues, as well as patches that enable platform support.\nGodot 4.5\tSeptember 2025\tReceives fixes for security and platform support issues only.\nGodot 4.4\tMarch 2025\tNo longer supported (last update: 4.4.1).\nGodot 4.3\tAugust 2024\tNo longer supported (last update: 4.3).\nGodot 4.2\tNovember 2023\tNo longer supported (last update: 4.2.2).\nGodot 4.1\tJuly 2023\tNo longer supported (last update: 4.1.4).\nGodot 4.0\tMarch 2023\tNo longer supported (last update: 4.0.4).\nGodot 3.7\t( 3.x )\tNo ETA for now\tBeta. Receives new features, usability and performance improvements, as well as bug fixes, while under development.\nGodot 3.6\tSeptember 2024\tReceives fixes for bugs and security issues, as well as patches that enable platform support.\nGodot 3.5\tAugust 2022\tNo longer supported (last update: 3.5.3).\nGodot 3.4\tNovember 2021\tNo longer supported (last update: 3.4.5).\nGodot 3.3\tApril 2021\tNo longer supported (last update: 3.3.4).\nGodot 3.2\tJanuary 2020\tNo longer supported (last update: 3.2.3).\nGodot 3.1\tMarch 2019\tNo longer supported (last update: 3.1.2).\nGodot 3.0\tJanuary 2018\tNo longer supported (last update: 3.0.6).\nGodot 2.1\tJuly 2016\tNo longer supported (last update: 2.1.6).\nGodot 2.0\tFebruary 2016\tNo longer supported (last update: 2.0.4.1).\nGodot 1.1\tMay 2015\tNo longer supported.\nGodot 1.0\tDecember 2014\tNo longer supported.\nLegend:\nFull support –\nPartial support –\nNo support (end of life) –\nDevelopment version\nPre-release Godot versions aren't intended to be used in production and are provided for testing purposes only.","code_blocks":[],"language_tags":[],"godot_version_tags":["4.7","4.6","4.5","4.4","4.3","4.2","4.1","4.0","3.7","3.6","3.5","3.4","3.3","3.2","3.1","3.0","2.1","2.0","1.1","1.0"],"api_symbols":[],"token_count":295,"metadata":{}},{"chunk_id":"godot-stable:pages/about__release_policy__9f3af805.md#section-0004","doc_version":"stable","source_url":"https://docs.godotengine.org/en/stable/about/release_policy.html","source_file":"pages/about__release_policy__9f3af805.md","source_sha256":"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc","doc_type":"about","symbol":"","section_path":["Which version should I use for a new project?"],"heading":"Which version should I use for a new project?","content":"Which version should I use for a new project?\n\nWe recommend using Godot 4.x for new projects, as the Godot 4.x series will be supported long after 3.x stops receiving updates in the future. One caveat is that a lot of third-party documentation hasn't been updated for Godot 4.x yet.\nIf you have to follow a tutorial designed for Godot 3.x, we recommend keeping Upgrading from Godot 3 to Godot 4 open in a separate tab to check which methods have been renamed (if you get a script error while trying to use a specific node or method that was renamed in Godot 4.x).\nIf your project requires a feature that is missing in 4.x (such as GLES2/WebGL 1.0), you should use Godot 3.x for a new project instead.","code_blocks":[],"language_tags":[],"godot_version_tags":["4.x","3.x","4.0"],"api_symbols":[],"token_count":115,"metadata":{}},{"chunk_id":"godot-stable:pages/about__release_policy__9f3af805.md#section-0005","doc_version":"stable","source_url":"https://docs.godotengine.org/en/stable/about/release_policy.html","source_file":"pages/about__release_policy__9f3af805.md","source_sha256":"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc","doc_type":"about","symbol":"","section_path":["Should I upgrade my project to use new engine versions?"],"heading":"Should I upgrade my project to use new engine versions?","content":"Should I upgrade my project to use new engine versions?\n\nNote\nUpgrading software while working on a project is inherently risky, so consider whether it's a good idea for your project before attempting an upgrade. Also, make backups of your project or use version control to prevent losing data in case the upgrade goes wrong.\nThat said, we do our best to keep minor and especially patch releases compatible with existing projects.\nThe general recommendation is to upgrade your project to follow new patch releases, such as upgrading from 4.0.2 to 4.0.3. This ensures you get bug fixes, security updates and platform support updates (which is especially important for mobile platforms). You also get continued support, as only the last patch release receives support on official community platforms.\nFor minor releases, you should determine whether it's a good idea to upgrade on a case-by-case basis. We've made a lot of effort in making the upgrade process as seamless as possible, but some breaking changes may be present in minor releases, along with a greater risk of regressions. Some fixes included in minor releases may also change a class' expected behavior as required to fix some bugs. This is especially the case in classes marked as experimental in the documentation.\nMajor releases bring a lot of new functionality, but they also remove previously existing functionality and may raise hardware requirements. They also require much more work to upgrade to compared to minor releases. As a result, we recommend sticking with the major release you've started your project with if you are happy with how your project currently works. For example, if your project was started with 3.5, we recommend upgrading to 3.5.2 and possibly 3.6 in the future, but not to 4.0+, unless your project really needs the new features that come with 4.0+.","code_blocks":[],"language_tags":[],"godot_version_tags":["4.0.2","4.0.3","3.5","3.5.2","3.6","4.0+"],"api_symbols":[],"token_count":220,"metadata":{}},{"chunk_id":"godot-stable:pages/about__release_policy__9f3af805.md#section-0006","doc_version":"stable","source_url":"https://docs.godotengine.org/en/stable/about/release_policy.html","source_file":"pages/about__release_policy__9f3af805.md","source_sha256":"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc","doc_type":"about","symbol":"","section_path":["When is the next release out?"],"heading":"When is the next release out?","content":"When is the next release out?\n\nWhile Godot contributors aren't working under any deadlines, we strive to publish minor releases relatively frequently.\nIn particular, after the very long release cycle for 4.0, we are pivoting to a faster-paced development workflow, 4.1 released 4 months after 4.0, and 4.2 released 4 months after 4.1.\nFrequent minor releases will enable us to ship new features faster (possibly as experimental), get user feedback quickly, and iterate to improve those features and their usability. Likewise, the general user experience will be improved more steadily with a faster path to the end users.\nMaintenance (patch) releases are released as needed with potentially very short development cycles, to provide users of the current stable branch with the latest bug fixes for their production needs.\nThere is currently no planned release date for the next 3.x minor version, 3.7.\nThe current stable release, 3.6, may be the last stable branch of Godot 3.x.\nGodot 3.x is supported on a best-effort basis, as long as contributors continue to maintain it.","code_blocks":[],"language_tags":[],"godot_version_tags":["4.0","4.1","4.2","3.x","3.7","3.6"],"api_symbols":[],"token_count":155,"metadata":{}},{"chunk_id":"godot-stable:pages/about__release_policy__9f3af805.md#section-0007","doc_version":"stable","source_url":"https://docs.godotengine.org/en/stable/about/release_policy.html","source_file":"pages/about__release_policy__9f3af805.md","source_sha256":"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc","doc_type":"about","symbol":"","section_path":["What are the criteria for compatibility across engine versions?"],"heading":"What are the criteria for compatibility across engine versions?","content":"What are the criteria for compatibility across engine versions?\n\nNote\nThis section is intended to be used by contributors to determine which changes are safe for a given release. The list is not exhaustive; it only outlines the most common situations encountered during Godot's development.\nThe following changes are acceptable in patch releases:\nFixing a bug in a way that has no major negative impact on most projects, such as a visual or physics bug. Godot's physics engine is not deterministic, so physics bug fixes are not considered to break compatibility. If fixing a bug has a negative impact that could impact a lot of projects, it should be made optional (e.g. using a project setting or separate method).\nAdding a new optional parameter to a method.\nSmall-scale editor usability tweaks.\nNote that we tend to be more conservative with the fixes we allow in each subsequent patch release. For instance, 4.0.1 may receive more impactful fixes than 4.0.4 would.\nThe following changes are acceptable in minor releases, but not patch releases:\nSignificant new features.\nRenaming a method parameter. In C#, method parameters can be passed by name (but not in GDScript). As a result, this can break some projects that use C#.\nDeprecating a method, member variable, or class. This is done by adding a deprecated flag to its class reference, which will show up in the editor. When a method is marked as deprecated, it's slated to be removed in the next major release.\nChanges that affect the default project theme's visuals.\nBug fixes which significantly change the behavior or the output, with the aim to meet user expectations better. In comparison, in patch releases, we may favor keeping a buggy behavior so we don't break existing projects which likely already rely on the bug or use a workaround.\nPerformance optimizations that result in visual changes.\nThe following changes are considered compatibility-breaking and can only be performed in a new major release:\nRenaming or removing a method, member variable, or class.\nModifying a node's inheritance tree by making it inherit from a different class.\nChanging the default value of a project setting value in a way that affects existing projects. To only affect new projects, the project manager should write a modified project.godot instead.\nSince Godot 5.0 hasn't been branched off yet, we currently discourage making compatibility-breaking changes of this kind.\nNote\nWhen modifying a method's signature in any fashion (including adding an optional parameter), a GDExtension compatibility method must be created.\nThis ensures that existing GDExtensions continue to work across patch and minor releases, so that users don't have to recompile them.\nSee Handling compatibility breakages for more information.","code_blocks":[],"language_tags":[],"godot_version_tags":["4.0.1","4.0.4","5.0"],"api_symbols":["GDExtension"],"token_count":330,"metadata":{}}]

Conversion Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Target Table:** `docs_chunks`
   - **Required Fields:** `chunk_id`, `doc_version`, `source_url`, `source_file`, `source_sha256`, `doc_type`, `symbol`, `section_path`, `heading`, `content`, `code_blocks`, `language_tags`, `godot_version_tags`, `api_symbols`, `token_count`, `metadata`
   - **Rules:**
     - `chunk_id`: Must match `^godot-\w+:\S+`. Use deterministic like `godot-stable:pages/about__intro.md#section-0001`. Never `chunk_0` or plain numeric.
     - `doc_version`: e.g., `stable`, `latest`, `4.6`, `unknown`.
     - `source_url`: original docs URL if known, else `""`.
     - `source_file`: MUST be `pages/about__release_policy__9f3af805.md`
     - `source_sha256`: MUST be `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`
     - `doc_type`: exactly one of `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. Never `article`.
     - `symbol`: class/API symbol or `""`.
     - `section_path`: list[str] heading hierarchy.
     - `heading`: section heading.
     - `content`: searchable body text.
     - `code_blocks`: list[str] extracted code blocks.
     - `language_tags`: list[str] detected code languages.
     - `godot_version_tags`: list[str] version hints.
     - `api_symbols`: list[str] detected Godot symbols.
     - `token_count`: int estimated token count.
     - `metadata`: dict extra metadata.
   - **Input Markdown:** A documentation page about Godot's release policy. Contains sections like "Godot release policy", "Godot versioning", "Release support timeline", "Which version should I use for a new project?", "Should I upgrade my project to use new engine versions?", "When is the next release out?", "What are the criteria for compatibility across engine versions?".
   - **Constraints:** Return ONLY a JSON array. No markdown code fences. No comments.

2.  **Determine Chunking Strategy:**
   The prompt asks for "documentation chunk records". I should split the markdown into logical chunks based on headings. Each chunk will be a record in the JSON array.
   I'll create one record per major section to keep it manageable and aligned with the schema.
   Sections identified:
   1. Godot release policy (intro)
   2. Godot versioning
   3. Release support timeline
   4. Which version should I use for a new project?
   5. Should I upgrade my project to use new engine versions?
   6. When is the next release out?
   7. What are the criteria for compatibility across engine versions?

   I'll generate one JSON object per section. I need to ensure all fields are present and correctly formatted.

   Let's draft each chunk carefully.

   **Chunk 1: Godot release policy**
   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0001`
   - `doc_version`: `stable`
   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`
   - `source_file`: `pages/about__release_policy__9f3af805.md`
   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`
   - `doc_type`: `about`
   - `symbol`: `""`
   - `section_path`: `["Godot release policy"]`
   - `heading`: `Godot release policy`
   - `content`: `Godot Engine 4.6 documentation in English\nGodot release policy\nEdit on GitHub\nLearn how to contribute!\nGodot release policy\n\nGodot's release policy is in constant evolution. The description below provides a general idea of what to expect, but what will actually happen depends on the choices of core contributors and the needs of the community at a given time.`
   - `code_blocks`: `[]`
   - `language_tags`: `[]`
   - `godot_version_tags`: `["4.6"]`
   - `api_symbols`: `[]`
   - `token_count`: ~50
   - `metadata`: `{}`

   **Chunk 2: Godot versioning**
   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0002`
   - `doc_version`: `stable`
   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`
   - `source_file`: `pages/about__release_policy__9f3af805.md`
   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`
   - `doc_type`: `about`
   - `symbol`: `""`
   - `section_path`: `["Godot versioning"]`
   - `heading`: `Godot versioning`
   - `content`: `Godot versioning\n\nGodot loosely follows Semantic Versioning with a major.minor.patch versioning system, albeit with an interpretation of each term adapted to the complexity of a game engine:\nThe major version is incremented when major compatibility breakages happen which imply significant porting work to move projects from one major version to another.\nFor example, porting Godot projects from Godot 3.x to Godot 4.x requires running the project through a conversion tool, and then performing a number of further adjustments manually for what the tool could not do automatically.\nThe minor version is incremented for feature releases that do not break compatibility in a major way. Minor compatibility breakage in very specific areas may happen in minor versions, but the vast majority of projects should not be affected or require significant porting work.\nThis is because Godot, as a game engine, covers many areas like rendering, physics, and scripting. Fixing bugs or implementing new features in one area might sometimes require changing a feature's behavior or modifying a class's interface, even if the rest of the engine API remains backwards compatible.\nTip\nUpgrading to a new minor version is recommended for all users, but some testing is necessary to ensure that your project still behaves as expected.\nThe patch version is incremented for maintenance releases which focus on fixing bugs and security issues, implementing new requirements for platform support, and backporting safe usability enhancements. Patch releases are backwards compatible.\nPatch versions may include minor new features which do not impact the existing API, and thus have no risk of impacting existing projects.\nTip\nUpdating to new patch versions is therefore considered safe and strongly recommended to all users of a given stable branch.\nWe call major.minor combinations stable branches. Each stable branch starts with a major.minor release (without the 0 for patch) and is further developed for maintenance releases in a Git branch of the same name (for example patch updates for the 4.0 stable branch are developed in the 4.0 Git branch).`
   - `code_blocks`: `[]`
   - `language_tags`: `[]`
   - `godot_version_tags`: `["3.x", "4.x", "4.0"]`
   - `api_symbols`: `[]`
   - `token_count`: ~180
   - `metadata`: `{}`

   **Chunk 3: Release support timeline**
   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0003`
   - `doc_version`: `stable`
   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`
   - `source_file`: `pages/about__release_policy__9f3af805.md`
   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`
   - `doc_type`: `about`
   - `symbol`: `""`
   - `section_path`: `["Release support timeline"]`
   - `heading`: `Release support timeline`
   - `content`: `Release support timeline\n\nStable branches are supported at least until the next stable branch is released and has received its first patch update. In practice, we support stable branches on a best effort basis for as long as they have active users who need maintenance updates.\nWhenever a new major version is released, we make the previous stable branch a long-term supported release, and do our best to provide fixes for issues encountered by users of that branch who cannot port complex projects to the new major version. This was the case for the 2.1 branch, and is the case for the 3.x branch.\nIn a given minor release series, only the latest patch release receives support. If you experience an issue using an older patch release, please upgrade to the latest patch release of that series and test again before reporting an issue on GitHub.\nVersion\tRelease date\tSupport level\nGodot 4.7\t( master )\tQ2/Q3 2026 (estimate)\tDevelopment. Receives new features, usability and performance improvements, as well as bug fixes, while under development.\nGodot 4.6\tJanuary 2026\tReceives fixes for bugs and security issues, as well as patches that enable platform support.\nGodot 4.5\tSeptember 2025\tReceives fixes for security and platform support issues only.\nGodot 4.4\tMarch 2025\tNo longer supported (last update: 4.4.1).\nGodot 4.3\tAugust 2024\tNo longer supported (last update: 4.3).\nGodot 4.2\tNovember 2023\tNo longer supported (last update: 4.2.2).\nGodot 4.1\tJuly 2023\tNo longer supported (last update: 4.1.4).\nGodot 4.0\tMarch 2023\tNo longer supported (last update: 4.0.4).\nGodot 3.7\t( 3.x )\tNo ETA for now\tBeta. Receives new features, usability and performance improvements, as well as bug fixes, while under development.\nGodot 3.6\tSeptember 2024\tReceives fixes for bugs and security issues, as well as patches that enable platform support.\nGodot 3.5\tAugust 2022\tNo longer supported (last update: 3.5.3).\nGodot 3.4\tNovember 2021\tNo longer supported (last update: 3.4.5).\nGodot 3.3\tApril 2021\tNo longer supported (last update: 3.3.4).\nGodot 3.2\tJanuary 2020\tNo longer supported (last update: 3.2.3).\nGodot 3.1\tMarch 2019\tNo longer supported (last update: 3.1.2).\nGodot 3.0\tJanuary 2018\tNo longer supported (last update: 3.0.6).\nGodot 2.1\tJuly 2016\tNo longer supported (last update: 2.1.6).\nGodot 2.0\tFebruary 2016\tNo longer supported (last update: 2.0.4.1).\nGodot 1.1\tMay 2015\tNo longer supported.\nGodot 1.0\tDecember 2014\tNo longer supported.\nLegend:\nFull support –\nPartial support –\nNo support (end of life) –\nDevelopment version\nPre-release Godot versions aren't intended to be used in production and are provided for testing purposes only.`
   - `code_blocks`: `[]`
   - `language_tags`: `[]`
   - `godot_version_tags`: `["4.7", "4.6", "4.5", "4.4", "4.3", "4.2", "4.1", "4.0", "3.7", "3.6", "3.5", "3.4", "3.3", "3.2", "3.1", "3.0", "2.1", "2.0", "1.1", "1.0"]`
   - `api_symbols`: `[]`
   - `token_count`: ~280
   - `metadata`: `{}`

   **Chunk 4: Which version should I use for a new project?**
   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0004`
   - `doc_version`: `stable`
   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`
   - `source_file`: `pages/about__release_policy__9f3af805.md`
   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`
   - `doc_type`: `about`
   - `symbol`: `""`
   - `section_path`: `["Which version should I use for a new project?"]`
   - `heading`: `Which version should I use for a new project?`
   - `content`: `Which version should I use for a new project?\n\nWe recommend using Godot 4.x for new projects, as the Godot 4.x series will be supported long after 3.x stops receiving updates in the future. One caveat is that a lot of third-party documentation hasn't been updated for Godot 4.x yet.\nIf you have to follow a tutorial designed for Godot 3.x, we recommend keeping Upgrading from Godot 3 to Godot 4 open in a separate tab to check which methods have been renamed (if you get a script error while trying to use a specific node or method that was renamed in Godot 4.x).\nIf your project requires a feature that is missing in 4.x (such as GLES2/WebGL 1.0), you should use Godot 3.x for a new project instead.`
   - `code_blocks`: `[]`
   - `language_tags`: `[]`
   - `godot_version_tags`: `["4.x", "3.x", "4.0"]`
   - `api_symbols`: `[]`
   - `token_count`: ~110
   - `metadata`: `{}`

   **Chunk 5: Should I upgrade my project to use new engine versions?**
   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0005`
   - `doc_version`: `stable`
   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`
   - `source_file`: `pages/about__release_policy__9f3af805.md`
   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`
   - `doc_type`: `about`
   - `symbol`: `""`
   - `section_path`: `["Should I upgrade my project to use new engine versions?"]`
   - `heading`: `Should I upgrade my project to use new engine versions?`
   - `content`: `Should I upgrade my project to use new engine versions?\n\nNote\nUpgrading software while working on a project is inherently risky, so consider whether it's a good idea for your project before attempting an upgrade. Also, make backups of your project or use version control to prevent losing data in case the upgrade goes wrong.\nThat said, we do our best to keep minor and especially patch releases compatible with existing projects.\nThe general recommendation is to upgrade your project to follow new patch releases, such as upgrading from 4.0.2 to 4.0.3. This ensures you get bug fixes, security updates and platform support updates (which is especially important for mobile platforms). You also get continued support, as only the last patch release receives support on official community platforms.\nFor minor releases, you should determine whether it's a good idea to upgrade on a case-by-case basis. We've made a lot of effort in making the upgrade process as seamless as possible, but some breaking changes may be present in minor releases, along with a greater risk of regressions. Some fixes included in minor releases may also change a class' expected behavior as required to fix some bugs. This is especially the case in classes marked as experimental in the documentation.\nMajor releases bring a lot of new functionality, but they also remove previously existing functionality and may raise hardware requirements. They also require much more work to upgrade to compared to minor releases. As a result, we recommend sticking with the major release you've started your project with if you are happy with how your project currently works. For example, if your project was started with 3.5, we recommend upgrading to 3.5.2 and possibly 3.6 in the future, but not to 4.0+, unless your project really needs the new features that come with 4.0+.`
   - `code_blocks`: `[]`
   - `language_tags`: `[]`
   - `godot_version_tags`: `["4.0.2", "4.0.3", "3.5", "3.5.2", "3.6", "4.0+"]`
   - `api_symbols`: `[]`
   - `token_count`: ~210
   - `metadata`: `{}`

   **Chunk 6: When is the next release out?**
   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0006`
   - `doc_version`: `stable`
   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`
   - `source_file`: `pages/about__release_policy__9f3af805.md`
   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`
   - `doc_type`: `about`
   - `symbol`: `""`
   - `section_path`: `["When is the next release out?"]`
   - `heading`: `When is the next release out?`
   - `content`: `When is the next release out?\n\nWhile Godot contributors aren't working under any deadlines, we strive to publish minor releases relatively frequently.\nIn particular, after the very long release cycle for 4.0, we are pivoting to a faster-paced development workflow, 4.1 released 4 months after 4.0, and 4.2 released 4 months after 4.1.\nFrequent minor releases will enable us to ship new features faster (possibly as experimental), get user feedback quickly, and iterate to improve those features and their usability. Likewise, the general user experience will be improved more steadily with a faster path to the end users.\nMaintenance (patch) releases are released as needed with potentially very short development cycles, to provide users of the current stable branch with the latest bug fixes for their production needs.\nThere is currently no planned release date for the next 3.x minor version, 3.7.\nThe current stable release, 3.6, may be the last stable branch of Godot 3.x.\nGodot 3.x is supported on a best-effort basis, as long as contributors continue to maintain it.`
   - `code_blocks`: `[]`
   - `language_tags`: `[]`
   - `godot_version_tags`: `["4.0", "4.1", "4.2", "3.x", "3.7", "3.6"]`
   - `api_symbols`: `[]`
   - `token_count`: ~150
   - `metadata`: `{}`

   **Chunk 7: What are the criteria for compatibility across engine versions?**
   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0007`
   - `doc_version`: `stable`
   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`
   - `source_file`: `pages/about__release_policy__9f3af805.md`
   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`
   - `doc_type`: `about`
   - `symbol`: `""`
   - `section_path`: `["What are the criteria for compatibility across engine versions?"]`
   - `heading`: `What are the criteria for compatibility across engine versions?`
   - `content`: `What are the criteria for compatibility across engine versions?\n\nNote\nThis section is intended to be used by contributors to determine which changes are safe for a given release. The list is not exhaustive; it only outlines the most common situations encountered during Godot's development.\nThe following changes are acceptable in patch releases:\nFixing a bug in a way that has no major negative impact on most projects, such as a visual or physics bug. Godot's physics engine is not deterministic, so physics bug fixes are not considered to break compatibility. If fixing a bug has a negative impact that could impact a lot of projects, it should be made optional (e.g. using a project setting or separate method).\nAdding a new optional parameter to a method.\nSmall-scale editor usability tweaks.\nNote that we tend to be more conservative with the fixes we allow in each subsequent patch release. For instance, 4.0.1 may receive more impactful fixes than 4.0.4 would.\nThe following changes are acceptable in minor releases, but not patch releases:\nSignificant new features.\nRenaming a method parameter. In C#, method parameters can be passed by name (but not in GDScript). As a result, this can break some projects that use C#.\nDeprecating a method, member variable, or class. This is done by adding a deprecated flag to its class reference, which will show up in the editor. When a method is marked as deprecated, it's slated to be removed in the next major release.\nChanges that affect the default project theme's visuals.\nBug fixes which significantly change the behavior or the output, with the aim to meet user expectations better. In comparison, in patch releases, we may favor keeping a buggy behavior so we don't break existing projects which likely already rely on the bug or use a workaround.\nPerformance optimizations that result in visual changes.\nThe following changes are considered compatibility-breaking and can only be performed in a new major release:\nRenaming or removing a method, member variable, or class.\nModifying a node's inheritance tree by making it inherit from a different class.\nChanging the default value of a project setting value in a way that affects existing projects. To only affect new projects, the project manager should write a modified project.godot instead.\nSince Godot 5.0 hasn't been branched off yet, we currently discourage making compatibility-breaking changes of this kind.\nNote\nWhen modifying a method's signature in any fashion (including adding an optional parameter), a GDExtension compatibility method must be created.\nThis ensures that existing GDExtensions continue to work across patch and minor releases, so that users don't have to recompile them.\nSee Handling compatibility breakages for more information.`
   - `code_blocks`: `[]`
   - `language_tags`: `[]`
   - `godot_version_tags`: `["4.0.1", "4.0.4", "5.0"]`
   - `api_symbols`: `["GDExtension"]`
   - `token_count`: ~320
   - `metadata`: `{}`

3.  **Validate against Constraints:**
   - `chunk_id`: matches `^godot-\w+:\S+`? Yes, `godot-stable:pages/about__release_policy__9f3af805.md#section-0001` etc.
   - `doc_version`: `stable` (valid)
   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html` (valid)
   - `source_file`: `pages/about__release_policy__9f3af805.md` (exact match required)
   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc` (exact match required)
   - `doc_type`: `about` (valid)
   - `symbol`: `""` (valid)
   - `section_path`: list of strings (valid)
   - `heading`: string (valid)
   - `content`: string (valid)
   - `code_blocks`: list of strings (valid, empty here)
   - `language_tags`: list of strings (valid, empty here)
   - `godot_version_tags`: list of strings (valid)
   - `api_symbols`: list of strings (valid)
   - `token_count`: int (valid)
   - `metadata`: dict (valid)
   - Return ONLY JSON array. No markdown fences. No comments.

   I will construct the JSON carefully. I'll make sure to escape newlines in strings properly for JSON. I'll combine the content into single strings with `\n` for newlines.

   Let's draft the JSON array.
   I will verify each field type.
   `chunk_id`: string
   `doc_version`: string
   `source_url`: string
   `source_file`: string
   `source_sha256`: string
   `doc_type`: string
   `symbol`: string
   `section_path`: array of strings
   `heading`: string
   `content`: string
   `code_blocks`: array of strings
   `language_tags`: array of strings
   `godot_version_tags`: array of strings
   `api_symbols`: array of strings
   `token_count`: integer
   `metadata`: object

   All good. I will generate the JSON now.
   One minor thing: The prompt says "Return only valid JSON. No markdown. No comments." So I will output raw JSON starting with `[` and ending with `]`.
   I'll ensure proper escaping of quotes and newlines in the content strings.
   I'll double check the `source_file` and `source_sha256` constraints. They are exact.
   I'll make sure `doc_type` is exactly one of the allowed values. `about` is allowed.
   I'll make sure `chunk_id` matches regex. `godot-stable:pages/about__release_policy__9f3af805.md#section-0001` matches `^godot-\w+:\S+`.
   All set.
   Generating. 
   Self-Correction/Refinement during thought: 
   I should check if `code_blocks` or `language_tags` have any. The markdown doesn't have explicit code blocks (```), just inline text. So empty lists are fine.
   I will format the JSON carefully.
   I'll produce exactly 7 records as planned.
   Ready. 
   Output matches the requested format.✅
   Proceeds. 
   [Output Generation] -> JSON array. 
   (Note: I will manually ensure newlines in content are represented as `\n` in JSON strings.)
   All constraints met.✅
   Output matches.✅
   Proceeds. 
   `[{"chunk_id":"godot-stable:pages/about__release_policy__9f3af805.md#section-0001",...}, ...]`
   Done. 
   *Self-Correction/Verification during generation prep*: 
   Check `section_path`: The prompt says "heading hierarchy". For a single section, it's just `["Godot release policy"]`. That's fine.
   Check `token_count`: I'll estimate roughly based on word count. ~50-300 is fine.
   Check `metadata`: `{}` is fine.
   All good.
   Output matches exactly.✅
   Proceeds. 
   [Output Generation] (raw JSON)
   *(Done.)*

Raw Conversion Response

{
  "finish_reason": "stop",
  "content": "[{\"chunk_id\":\"godot-stable:pages/about__release_policy__9f3af805.md#section-0001\",\"doc_version\":\"stable\",\"source_url\":\"https://docs.godotengine.org/en/stable/about/release_policy.html\",\"source_file\":\"pages/about__release_policy__9f3af805.md\",\"source_sha256\":\"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc\",\"doc_type\":\"about\",\"symbol\":\"\",\"section_path\":[\"Godot release policy\"],\"heading\":\"Godot release policy\",\"content\":\"Godot Engine 4.6 documentation in English\\nGodot release policy\\nEdit on GitHub\\nLearn how to contribute!\\nGodot release policy\\n\\nGodot's release policy is in constant evolution. The description below provides a general idea of what to expect, but what will actually happen depends on the choices of core contributors and the needs of the community at a given time.\",\"code_blocks\":[],\"language_tags\":[],\"godot_version_tags\":[\"4.6\"],\"api_symbols\":[],\"token_count\":52,\"metadata\":{}},{\"chunk_id\":\"godot-stable:pages/about__release_policy__9f3af805.md#section-0002\",\"doc_version\":\"stable\",\"source_url\":\"https://docs.godotengine.org/en/stable/about/release_policy.html\",\"source_file\":\"pages/about__release_policy__9f3af805.md\",\"source_sha256\":\"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc\",\"doc_type\":\"about\",\"symbol\":\"\",\"section_path\":[\"Godot versioning\"],\"heading\":\"Godot versioning\",\"content\":\"Godot versioning\\n\\nGodot loosely follows Semantic Versioning with a major.minor.patch versioning system, albeit with an interpretation of each term adapted to the complexity of a game engine:\\nThe major version is incremented when major compatibility breakages happen which imply significant porting work to move projects from one major version to another.\\nFor example, porting Godot projects from Godot 3.x to Godot 4.x requires running the project through a conversion tool, and then performing a number of further adjustments manually for what the tool could not do automatically.\\nThe minor version is incremented for feature releases that do not break compatibility in a major way. Minor compatibility breakage in very specific areas may happen in minor versions, but the vast majority of projects should not be affected or require significant porting work.\\nThis is because Godot, as a game engine, covers many areas like rendering, physics, and scripting. Fixing bugs or implementing new features in one area might sometimes require changing a feature's behavior or modifying a class's interface, even if the rest of the engine API remains backwards compatible.\\nTip\\nUpgrading to a new minor version is recommended for all users, but some testing is necessary to ensure that your project still behaves as expected.\\nThe patch version is incremented for maintenance releases which focus on fixing bugs and security issues, implementing new requirements for platform support, and backporting safe usability enhancements. Patch releases are backwards compatible.\\nPatch versions may include minor new features which do not impact the existing API, and thus have no risk of impacting existing projects.\\nTip\\nUpdating to new patch versions is therefore considered safe and strongly recommended to all users of a given stable branch.\\nWe call major.minor combinations stable branches. Each stable branch starts with a major.minor release (without the 0 for patch) and is further developed for maintenance releases in a Git branch of the same name (for example patch updates for the 4.0 stable branch are developed in the 4.0 Git branch).\",\"code_blocks\":[],\"language_tags\":[],\"godot_version_tags\":[\"3.x\",\"4.x\",\"4.0\"],\"api_symbols\":[],\"token_count\":185,\"metadata\":{}},{\"chunk_id\":\"godot-stable:pages/about__release_policy__9f3af805.md#section-0003\",\"doc_version\":\"stable\",\"source_url\":\"https://docs.godotengine.org/en/stable/about/release_policy.html\",\"source_file\":\"pages/about__release_policy__9f3af805.md\",\"source_sha256\":\"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc\",\"doc_type\":\"about\",\"symbol\":\"\",\"section_path\":[\"Release support timeline\"],\"heading\":\"Release support timeline\",\"content\":\"Release support timeline\\n\\nStable branches are supported at least until the next stable branch is released and has received its first patch update. In practice, we support stable branches on a best effort basis for as long as they have active users who need maintenance updates.\\nWhenever a new major version is released, we make the previous stable branch a long-term supported release, and do our best to provide fixes for issues encountered by users of that branch who cannot port complex projects to the new major version. This was the case for the 2.1 branch, and is the case for the 3.x branch.\\nIn a given minor release series, only the latest patch release receives support. If you experience an issue using an older patch release, please upgrade to the latest patch release of that series and test again before reporting an issue on GitHub.\\nVersion\\tRelease date\\tSupport level\\nGodot 4.7\\t( master )\\tQ2/Q3 2026 (estimate)\\tDevelopment. Receives new features, usability and performance improvements, as well as bug fixes, while under development.\\nGodot 4.6\\tJanuary 2026\\tReceives fixes for bugs and security issues, as well as patches that enable platform support.\\nGodot 4.5\\tSeptember 2025\\tReceives fixes for security and platform support issues only.\\nGodot 4.4\\tMarch 2025\\tNo longer supported (last update: 4.4.1).\\nGodot 4.3\\tAugust 2024\\tNo longer supported (last update: 4.3).\\nGodot 4.2\\tNovember 2023\\tNo longer supported (last update: 4.2.2).\\nGodot 4.1\\tJuly 2023\\tNo longer supported (last update: 4.1.4).\\nGodot 4.0\\tMarch 2023\\tNo longer supported (last update: 4.0.4).\\nGodot 3.7\\t( 3.x )\\tNo ETA for now\\tBeta. Receives new features, usability and performance improvements, as well as bug fixes, while under development.\\nGodot 3.6\\tSeptember 2024\\tReceives fixes for bugs and security issues, as well as patches that enable platform support.\\nGodot 3.5\\tAugust 2022\\tNo longer supported (last update: 3.5.3).\\nGodot 3.4\\tNovember 2021\\tNo longer supported (last update: 3.4.5).\\nGodot 3.3\\tApril 2021\\tNo longer supported (last update: 3.3.4).\\nGodot 3.2\\tJanuary 2020\\tNo longer supported (last update: 3.2.3).\\nGodot 3.1\\tMarch 2019\\tNo longer supported (last update: 3.1.2).\\nGodot 3.0\\tJanuary 2018\\tNo longer supported (last update: 3.0.6).\\nGodot 2.1\\tJuly 2016\\tNo longer supported (last update: 2.1.6).\\nGodot 2.0\\tFebruary 2016\\tNo longer supported (last update: 2.0.4.1).\\nGodot 1.1\\tMay 2015\\tNo longer supported.\\nGodot 1.0\\tDecember 2014\\tNo longer supported.\\nLegend:\\nFull support –\\nPartial support –\\nNo support (end of life) –\\nDevelopment version\\nPre-release Godot versions aren't intended to be used in production and are provided for testing purposes only.\",\"code_blocks\":[],\"language_tags\":[],\"godot_version_tags\":[\"4.7\",\"4.6\",\"4.5\",\"4.4\",\"4.3\",\"4.2\",\"4.1\",\"4.0\",\"3.7\",\"3.6\",\"3.5\",\"3.4\",\"3.3\",\"3.2\",\"3.1\",\"3.0\",\"2.1\",\"2.0\",\"1.1\",\"1.0\"],\"api_symbols\":[],\"token_count\":295,\"metadata\":{}},{\"chunk_id\":\"godot-stable:pages/about__release_policy__9f3af805.md#section-0004\",\"doc_version\":\"stable\",\"source_url\":\"https://docs.godotengine.org/en/stable/about/release_policy.html\",\"source_file\":\"pages/about__release_policy__9f3af805.md\",\"source_sha256\":\"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc\",\"doc_type\":\"about\",\"symbol\":\"\",\"section_path\":[\"Which version should I use for a new project?\"],\"heading\":\"Which version should I use for a new project?\",\"content\":\"Which version should I use for a new project?\\n\\nWe recommend using Godot 4.x for new projects, as the Godot 4.x series will be supported long after 3.x stops receiving updates in the future. One caveat is that a lot of third-party documentation hasn't been updated for Godot 4.x yet.\\nIf you have to follow a tutorial designed for Godot 3.x, we recommend keeping Upgrading from Godot 3 to Godot 4 open in a separate tab to check which methods have been renamed (if you get a script error while trying to use a specific node or method that was renamed in Godot 4.x).\\nIf your project requires a feature that is missing in 4.x (such as GLES2/WebGL 1.0), you should use Godot 3.x for a new project instead.\",\"code_blocks\":[],\"language_tags\":[],\"godot_version_tags\":[\"4.x\",\"3.x\",\"4.0\"],\"api_symbols\":[],\"token_count\":115,\"metadata\":{}},{\"chunk_id\":\"godot-stable:pages/about__release_policy__9f3af805.md#section-0005\",\"doc_version\":\"stable\",\"source_url\":\"https://docs.godotengine.org/en/stable/about/release_policy.html\",\"source_file\":\"pages/about__release_policy__9f3af805.md\",\"source_sha256\":\"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc\",\"doc_type\":\"about\",\"symbol\":\"\",\"section_path\":[\"Should I upgrade my project to use new engine versions?\"],\"heading\":\"Should I upgrade my project to use new engine versions?\",\"content\":\"Should I upgrade my project to use new engine versions?\\n\\nNote\\nUpgrading software while working on a project is inherently risky, so consider whether it's a good idea for your project before attempting an upgrade. Also, make backups of your project or use version control to prevent losing data in case the upgrade goes wrong.\\nThat said, we do our best to keep minor and especially patch releases compatible with existing projects.\\nThe general recommendation is to upgrade your project to follow new patch releases, such as upgrading from 4.0.2 to 4.0.3. This ensures you get bug fixes, security updates and platform support updates (which is especially important for mobile platforms). You also get continued support, as only the last patch release receives support on official community platforms.\\nFor minor releases, you should determine whether it's a good idea to upgrade on a case-by-case basis. We've made a lot of effort in making the upgrade process as seamless as possible, but some breaking changes may be present in minor releases, along with a greater risk of regressions. Some fixes included in minor releases may also change a class' expected behavior as required to fix some bugs. This is especially the case in classes marked as experimental in the documentation.\\nMajor releases bring a lot of new functionality, but they also remove previously existing functionality and may raise hardware requirements. They also require much more work to upgrade to compared to minor releases. As a result, we recommend sticking with the major release you've started your project with if you are happy with how your project currently works. For example, if your project was started with 3.5, we recommend upgrading to 3.5.2 and possibly 3.6 in the future, but not to 4.0+, unless your project really needs the new features that come with 4.0+.\",\"code_blocks\":[],\"language_tags\":[],\"godot_version_tags\":[\"4.0.2\",\"4.0.3\",\"3.5\",\"3.5.2\",\"3.6\",\"4.0+\"],\"api_symbols\":[],\"token_count\":220,\"metadata\":{}},{\"chunk_id\":\"godot-stable:pages/about__release_policy__9f3af805.md#section-0006\",\"doc_version\":\"stable\",\"source_url\":\"https://docs.godotengine.org/en/stable/about/release_policy.html\",\"source_file\":\"pages/about__release_policy__9f3af805.md\",\"source_sha256\":\"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc\",\"doc_type\":\"about\",\"symbol\":\"\",\"section_path\":[\"When is the next release out?\"],\"heading\":\"When is the next release out?\",\"content\":\"When is the next release out?\\n\\nWhile Godot contributors aren't working under any deadlines, we strive to publish minor releases relatively frequently.\\nIn particular, after the very long release cycle for 4.0, we are pivoting to a faster-paced development workflow, 4.1 released 4 months after 4.0, and 4.2 released 4 months after 4.1.\\nFrequent minor releases will enable us to ship new features faster (possibly as experimental), get user feedback quickly, and iterate to improve those features and their usability. Likewise, the general user experience will be improved more steadily with a faster path to the end users.\\nMaintenance (patch) releases are released as needed with potentially very short development cycles, to provide users of the current stable branch with the latest bug fixes for their production needs.\\nThere is currently no planned release date for the next 3.x minor version, 3.7.\\nThe current stable release, 3.6, may be the last stable branch of Godot 3.x.\\nGodot 3.x is supported on a best-effort basis, as long as contributors continue to maintain it.\",\"code_blocks\":[],\"language_tags\":[],\"godot_version_tags\":[\"4.0\",\"4.1\",\"4.2\",\"3.x\",\"3.7\",\"3.6\"],\"api_symbols\":[],\"token_count\":155,\"metadata\":{}},{\"chunk_id\":\"godot-stable:pages/about__release_policy__9f3af805.md#section-0007\",\"doc_version\":\"stable\",\"source_url\":\"https://docs.godotengine.org/en/stable/about/release_policy.html\",\"source_file\":\"pages/about__release_policy__9f3af805.md\",\"source_sha256\":\"97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc\",\"doc_type\":\"about\",\"symbol\":\"\",\"section_path\":[\"What are the criteria for compatibility across engine versions?\"],\"heading\":\"What are the criteria for compatibility across engine versions?\",\"content\":\"What are the criteria for compatibility across engine versions?\\n\\nNote\\nThis section is intended to be used by contributors to determine which changes are safe for a given release. The list is not exhaustive; it only outlines the most common situations encountered during Godot's development.\\nThe following changes are acceptable in patch releases:\\nFixing a bug in a way that has no major negative impact on most projects, such as a visual or physics bug. Godot's physics engine is not deterministic, so physics bug fixes are not considered to break compatibility. If fixing a bug has a negative impact that could impact a lot of projects, it should be made optional (e.g. using a project setting or separate method).\\nAdding a new optional parameter to a method.\\nSmall-scale editor usability tweaks.\\nNote that we tend to be more conservative with the fixes we allow in each subsequent patch release. For instance, 4.0.1 may receive more impactful fixes than 4.0.4 would.\\nThe following changes are acceptable in minor releases, but not patch releases:\\nSignificant new features.\\nRenaming a method parameter. In C#, method parameters can be passed by name (but not in GDScript). As a result, this can break some projects that use C#.\\nDeprecating a method, member variable, or class. This is done by adding a deprecated flag to its class reference, which will show up in the editor. When a method is marked as deprecated, it's slated to be removed in the next major release.\\nChanges that affect the default project theme's visuals.\\nBug fixes which significantly change the behavior or the output, with the aim to meet user expectations better. In comparison, in patch releases, we may favor keeping a buggy behavior so we don't break existing projects which likely already rely on the bug or use a workaround.\\nPerformance optimizations that result in visual changes.\\nThe following changes are considered compatibility-breaking and can only be performed in a new major release:\\nRenaming or removing a method, member variable, or class.\\nModifying a node's inheritance tree by making it inherit from a different class.\\nChanging the default value of a project setting value in a way that affects existing projects. To only affect new projects, the project manager should write a modified project.godot instead.\\nSince Godot 5.0 hasn't been branched off yet, we currently discourage making compatibility-breaking changes of this kind.\\nNote\\nWhen modifying a method's signature in any fashion (including adding an optional parameter), a GDExtension compatibility method must be created.\\nThis ensures that existing GDExtensions continue to work across patch and minor releases, so that users don't have to recompile them.\\nSee Handling compatibility breakages for more information.\",\"code_blocks\":[],\"language_tags\":[],\"godot_version_tags\":[\"4.0.1\",\"4.0.4\",\"5.0\"],\"api_symbols\":[\"GDExtension\"],\"token_count\":330,\"metadata\":{}}]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Target Table:** `docs_chunks`\n   - **Required Fields:** `chunk_id`, `doc_version`, `source_url`, `source_file`, `source_sha256`, `doc_type`, `symbol`, `section_path`, `heading`, `content`, `code_blocks`, `language_tags`, `godot_version_tags`, `api_symbols`, `token_count`, `metadata`\n   - **Rules:**\n     - `chunk_id`: Must match `^godot-\\w+:\\S+`. Use deterministic like `godot-stable:pages/about__intro.md#section-0001`. Never `chunk_0` or plain numeric.\n     - `doc_version`: e.g., `stable`, `latest`, `4.6`, `unknown`.\n     - `source_url`: original docs URL if known, else `\"\"`.\n     - `source_file`: MUST be `pages/about__release_policy__9f3af805.md`\n     - `source_sha256`: MUST be `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`\n     - `doc_type`: exactly one of `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. Never `article`.\n     - `symbol`: class/API symbol or `\"\"`.\n     - `section_path`: list[str] heading hierarchy.\n     - `heading`: section heading.\n     - `content`: searchable body text.\n     - `code_blocks`: list[str] extracted code blocks.\n     - `language_tags`: list[str] detected code languages.\n     - `godot_version_tags`: list[str] version hints.\n     - `api_symbols`: list[str] detected Godot symbols.\n     - `token_count`: int estimated token count.\n     - `metadata`: dict extra metadata.\n   - **Input Markdown:** A documentation page about Godot's release policy. Contains sections like \"Godot release policy\", \"Godot versioning\", \"Release support timeline\", \"Which version should I use for a new project?\", \"Should I upgrade my project to use new engine versions?\", \"When is the next release out?\", \"What are the criteria for compatibility across engine versions?\".\n   - **Constraints:** Return ONLY a JSON array. No markdown code fences. No comments.\n\n2.  **Determine Chunking Strategy:**\n   The prompt asks for \"documentation chunk records\". I should split the markdown into logical chunks based on headings. Each chunk will be a record in the JSON array.\n   I'll create one record per major section to keep it manageable and aligned with the schema.\n   Sections identified:\n   1. Godot release policy (intro)\n   2. Godot versioning\n   3. Release support timeline\n   4. Which version should I use for a new project?\n   5. Should I upgrade my project to use new engine versions?\n   6. When is the next release out?\n   7. What are the criteria for compatibility across engine versions?\n\n   I'll generate one JSON object per section. I need to ensure all fields are present and correctly formatted.\n\n   Let's draft each chunk carefully.\n\n   **Chunk 1: Godot release policy**\n   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0001`\n   - `doc_version`: `stable`\n   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`\n   - `source_file`: `pages/about__release_policy__9f3af805.md`\n   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`\n   - `doc_type`: `about`\n   - `symbol`: `\"\"`\n   - `section_path`: `[\"Godot release policy\"]`\n   - `heading`: `Godot release policy`\n   - `content`: `Godot Engine 4.6 documentation in English\\nGodot release policy\\nEdit on GitHub\\nLearn how to contribute!\\nGodot release policy\\n\\nGodot's release policy is in constant evolution. The description below provides a general idea of what to expect, but what will actually happen depends on the choices of core contributors and the needs of the community at a given time.`\n   - `code_blocks`: `[]`\n   - `language_tags`: `[]`\n   - `godot_version_tags`: `[\"4.6\"]`\n   - `api_symbols`: `[]`\n   - `token_count`: ~50\n   - `metadata`: `{}`\n\n   **Chunk 2: Godot versioning**\n   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0002`\n   - `doc_version`: `stable`\n   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`\n   - `source_file`: `pages/about__release_policy__9f3af805.md`\n   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`\n   - `doc_type`: `about`\n   - `symbol`: `\"\"`\n   - `section_path`: `[\"Godot versioning\"]`\n   - `heading`: `Godot versioning`\n   - `content`: `Godot versioning\\n\\nGodot loosely follows Semantic Versioning with a major.minor.patch versioning system, albeit with an interpretation of each term adapted to the complexity of a game engine:\\nThe major version is incremented when major compatibility breakages happen which imply significant porting work to move projects from one major version to another.\\nFor example, porting Godot projects from Godot 3.x to Godot 4.x requires running the project through a conversion tool, and then performing a number of further adjustments manually for what the tool could not do automatically.\\nThe minor version is incremented for feature releases that do not break compatibility in a major way. Minor compatibility breakage in very specific areas may happen in minor versions, but the vast majority of projects should not be affected or require significant porting work.\\nThis is because Godot, as a game engine, covers many areas like rendering, physics, and scripting. Fixing bugs or implementing new features in one area might sometimes require changing a feature's behavior or modifying a class's interface, even if the rest of the engine API remains backwards compatible.\\nTip\\nUpgrading to a new minor version is recommended for all users, but some testing is necessary to ensure that your project still behaves as expected.\\nThe patch version is incremented for maintenance releases which focus on fixing bugs and security issues, implementing new requirements for platform support, and backporting safe usability enhancements. Patch releases are backwards compatible.\\nPatch versions may include minor new features which do not impact the existing API, and thus have no risk of impacting existing projects.\\nTip\\nUpdating to new patch versions is therefore considered safe and strongly recommended to all users of a given stable branch.\\nWe call major.minor combinations stable branches. Each stable branch starts with a major.minor release (without the 0 for patch) and is further developed for maintenance releases in a Git branch of the same name (for example patch updates for the 4.0 stable branch are developed in the 4.0 Git branch).`\n   - `code_blocks`: `[]`\n   - `language_tags`: `[]`\n   - `godot_version_tags`: `[\"3.x\", \"4.x\", \"4.0\"]`\n   - `api_symbols`: `[]`\n   - `token_count`: ~180\n   - `metadata`: `{}`\n\n   **Chunk 3: Release support timeline**\n   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0003`\n   - `doc_version`: `stable`\n   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`\n   - `source_file`: `pages/about__release_policy__9f3af805.md`\n   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`\n   - `doc_type`: `about`\n   - `symbol`: `\"\"`\n   - `section_path`: `[\"Release support timeline\"]`\n   - `heading`: `Release support timeline`\n   - `content`: `Release support timeline\\n\\nStable branches are supported at least until the next stable branch is released and has received its first patch update. In practice, we support stable branches on a best effort basis for as long as they have active users who need maintenance updates.\\nWhenever a new major version is released, we make the previous stable branch a long-term supported release, and do our best to provide fixes for issues encountered by users of that branch who cannot port complex projects to the new major version. This was the case for the 2.1 branch, and is the case for the 3.x branch.\\nIn a given minor release series, only the latest patch release receives support. If you experience an issue using an older patch release, please upgrade to the latest patch release of that series and test again before reporting an issue on GitHub.\\nVersion\\tRelease date\\tSupport level\\nGodot 4.7\\t( master )\\tQ2/Q3 2026 (estimate)\\tDevelopment. Receives new features, usability and performance improvements, as well as bug fixes, while under development.\\nGodot 4.6\\tJanuary 2026\\tReceives fixes for bugs and security issues, as well as patches that enable platform support.\\nGodot 4.5\\tSeptember 2025\\tReceives fixes for security and platform support issues only.\\nGodot 4.4\\tMarch 2025\\tNo longer supported (last update: 4.4.1).\\nGodot 4.3\\tAugust 2024\\tNo longer supported (last update: 4.3).\\nGodot 4.2\\tNovember 2023\\tNo longer supported (last update: 4.2.2).\\nGodot 4.1\\tJuly 2023\\tNo longer supported (last update: 4.1.4).\\nGodot 4.0\\tMarch 2023\\tNo longer supported (last update: 4.0.4).\\nGodot 3.7\\t( 3.x )\\tNo ETA for now\\tBeta. Receives new features, usability and performance improvements, as well as bug fixes, while under development.\\nGodot 3.6\\tSeptember 2024\\tReceives fixes for bugs and security issues, as well as patches that enable platform support.\\nGodot 3.5\\tAugust 2022\\tNo longer supported (last update: 3.5.3).\\nGodot 3.4\\tNovember 2021\\tNo longer supported (last update: 3.4.5).\\nGodot 3.3\\tApril 2021\\tNo longer supported (last update: 3.3.4).\\nGodot 3.2\\tJanuary 2020\\tNo longer supported (last update: 3.2.3).\\nGodot 3.1\\tMarch 2019\\tNo longer supported (last update: 3.1.2).\\nGodot 3.0\\tJanuary 2018\\tNo longer supported (last update: 3.0.6).\\nGodot 2.1\\tJuly 2016\\tNo longer supported (last update: 2.1.6).\\nGodot 2.0\\tFebruary 2016\\tNo longer supported (last update: 2.0.4.1).\\nGodot 1.1\\tMay 2015\\tNo longer supported.\\nGodot 1.0\\tDecember 2014\\tNo longer supported.\\nLegend:\\nFull support –\\nPartial support –\\nNo support (end of life) –\\nDevelopment version\\nPre-release Godot versions aren't intended to be used in production and are provided for testing purposes only.`\n   - `code_blocks`: `[]`\n   - `language_tags`: `[]`\n   - `godot_version_tags`: `[\"4.7\", \"4.6\", \"4.5\", \"4.4\", \"4.3\", \"4.2\", \"4.1\", \"4.0\", \"3.7\", \"3.6\", \"3.5\", \"3.4\", \"3.3\", \"3.2\", \"3.1\", \"3.0\", \"2.1\", \"2.0\", \"1.1\", \"1.0\"]`\n   - `api_symbols`: `[]`\n   - `token_count`: ~280\n   - `metadata`: `{}`\n\n   **Chunk 4: Which version should I use for a new project?**\n   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0004`\n   - `doc_version`: `stable`\n   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`\n   - `source_file`: `pages/about__release_policy__9f3af805.md`\n   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`\n   - `doc_type`: `about`\n   - `symbol`: `\"\"`\n   - `section_path`: `[\"Which version should I use for a new project?\"]`\n   - `heading`: `Which version should I use for a new project?`\n   - `content`: `Which version should I use for a new project?\\n\\nWe recommend using Godot 4.x for new projects, as the Godot 4.x series will be supported long after 3.x stops receiving updates in the future. One caveat is that a lot of third-party documentation hasn't been updated for Godot 4.x yet.\\nIf you have to follow a tutorial designed for Godot 3.x, we recommend keeping Upgrading from Godot 3 to Godot 4 open in a separate tab to check which methods have been renamed (if you get a script error while trying to use a specific node or method that was renamed in Godot 4.x).\\nIf your project requires a feature that is missing in 4.x (such as GLES2/WebGL 1.0), you should use Godot 3.x for a new project instead.`\n   - `code_blocks`: `[]`\n   - `language_tags`: `[]`\n   - `godot_version_tags`: `[\"4.x\", \"3.x\", \"4.0\"]`\n   - `api_symbols`: `[]`\n   - `token_count`: ~110\n   - `metadata`: `{}`\n\n   **Chunk 5: Should I upgrade my project to use new engine versions?**\n   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0005`\n   - `doc_version`: `stable`\n   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`\n   - `source_file`: `pages/about__release_policy__9f3af805.md`\n   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`\n   - `doc_type`: `about`\n   - `symbol`: `\"\"`\n   - `section_path`: `[\"Should I upgrade my project to use new engine versions?\"]`\n   - `heading`: `Should I upgrade my project to use new engine versions?`\n   - `content`: `Should I upgrade my project to use new engine versions?\\n\\nNote\\nUpgrading software while working on a project is inherently risky, so consider whether it's a good idea for your project before attempting an upgrade. Also, make backups of your project or use version control to prevent losing data in case the upgrade goes wrong.\\nThat said, we do our best to keep minor and especially patch releases compatible with existing projects.\\nThe general recommendation is to upgrade your project to follow new patch releases, such as upgrading from 4.0.2 to 4.0.3. This ensures you get bug fixes, security updates and platform support updates (which is especially important for mobile platforms). You also get continued support, as only the last patch release receives support on official community platforms.\\nFor minor releases, you should determine whether it's a good idea to upgrade on a case-by-case basis. We've made a lot of effort in making the upgrade process as seamless as possible, but some breaking changes may be present in minor releases, along with a greater risk of regressions. Some fixes included in minor releases may also change a class' expected behavior as required to fix some bugs. This is especially the case in classes marked as experimental in the documentation.\\nMajor releases bring a lot of new functionality, but they also remove previously existing functionality and may raise hardware requirements. They also require much more work to upgrade to compared to minor releases. As a result, we recommend sticking with the major release you've started your project with if you are happy with how your project currently works. For example, if your project was started with 3.5, we recommend upgrading to 3.5.2 and possibly 3.6 in the future, but not to 4.0+, unless your project really needs the new features that come with 4.0+.`\n   - `code_blocks`: `[]`\n   - `language_tags`: `[]`\n   - `godot_version_tags`: `[\"4.0.2\", \"4.0.3\", \"3.5\", \"3.5.2\", \"3.6\", \"4.0+\"]`\n   - `api_symbols`: `[]`\n   - `token_count`: ~210\n   - `metadata`: `{}`\n\n   **Chunk 6: When is the next release out?**\n   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0006`\n   - `doc_version`: `stable`\n   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`\n   - `source_file`: `pages/about__release_policy__9f3af805.md`\n   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`\n   - `doc_type`: `about`\n   - `symbol`: `\"\"`\n   - `section_path`: `[\"When is the next release out?\"]`\n   - `heading`: `When is the next release out?`\n   - `content`: `When is the next release out?\\n\\nWhile Godot contributors aren't working under any deadlines, we strive to publish minor releases relatively frequently.\\nIn particular, after the very long release cycle for 4.0, we are pivoting to a faster-paced development workflow, 4.1 released 4 months after 4.0, and 4.2 released 4 months after 4.1.\\nFrequent minor releases will enable us to ship new features faster (possibly as experimental), get user feedback quickly, and iterate to improve those features and their usability. Likewise, the general user experience will be improved more steadily with a faster path to the end users.\\nMaintenance (patch) releases are released as needed with potentially very short development cycles, to provide users of the current stable branch with the latest bug fixes for their production needs.\\nThere is currently no planned release date for the next 3.x minor version, 3.7.\\nThe current stable release, 3.6, may be the last stable branch of Godot 3.x.\\nGodot 3.x is supported on a best-effort basis, as long as contributors continue to maintain it.`\n   - `code_blocks`: `[]`\n   - `language_tags`: `[]`\n   - `godot_version_tags`: `[\"4.0\", \"4.1\", \"4.2\", \"3.x\", \"3.7\", \"3.6\"]`\n   - `api_symbols`: `[]`\n   - `token_count`: ~150\n   - `metadata`: `{}`\n\n   **Chunk 7: What are the criteria for compatibility across engine versions?**\n   - `chunk_id`: `godot-stable:pages/about__release_policy__9f3af805.md#section-0007`\n   - `doc_version`: `stable`\n   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html`\n   - `source_file`: `pages/about__release_policy__9f3af805.md`\n   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc`\n   - `doc_type`: `about`\n   - `symbol`: `\"\"`\n   - `section_path`: `[\"What are the criteria for compatibility across engine versions?\"]`\n   - `heading`: `What are the criteria for compatibility across engine versions?`\n   - `content`: `What are the criteria for compatibility across engine versions?\\n\\nNote\\nThis section is intended to be used by contributors to determine which changes are safe for a given release. The list is not exhaustive; it only outlines the most common situations encountered during Godot's development.\\nThe following changes are acceptable in patch releases:\\nFixing a bug in a way that has no major negative impact on most projects, such as a visual or physics bug. Godot's physics engine is not deterministic, so physics bug fixes are not considered to break compatibility. If fixing a bug has a negative impact that could impact a lot of projects, it should be made optional (e.g. using a project setting or separate method).\\nAdding a new optional parameter to a method.\\nSmall-scale editor usability tweaks.\\nNote that we tend to be more conservative with the fixes we allow in each subsequent patch release. For instance, 4.0.1 may receive more impactful fixes than 4.0.4 would.\\nThe following changes are acceptable in minor releases, but not patch releases:\\nSignificant new features.\\nRenaming a method parameter. In C#, method parameters can be passed by name (but not in GDScript). As a result, this can break some projects that use C#.\\nDeprecating a method, member variable, or class. This is done by adding a deprecated flag to its class reference, which will show up in the editor. When a method is marked as deprecated, it's slated to be removed in the next major release.\\nChanges that affect the default project theme's visuals.\\nBug fixes which significantly change the behavior or the output, with the aim to meet user expectations better. In comparison, in patch releases, we may favor keeping a buggy behavior so we don't break existing projects which likely already rely on the bug or use a workaround.\\nPerformance optimizations that result in visual changes.\\nThe following changes are considered compatibility-breaking and can only be performed in a new major release:\\nRenaming or removing a method, member variable, or class.\\nModifying a node's inheritance tree by making it inherit from a different class.\\nChanging the default value of a project setting value in a way that affects existing projects. To only affect new projects, the project manager should write a modified project.godot instead.\\nSince Godot 5.0 hasn't been branched off yet, we currently discourage making compatibility-breaking changes of this kind.\\nNote\\nWhen modifying a method's signature in any fashion (including adding an optional parameter), a GDExtension compatibility method must be created.\\nThis ensures that existing GDExtensions continue to work across patch and minor releases, so that users don't have to recompile them.\\nSee Handling compatibility breakages for more information.`\n   - `code_blocks`: `[]`\n   - `language_tags`: `[]`\n   - `godot_version_tags`: `[\"4.0.1\", \"4.0.4\", \"5.0\"]`\n   - `api_symbols`: `[\"GDExtension\"]`\n   - `token_count`: ~320\n   - `metadata`: `{}`\n\n3.  **Validate against Constraints:**\n   - `chunk_id`: matches `^godot-\\w+:\\S+`? Yes, `godot-stable:pages/about__release_policy__9f3af805.md#section-0001` etc.\n   - `doc_version`: `stable` (valid)\n   - `source_url`: `https://docs.godotengine.org/en/stable/about/release_policy.html` (valid)\n   - `source_file`: `pages/about__release_policy__9f3af805.md` (exact match required)\n   - `source_sha256`: `97886257e635e7282bce8c417c2193a2aa9c41e62319a9e24774b5c13c06dbdc` (exact match required)\n   - `doc_type`: `about` (valid)\n   - `symbol`: `\"\"` (valid)\n   - `section_path`: list of strings (valid)\n   - `heading`: string (valid)\n   - `content`: string (valid)\n   - `code_blocks`: list of strings (valid, empty here)\n   - `language_tags`: list of strings (valid, empty here)\n   - `godot_version_tags`: list of strings (valid)\n   - `api_symbols`: list of strings (valid)\n   - `token_count`: int (valid)\n   - `metadata`: dict (valid)\n   - Return ONLY JSON array. No markdown fences. No comments.\n\n   I will construct the JSON carefully. I'll make sure to escape newlines in strings properly for JSON. I'll combine the content into single strings with `\\n` for newlines.\n\n   Let's draft the JSON array.\n   I will verify each field type.\n   `chunk_id`: string\n   `doc_version`: string\n   `source_url`: string\n   `source_file`: string\n   `source_sha256`: string\n   `doc_type`: string\n   `symbol`: string\n   `section_path`: array of strings\n   `heading`: string\n   `content`: string\n   `code_blocks`: array of strings\n   `language_tags`: array of strings\n   `godot_version_tags`: array of strings\n   `api_symbols`: array of strings\n   `token_count`: integer\n   `metadata`: object\n\n   All good. I will generate the JSON now.\n   One minor thing: The prompt says \"Return only valid JSON. No markdown. No comments.\" So I will output raw JSON starting with `[` and ending with `]`.\n   I'll ensure proper escaping of quotes and newlines in the content strings.\n   I'll double check the `source_file` and `source_sha256` constraints. They are exact.\n   I'll make sure `doc_type` is exactly one of the allowed values. `about` is allowed.\n   I'll make sure `chunk_id` matches regex. `godot-stable:pages/about__release_policy__9f3af805.md#section-0001` matches `^godot-\\w+:\\S+`.\n   All set.\n   Generating. \n   Self-Correction/Refinement during thought: \n   I should check if `code_blocks` or `language_tags` have any. The markdown doesn't have explicit code blocks (```), just inline text. So empty lists are fine.\n   I will format the JSON carefully.\n   I'll produce exactly 7 records as planned.\n   Ready. \n   Output matches the requested format.✅\n   Proceeds. \n   [Output Generation] -> JSON array. \n   (Note: I will manually ensure newlines in content are represented as `\\n` in JSON strings.)\n   All constraints met.✅\n   Output matches.✅\n   Proceeds. \n   `[{\"chunk_id\":\"godot-stable:pages/about__release_policy__9f3af805.md#section-0001\",...}, ...]`\n   Done. \n   *Self-Correction/Verification during generation prep*: \n   Check `section_path`: The prompt says \"heading hierarchy\". For a single section, it's just `[\"Godot release policy\"]`. That's fine.\n   Check `token_count`: I'll estimate roughly based on word count. ~50-300 is fine.\n   Check `metadata`: `{}` is fine.\n   All good.\n   Output matches exactly.✅\n   Proceeds. \n   [Output Generation] (raw JSON)\n   *(Done.)*\n"
}

7. pages/about__system_requirements__6f1863c2.md::docs_chunks

stage: conversion
api_url: [redacted]
model: [redacted]
table: docs_chunks
markdown_length: 11736
prompt_length: 13259
response_saved: True

Request Message Summary

[
  {
    "role": "system",
    "content_length": 193
  },
  {
    "role": "user",
    "content_length": 13259
  }
]

Full Conversion Prompt Sent To Qwen

Table: docs_chunks
Return a JSON array of documentation chunk records.
Required fields and exact rules:
  - chunk_id (str): MUST match regex ^godot-\w+:\S+. Use a deterministic value like godot-stable:pages/about__intro.md#section-0001. Never return chunk_0 or plain numeric IDs.
  - doc_version (str): docs version such as stable, latest, 4.6, or unknown.
  - source_url (str): original docs URL if known, otherwise empty string.
  - source_file (str): exact local markdown path provided by the caller.
  - source_sha256 (str): exact sha256 provided by the caller.
  - doc_type (str): exactly one of class_reference, tutorial, migration, engine_details, about, other. Never use article.
  - symbol (str): class/API symbol or empty string.
  - section_path (list[str]): heading hierarchy.
  - heading (str): section heading.
  - content (str): searchable body text.
  - code_blocks (list[str]): extracted code blocks.
  - language_tags (list[str]): detected code languages.
  - godot_version_tags (list[str]): version hints.
  - api_symbols (list[str]): detected Godot symbols.
  - token_count (int): estimated token count.
  - metadata (dict): any extra metadata.
Return only valid JSON. No markdown. No comments.

Target table: docs_chunks
Source file that MUST be written into source_file fields: pages/about__system_requirements__6f1863c2.md
Source sha256 that MUST be written into source_sha256 fields when the field exists: ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149

--- MARKDOWN ---
# Source: https://docs.godotengine.org/en/stable/about/system_requirements.html

Godot Engine 4.6 documentation in English
System requirements
Edit on GitHub
Learn how to contribute!
System requirements

This page contains system requirements for the editor and exported projects.
These specifications are given for informative purposes only, but they can be
referred to if you're looking to build or upgrade a system to use Godot on.
Godot editor

These are the
minimum
specifications required to run the Godot editor and work
on a simple 2D or 3D project:
Desktop or laptop PC - Minimum

CPU
Windows:
x86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv8 CPU
Example: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite
macOS:
x86_64 or ARM CPU (Apple Silicon)
Example: Intel Core 2 Duo SU9400, Apple M1
Linux:
x86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv7 or
ARMv8 CPU
Example: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4
GPU
Forward+ renderer:
Integrated graphics with full Vulkan 1.0 support
Example: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)
Mobile renderer:
Integrated graphics with full Vulkan 1.0 support
Example: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)
Compatibility renderer:
Integrated graphics with full OpenGL 3.3 support
Example: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)
RAM
Native editor:
4 GB
Web editor:
8 GB
Storage
200 MB (used for the executable, project files and cache).
Exporting projects requires downloading export templates separately
(1.3 GB after installation).
Operating system
Native editor:
Windows 10, macOS 10.13 (Compatibility) or
macOS 10.15 (Forward+/Mobile), Linux distribution released after 2018
Web editor:
Recent versions of mainstream browsers: Firefox and derivatives
(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.
Note
If your x86_64 CPU does not support SSE4.2, you can still run the 32-bit Godot
executable which only has a SSE2 requirement (all x86_64 CPUs support SSE2).
While supported on Linux, we have no official minimum requirements for running on
rv64 (RISC-V), ppc64 & ppc32 (PowerPC), and loongarch64. In addition you must
compile the editor for that platform (as well as export templates) yourself,
no official downloads are currently provided. RISC-V compiling instructions can
be found on the
Compiling for Linux, *BSD
page.
Mobile device (smartphone/tablet) - Minimum

CPU
Android:
SoC with any 32-bit or 64-bit ARM or x86 CPU
Example: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430
iOS:
Cannot run the editor
GPU
Forward+ renderer:
SoC featuring GPU with full Vulkan 1.0 support
Example: Qualcomm Adreno 505, Mali-G71 MP2
Mobile renderer:
SoC featuring GPU with full Vulkan 1.0 support
Example: Qualcomm Adreno 505, Mali-G71 MP2
Compatibility renderer:
SoC featuring GPU with full OpenGL ES 3.0 support
Example: Qualcomm Adreno 306, Mali-T628 MP6
RAM
Native editor:
3 GB
Web editor:
6 GB
Storage
200 MB (used for the executable, project files and cache)
Exporting projects requires downloading export templates separately
(1.3 GB after installation)
Operating system
Native editor:
Android 6.0 (Compatibility) or Android 9.0 (Forward+/Mobile)
Web editor:
Recent versions of mainstream browsers: Firefox and derivatives
(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.
These are the
recommended
specifications to get a smooth experience with the
Godot editor on a simple 2D or 3D project:
Desktop or laptop PC - Recommended

CPU
Windows:
x86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU
Example: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite
macOS:
x86_64 or ARM CPU (Apple Silicon)
Example: Intel Core i5-8500, Apple M1
Linux:
x86_64 CPU with SSE4.2 support, ARMv7 or ARMv8 CPU
Example: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking
GPU
Forward+ renderer:
Dedicated graphics with full Vulkan 1.2 support
Example: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)
Mobile renderer:
Dedicated graphics with full Vulkan 1.2 support
Example: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)
Compatibility renderer:
Dedicated graphics with full OpenGL 4.6 support
Example: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)
RAM
Native editor:
8 GB
Web editor:
12 GB
Storage
1.5 GB (used for the executable, project files, all export templates and cache)
Operating system
Native editor:
Windows 10, macOS 10.15,
Linux distribution released after 2020
Web editor:
Latest version of Firefox, Chrome, Edge, Safari, Opera
Mobile device (smartphone/tablet) - Recommended

CPU
Android:
SoC with 64-bit ARM or x86 CPU, with 3 "performance" cores or more
Example: Qualcomm Snapdragon 845, Samsung Exynos 9810
iOS:
Cannot run the editor
GPU
Forward+ renderer:
SoC featuring GPU with full Vulkan 1.2 support
Example: Qualcomm Adreno 630, Mali-G72 MP18
Mobile renderer:
SoC featuring GPU with full Vulkan 1.2 support
Example: Qualcomm Adreno 630, Mali-G72 MP18
Compatibility renderer:
SoC featuring GPU with full OpenGL ES 3.2 support
Example: Qualcomm Adreno 630, Mali-G72 MP18
RAM
Native editor:
6 GB
Web editor:
8 GB
Storage
1.5 GB (used for the executable, project files, all export templates and cache)
Operating system
Native editor:
Android 9.0
Web editor:
Latest version of Firefox, Chrome, Edge, Safari, Opera,
Samsung Internet
Exported Godot project

Warning
The requirements below are a baseline for a
simple
2D or 3D project,
with basic scripting and few visual flourishes. CPU, GPU, RAM and
storage requirements will heavily vary depending on your project's scope,
its renderer, viewport resolution and graphics settings chosen.
Other programs running on the system while the project is running
will also compete for resources, including RAM and video RAM.
It is strongly recommended to do your own testing on low-end hardware to
make sure your project runs at the desired speed. To provide scalability for
low-end hardware, you will also need to introduce a
graphics options menu
to your project.
These are the
minimum
specifications required to run a simple 2D or 3D
project exported with Godot:
Desktop or laptop PC - Minimum

CPU
Windows:
x86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,
ARMv8 CPU
Example: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite
macOS:
x86_64 or ARM CPU (Apple Silicon)
Example: Intel Core 2 Duo SU9400, Apple M1
Linux:
x86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,
ARMv7 or ARMv8 CPU
Example: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4
GPU
Forward+ renderer:
Integrated graphics with full Vulkan 1.0 support,
Metal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)
Example: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)
Mobile renderer:
Integrated graphics with full Vulkan 1.0 support,
Metal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)
Example: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)
Compatibility renderer:
Integrated graphics with full OpenGL 3.3 support
or Direct3D 11 support (Windows).
Example: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)
RAM
For native exports:
2 GB
For web exports:
4 GB
Storage
150 MB (used for the executable, project files and cache)
Operating system
For native exports:
Windows 10, macOS 10.13 (Compatibility), macOS 10.15
(Forward+/Mobile, Vulkan), macOS 13.0 (Forward+/Mobile, Metal), Linux distribution
released after 2018
Web editor:
Recent versions of mainstream browsers: Firefox and derivatives
(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.
Mobile device (smartphone/tablet) - Minimum

CPU
Android:
SoC with any 32-bit or 64-bit ARM or x86 CPU
Example: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430
iOS:
SoC with any 64-bit ARM CPU
Example: Apple A7 (iPhone 5S)
GPU
Forward+ renderer:
SoC featuring GPU with full Vulkan 1.0 support, or
Metal 3 support (iOS/iPadOS)
Example (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)
Example (Metal): Apple A12 (iPhone XR/XS)
Mobile renderer:
SoC featuring GPU with full Vulkan 1.0 support, or
Metal 3 support (iOS/iPadOS)
Example (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)
Example (Metal): Apple A12 (iPhone XR/XS)
Compatibility renderer:
SoC featuring GPU with full OpenGL ES 3.0 support
Example: Qualcomm Adreno 306, Mali-T628 MP6, Apple A7 (iPhone 5S)
RAM
For native exports:
1 GB
For web exports:
2 GB
Storage
150 MB (used for the executable, project files and cache)
Operating system
For native exports:
Android 6.0 (Compatibility), Android 9.0 (Forward+/Mobile),
iOS 12.0 (Forward+/Mobile, Vulkan), iOS 16.0 (Forward+/Mobile, Metal)
Web editor:
Recent versions of mainstream browsers: Firefox and derivatives
(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.
These are the
recommended
specifications to get a smooth experience with a
simple 2D or 3D project exported with Godot:
Desktop or laptop PC - Recommended

CPU
Windows:
x86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU
Example: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite
macOS:
x86_64 or ARM CPU (Apple Silicon)
Example: Intel Core i5-8500, Apple M1
Linux:
x86_64 CPU with SSE4.2 support, with 4 physical cores or more,
ARMv7 or ARMv8 CPU
Example: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking
GPU
Forward+ renderer:
Dedicated graphics with full Vulkan 1.2 support,
Metal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)
Example: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)
Mobile renderer:
Dedicated graphics with full Vulkan 1.2 support,
Metal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)
Example: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)
Compatibility renderer:
Dedicated graphics with full OpenGL 4.6 support
Example: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)
RAM
For native exports:
4 GB
For web exports:
8 GB
Storage
150 MB (used for the executable, project files and cache)
Operating system
For native exports:
Windows 10, macOS 10.15 (Forward+/Mobile, Vulkan), macOS 13.0
(Forward+/Mobile, Metal), Linux distribution released after 2020
For web exports:
Latest version of Firefox, Chrome, Edge, Safari, Opera
Mobile device (smartphone/tablet) - Recommended

CPU
Android:
SoC with 64-bit ARM or x86 CPU, with 3 "performance" cores or more
Example: Qualcomm Snapdragon 845, Samsung Exynos 9810
iOS:
SoC with 64-bit ARM CPU
Example: Apple A14 (iPhone 12)
GPU
Forward+ renderer:
SoC featuring GPU with full Vulkan 1.2 support, or
Metal 3 support (iOS/iPadOS)
Example: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)
Mobile renderer:
SoC featuring GPU with full Vulkan 1.2 support, or
Metal 3 support (iOS/iPadOS)
Example: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)
Compatibility renderer:
SoC featuring GPU with full OpenGL ES 3.2 support
Example: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)
RAM
For native exports:
2 GB
For web exports:
4 GB
Storage
150 MB (used for the executable, project files and cache)
Operating system
For native exports:
Android 9.0, iOS 14.1 (Forward+/Mobile, Vulkan), iOS 16.0
(Forward+/Mobile, Metal)
For web exports:
Latest version of Firefox, Chrome, Edge, Safari, Opera,
Samsung Internet
Note
Godot doesn't use OpenGL/OpenGL ES extensions introduced after OpenGL
3.3/OpenGL ES 3.0, but GPUs supporting newer OpenGL/OpenGL ES versions
generally have fewer driver issues.
/no_think

Conversion Response Finish Reason

stop

Conversion Response Content

[
  {
    "chunk_id": "godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/system_requirements.html",
    "source_file": "pages/about__system_requirements__6f1863c2.md",
    "source_sha256": "ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149",
    "doc_type": "about",
    "symbol": "",
    "section_path": [
      "System requirements"
    ],
    "heading": "System requirements",
    "content": "Godot Engine 4.6 documentation in English\nSystem requirements\nEdit on GitHub\nLearn how to contribute!\nSystem requirements\n\nThis page contains system requirements for the editor and exported projects.\nThese specifications are given for informative purposes only, but they can be\nreferred to if you're looking to build or upgrade a system to use Godot on.\nGodot editor\n\nThese are the\nminimum\nspecifications required to run the Godot editor and work\non a simple 2D or 3D project:\nDesktop or laptop PC - Minimum\n\nCPU\nWindows:\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv8 CPU\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite\nmacOS:\nx86_64 or ARM CPU (Apple Silicon)\nExample: Intel Core 2 Duo SU9400, Apple M1\nLinux:\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv7 or\nARMv8 CPU\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4\nGPU\nForward+ renderer:\nIntegrated graphics with full Vulkan 1.0 support\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\nMobile renderer:\nIntegrated graphics with full Vulkan 1.0 support\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\nCompatibility renderer:\nIntegrated graphics with full OpenGL 3.3 support\nExample: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)\nRAM\nNative editor:\n4 GB\nWeb editor:\n8 GB\nStorage\n200 MB (used for the executable, project files and cache).\nExporting projects requires downloading export templates separately\n(1.3 GB after installation).\nOperating system\nNative editor:\nWindows 10, macOS 10.13 (Compatibility) or\nmacOS 10.15 (Forward+/Mobile), Linux distribution released after 2018\nWeb editor:\nRecent versions of mainstream browsers: Firefox and derivatives\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\nNote\nIf your x86_64 CPU does not support SSE4.2, you can still run the 32-bit Godot\nexecutable which only has a SSE2 requirement (all x86_64 CPUs support SSE2).\nWhile supported on Linux, we have no official minimum requirements for running on\nrv64 (RISC-V), ppc64 & ppc32 (PowerPC), and loongarch64. In addition you must\ncompile the editor for that platform (as well as export templates) yourself,\nno official downloads are currently provided. RISC-V compiling instructions can be found on the\nCompiling for Linux, *BSD\npage.\nMobile device (smartphone/tablet) - Minimum\n\nCPU\nAndroid:\nSoC with any 32-bit or 64-bit ARM or x86 CPU\nExample: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430\niOS:\nCannot run the editor\nGPU\nForward+ renderer:\nSoC featuring GPU with full Vulkan 1.0 support\nExample: Qualcomm Adreno 505, Mali-G71 MP2\nMobile renderer:\nSoC featuring GPU with full Vulkan 1.0 support\nExample: Qualcomm Adreno 505, Mali-G71 MP2\nCompatibility renderer:\nSoC featuring GPU with full OpenGL ES 3.0 support\nExample: Qualcomm Adreno 306, Mali-T628 MP6\nRAM\nNative editor:\n3 GB\nWeb editor:\n6 GB\nStorage\n200 MB (used for the executable, project files and cache)\nExporting projects requires downloading export templates separately\n(1.3 GB after installation)\nOperating system\nNative editor:\nAndroid 6.0 (Compatibility) or Android 9.0 (Forward+/Mobile)\nWeb editor:\nRecent versions of mainstream browsers: Firefox and derivatives\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": [
      "4.6"
    ],
    "api_symbols": [],
    "token_count": 345,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__system_requirements__6f1863c2.md#section-0002",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/system_requirements.html",
    "source_file": "pages/about__system_requirements__6f1863c2.md",
    "source_sha256": "ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149",
    "doc_type": "about",
    "symbol": "",
    "section_path": [
      "System requirements",
      "Godot editor",
      "Desktop or laptop PC - Recommended"
    ],
    "heading": "Godot editor recommended",
    "content": "These are the\nrecommended\nspecifications to get a smooth experience with the\nGodot editor on a simple 2D or 3D project:\nDesktop or laptop PC - Recommended\n\nCPU\nWindows:\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite\nmacOS:\nx86_64 or ARM CPU (Apple Silicon)\nExample: Intel Core i5-8500, Apple M1\nLinux:\nx86_64 CPU with SSE4.2 support, ARMv7 or ARMv8 CPU\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking\nGPU\nForward+ renderer:\nDedicated graphics with full Vulkan 1.2 support\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\nMobile renderer:\nDedicated graphics with full Vulkan 1.2 support\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\nCompatibility renderer:\nDedicated graphics with full OpenGL 4.6 support\nExample: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)\nRAM\nNative editor:\n8 GB\nWeb editor:\n12 GB\nStorage\n1.5 GB (used for the executable, project files, all export templates and cache)\nOperating system\nNative editor:\nWindows 10, macOS 10.15,\nLinux distribution released after 2020\nWeb editor:\nLatest version of Firefox, Chrome, Edge, Safari, Opera\nMobile device (smartphone/tablet) - Recommended\n\nCPU\nAndroid:\nSoC with 64-bit ARM or x86 CPU, with 3 \"performance\" cores or more\nExample: Qualcomm Snapdragon 845, Samsung Exynos 9810\niOS:\nCannot run the editor\nGPU\nForward+ renderer:\nSoC featuring GPU with full Vulkan 1.2 support\nExample: Qualcomm Adreno 630, Mali-G72 MP18\nMobile renderer:\nSoC featuring GPU with full Vulkan 1.2 support\nExample: Qualcomm Adreno 630, Mali-G72 MP18\nCompatibility renderer:\nSoC featuring GPU with full OpenGL ES 3.2 support\nExample: Qualcomm Adreno 630, Mali-G72 MP18\nRAM\nNative editor:\n6 GB\nWeb editor:\n8 GB\nStorage\n1.5 GB (used for the executable, project files, all export templates and cache)\nOperating system\nNative editor:\nAndroid 9.0\nWeb editor:\nLatest version of Firefox, Chrome, Edge, Safari, Opera,\nSamsung Internet",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": [
      "4.6"
    ],
    "api_symbols": [],
    "token_count": 368,
    "metadata": {}
  },
  {
    "chunk_id": "godot-stable:pages/about__system_requirements__6f1863c2.md#section-0003",
    "doc_version": "stable",
    "source_url": "https://docs.godotengine.org/en/stable/about/system_requirements.html",
    "source_file": "pages/about__system_requirements__6f1863c2.md",
    "source_sha256": "ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149",
    "doc_type": "about",
    "symbol": "",
    "section_path": [
      "System requirements",
      "Exported Godot project"
    ],
    "heading": "Exported Godot project",
    "content": "Exported Godot project\n\nWarning\nThe requirements below are a baseline for a\nsimple\n2D or 3D project,\nwith basic scripting and few visual flourishes. CPU, GPU, RAM and\nstorage requirements will heavily vary depending on your project's scope,\nits renderer, viewport resolution and graphics settings chosen.\nOther programs running on the system while the project is running\nwill also compete for resources, including RAM and video RAM.\nIt is strongly recommended to do your own testing on low-end hardware to\nmake sure your project runs at the desired speed. To provide scalability for\nlow-end hardware, you will also need to introduce a\ngraphics options menu\nto your project.\nThese are the\nminimum\nspecifications required to run a simple 2D or 3D\nproject exported with Godot:\nDesktop or laptop PC - Minimum\n\nCPU\nWindows:\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,\nARMv8 CPU\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite\nmacOS:\nx86_64 or ARM CPU (Apple Silicon)\nExample: Intel Core 2 Duo SU9400, Apple M1\nLinux:\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,\nARMv7 or ARMv8 CPU\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4\nGPU\nForward+ renderer:\nIntegrated graphics with full Vulkan 1.0 support,\nMetal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\nMobile renderer:\nIntegrated graphics with full Vulkan 1.0 support,\nMetal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\nCompatibility renderer:\nIntegrated graphics with full OpenGL 3.3 support\nor Direct3D 11 support (Windows).\nExample: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)\nRAM\nFor native exports:\n2 GB\nFor web exports:\n4 GB\nStorage\n150 MB (used for the executable, project files and cache)\nOperating system\nFor native exports:\nWindows 10, macOS 10.13 (Compatibility), macOS 10.15\n(Forward+/Mobile, Vulkan), macOS 13.0 (Forward+/Mobile, Metal), Linux distribution\nreleased after 2018\nWeb editor:\nRecent versions of mainstream browsers: Firefox and derivatives\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\nMobile device (smartphone/tablet) - Minimum\n\nCPU\nAndroid:\nSoC with any 32-bit or 64-bit ARM or x86 CPU\nExample: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430\niOS:\nSoC with any 64-bit ARM CPU\nExample: Apple A7 (iPhone 5S)\nGPU\nForward+ renderer:\nSoC featuring GPU with full Vulkan 1.0 support, or\nMetal 3 support (iOS/iPadOS)\nExample (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)\nExample (Metal): Apple A12 (iPhone XR/XS)\nMobile renderer:\nSoC featuring GPU with full Vulkan 1.0 support, or\nMetal 3 support (iOS/iPadOS)\nExample (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)\nExample (Metal): Apple A12 (iPhone XR/XS)\nCompatibility renderer:\nSoC featuring GPU with full OpenGL ES 3.0 support\nExample: Qualcomm Adreno 306, Mali-T628 MP6, Apple A7 (iPhone 5S)\nRAM\nFor native exports:\n1 GB\nFor web exports:\n2 GB\nStorage\n150 MB (used for the executable, project files and cache)\nOperating system\nFor native exports:\nAndroid 6.0 (Compatibility), Android 9.0 (Forward+/Mobile),\niOS 12.0 (Forward+/Mobile, Vulkan), iOS 16.0 (Forward+/Mobile, Metal)\nWeb editor:\nRecent versions of mainstream browsers: Firefox and derivatives\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\nThese are the\nrecommended\nspecifications to get a smooth experience with a\nsimple 2D or 3D project exported with Godot:\nDesktop or laptop PC - Recommended\n\nCPU\nWindows:\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite\nmacOS:\nx86_64 or ARM CPU (Apple Silicon)\nExample: Intel Core i5-8500, Apple M1\nLinux:\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more,\nARMv7 or ARMv8 CPU\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking\nGPU\nForward+ renderer:\nDedicated graphics with full Vulkan 1.2 support,\nMetal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\nMobile renderer:\nDedicated graphics with full Vulkan 1.2 support,\nMetal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\nCompatibility renderer:\nDedicated graphics with full OpenGL 4.6 support\nExample: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)\nRAM\nFor native exports:\n4 GB\nFor web exports:\n8 GB\nStorage\n150 MB (used for the executable, project files and cache)\nOperating system\nFor native exports:\nWindows 10, macOS 10.15 (Forward+/Mobile, Vulkan), macOS 13.0\n(Forward+/Mobile, Metal), Linux distribution released after 2020\nFor web exports:\nLatest version of Firefox, Chrome, Edge, Safari, Opera\nMobile device (smartphone/tablet) - Recommended\n\nCPU\nAndroid:\nSoC with 64-bit ARM or x86 CPU, with 3 \"performance\" cores or more\nExample: Qualcomm Snapdragon 845, Samsung Exynos 9810\niOS:\nSoC with 64-bit ARM CPU\nExample: Apple A14 (iPhone 12)\nGPU\nForward+ renderer:\nSoC featuring GPU with full Vulkan 1.2 support, or\nMetal 3 support (iOS/iPadOS)\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\nMobile renderer:\nSoC featuring GPU with full Vulkan 1.2 support, or\nMetal 3 support (iOS/iPadOS)\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\nCompatibility renderer:\nSoC featuring GPU with full OpenGL ES 3.2 support\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\nRAM\nFor native exports:\n2 GB\nFor web exports:\n4 GB\nStorage\n150 MB (used for the executable, project files and cache)\nOperating system\nFor native exports:\nAndroid 9.0, iOS 14.1 (Forward+/Mobile, Vulkan), iOS 16.0\n(Forward+/Mobile, Metal)\nFor web exports:\nLatest version of Firefox, Chrome, Edge, Safari, Opera,\nSamsung Internet\nNote\nGodot doesn't use OpenGL/OpenGL ES extensions introduced after OpenGL\n3.3/OpenGL ES 3.0, but GPUs supporting newer OpenGL/OpenGL ES versions\ngenerally have fewer driver issues.",
    "code_blocks": [],
    "language_tags": [],
    "godot_version_tags": [
      "4.6"
    ],
    "api_symbols": [],
    "token_count": 742,
    "metadata": {}
  }
]

Conversion Response Reasoning Content

Here's a thinking process:

1.  **Analyze User Input:**
   - **Table:** `docs_chunks`
   - **Required Fields:** `chunk_id`, `doc_version`, `source_url`, `source_file`, `source_sha256`, `doc_type`, `symbol`, `section_path`, `heading`, `content`, `code_blocks`, `language_tags`, `godot_version_tags`, `api_symbols`, `token_count`, `metadata`
   - **Rules:**
     - `chunk_id`: Must match `^godot-\w+:\S+`. Use deterministic like `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001`. Never `chunk_0` or plain numeric.
     - `doc_version`: e.g., `stable`, `latest`, `4.6`, `unknown`.
     - `source_url`: original docs URL if known, else `""`.
     - `source_file`: MUST be `pages/about__system_requirements__6f1863c2.md`.
     - `source_sha256`: MUST be `ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149` when field exists.
     - `doc_type`: exactly one of `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. Never `article`.
     - `symbol`: class/API symbol or `""`.
     - `section_path`: list[str] heading hierarchy.
     - `heading`: section heading.
     - `content`: searchable body text.
     - `code_blocks`: list[str] extracted code blocks.
     - `language_tags`: list[str] detected code languages.
     - `godot_version_tags`: list[str] version hints.
     - `api_symbols`: list[str] detected Godot symbols.
     - `token_count`: int estimated token count.
     - `metadata`: dict extra metadata.
   - **Input Markdown:** A documentation page about Godot 4.6 system requirements. It has sections like "System requirements", "Godot editor", "Desktop or laptop PC - Minimum", "Mobile device (smartphone/tablet) - Minimum", "Exported Godot project", etc.
   - **Output Format:** JSON array of records. No markdown fences, no explanation.

2.  **Determine Chunking Strategy:**
   The prompt asks for "documentation chunk records". I should split the markdown into logical chunks based on headings. I'll create one record per major section to keep it manageable, or maybe just one record for the whole page if it's short, but splitting by top-level headings is usually better for RAG. Let's look at the structure:
   - `# Source: https://...` (header)
   - `Godot Engine 4.6 documentation in English`
   - `System requirements` (H1/H2?)
   - `Godot editor` (H2)
     - `Desktop or laptop PC - Minimum` (H3)
     - `Mobile device (smartphone/tablet) - Minimum` (H3)
     - `Desktop or laptop PC - Recommended` (H3)
     - `Mobile device (smartphone/tablet) - Recommended` (H3)
   - `Exported Godot project` (H2)
     - `Desktop or laptop PC - Minimum` (H3)
     - `Mobile device (smartphone/tablet) - Minimum` (H3)
     - `Desktop or laptop PC - Recommended` (H3)
     - `Mobile device (smartphone/tablet) - Recommended` (H3)
   - `Note` (H3)

   I'll create chunks for each major section to keep `content` focused. I'll aim for ~4-5 chunks.
   Let's define chunks:
   1. `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001` -> "System requirements" (intro + Godot editor min)
   2. `...#section-0002` -> "Godot editor recommended"
   3. `...#section-0003` -> "Exported Godot project min"
   4. `...#section-0004` -> "Exported Godot project recommended + Note"

   Actually, to be safe and follow typical chunking, I'll make one chunk per top-level heading under "System requirements". But the prompt says "Return a JSON array of documentation chunk records." I'll just create a few logical chunks. Let's stick to 3 chunks for simplicity and completeness, or maybe just 1 chunk for the whole page if it's better. I'll go with 3 chunks covering the main sections.

   Let's carefully extract content for each chunk.
   I need to ensure `section_path` is a list of strings representing the heading hierarchy.
   `heading` is the section heading.
   `content` is the body text.
   `code_blocks` and `language_tags` are empty since there are no code blocks in this markdown.
   `godot_version_tags`: `["4.6"]`
   `api_symbols`: `[]`
   `symbol`: `""`
   `doc_type`: `about` (since it's system requirements/about page)
   `doc_version`: `stable` (from URL `en/stable/`)
   `source_url`: `https://docs.godotengine.org/en/stable/about/system_requirements.html`
   `source_file`: `pages/about__system_requirements__6f1863c2.md`
   `source_sha256`: `ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149`

   Let's draft Chunk 1:
   - chunk_id: `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001`
   - heading: `System requirements`
   - section_path: `["System requirements"]`
   - content: `Godot Engine 4.6 documentation in English\nSystem requirements\nEdit on GitHub\nLearn how to contribute!\nSystem requirements\n\nThis page contains system requirements for the editor and exported projects.\nThese specifications are given for informative purposes only, but they can be\nreferred to if you're looking to build or upgrade a system to use Godot on.\nGodot editor\n\nThese are the\nminimum\nspecifications required to run the Godot editor and work\non a simple 2D or 3D project:\nDesktop or laptop PC - Minimum\n\nCPU\nWindows:\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv8 CPU\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite\nmacOS:\nx86_64 or ARM CPU (Apple Silicon)\nExample: Intel Core 2 Duo SU9400, Apple M1\nLinux:\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv7 or\nARMv8 CPU\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4\nGPU\nForward+ renderer:\nIntegrated graphics with full Vulkan 1.0 support\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\nMobile renderer:\nIntegrated graphics with full Vulkan 1.0 support\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\nCompatibility renderer:\nIntegrated graphics with full OpenGL 3.3 support\nExample: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)\nRAM\nNative editor:\n4 GB\nWeb editor:\n8 GB\nStorage\n200 MB (used for the executable, project files and cache).\nExporting projects requires downloading export templates separately\n(1.3 GB after installation).\nOperating system\nNative editor:\nWindows 10, macOS 10.13 (Compatibility) or\nmacOS 10.15 (Forward+/Mobile), Linux distribution released after 2018\nWeb editor:\nRecent versions of mainstream browsers: Firefox and derivatives\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\nNote\nIf your x86_64 CPU does not support SSE4.2, you can still run the 32-bit Godot\nexecutable which only has a SSE2 requirement (all x86_64 CPUs support SSE2).\nWhile supported on Linux, we have no official minimum requirements for running on\nrv64 (RISC-V), ppc64 & ppc32 (PowerPC), and loongarch64. In addition you must\ncompile the editor for that platform (as well as export templates) yourself,\nno official downloads are currently provided. RISC-V compiling instructions can be found on the\nCompiling for Linux, *BSD\npage.\nMobile device (smartphone/tablet) - Minimum\n\nCPU\nAndroid:\nSoC with any 32-bit or 64-bit ARM or x86 CPU\nExample: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430\niOS:\nCannot run the editor\nGPU\nForward+ renderer:\nSoC featuring GPU with full Vulkan 1.0 support\nExample: Qualcomm Adreno 505, Mali-G71 MP2\nMobile renderer:\nSoC featuring GPU with full Vulkan 1.0 support\nExample: Qualcomm Adreno 505, Mali-G71 MP2\nCompatibility renderer:\nSoC featuring GPU with full OpenGL ES 3.0 support\nExample: Qualcomm Adreno 306, Mali-T628 MP6\nRAM\nNative editor:\n3 GB\nWeb editor:\n6 GB\nStorage\n200 MB (used for the executable, project files and cache)\nExporting projects requires downloading export templates separately\n(1.3 GB after installation)\nOperating system\nNative editor:\nAndroid 6.0 (Compatibility) or Android 9.0 (Forward+/Mobile)\nWeb editor:\nRecent versions of mainstream browsers: Firefox and derivatives\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.`
   - token_count: ~350
   - metadata: `{}`

   Chunk 2:
   - chunk_id: `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0002`
   - heading: `Godot editor recommended`
   - section_path: `["System requirements", "Godot editor", "Desktop or laptop PC - Recommended"]`
   - content: `These are the\nrecommended\nspecifications to get a smooth experience with the\nGodot editor on a simple 2D or 3D project:\nDesktop or laptop PC - Recommended\n\nCPU\nWindows:\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite\nmacOS:\nx86_64 or ARM CPU (Apple Silicon)\nExample: Intel Core i5-8500, Apple M1\nLinux:\nx86_64 CPU with SSE4.2 support, ARMv7 or ARMv8 CPU\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking\nGPU\nForward+ renderer:\nDedicated graphics with full Vulkan 1.2 support\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\nMobile renderer:\nDedicated graphics with full Vulkan 1.2 support\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\nCompatibility renderer:\nDedicated graphics with full OpenGL 4.6 support\nExample: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)\nRAM\nNative editor:\n8 GB\nWeb editor:\n12 GB\nStorage\n1.5 GB (used for the executable, project files, all export templates and cache)\nOperating system\nNative editor:\nWindows 10, macOS 10.15,\nLinux distribution released after 2020\nWeb editor:\nLatest version of Firefox, Chrome, Edge, Safari, Opera\nMobile device (smartphone/tablet) - Recommended\n\nCPU\nAndroid:\nSoC with 64-bit ARM or x86 CPU, with 3 "performance" cores or more\nExample: Qualcomm Snapdragon 845, Samsung Exynos 9810\niOS:\nCannot run the editor\nGPU\nForward+ renderer:\nSoC featuring GPU with full Vulkan 1.2 support\nExample: Qualcomm Adreno 630, Mali-G72 MP18\nMobile renderer:\nSoC featuring GPU with full Vulkan 1.2 support\nExample: Qualcomm Adreno 630, Mali-G72 MP18\nCompatibility renderer:\nSoC featuring GPU with full OpenGL ES 3.2 support\nExample: Qualcomm Adreno 630, Mali-G72 MP18\nRAM\nNative editor:\n6 GB\nWeb editor:\n8 GB\nStorage\n1.5 GB (used for the executable, project files, all export templates and cache)\nOperating system\nNative editor:\nAndroid 9.0\nWeb editor:\nLatest version of Firefox, Chrome, Edge, Safari, Opera,\nSamsung Internet`
   - token_count: ~380
   - metadata: `{}`

   Chunk 3:
   - chunk_id: `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0003`
   - heading: `Exported Godot project`
   - section_path: `["System requirements", "Exported Godot project"]`
   - content: `Exported Godot project\n\nWarning\nThe requirements below are a baseline for a\nsimple\n2D or 3D project,\nwith basic scripting and few visual flourishes. CPU, GPU, RAM and\nstorage requirements will heavily vary depending on your project's scope,\nits renderer, viewport resolution and graphics settings chosen.\nOther programs running on the system while the project is running\nwill also compete for resources, including RAM and video RAM.\nIt is strongly recommended to do your own testing on low-end hardware to\nmake sure your project runs at the desired speed. To provide scalability for\nlow-end hardware, you will also need to introduce a\ngraphics options menu\nto your project.\nThese are the\nminimum\nspecifications required to run a simple 2D or 3D\nproject exported with Godot:\nDesktop or laptop PC - Minimum\n\nCPU\nWindows:\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,\nARMv8 CPU\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite\nmacOS:\nx86_64 or ARM CPU (Apple Silicon)\nExample: Intel Core 2 Duo SU9400, Apple M1\nLinux:\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,\nARMv7 or ARMv8 CPU\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4\nGPU\nForward+ renderer:\nIntegrated graphics with full Vulkan 1.0 support,\nMetal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\nMobile renderer:\nIntegrated graphics with full Vulkan 1.0 support,\nMetal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\nCompatibility renderer:\nIntegrated graphics with full OpenGL 3.3 support\nor Direct3D 11 support (Windows).\nExample: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)\nRAM\nFor native exports:\n2 GB\nFor web exports:\n4 GB\nStorage\n150 MB (used for the executable, project files and cache)\nOperating system\nFor native exports:\nWindows 10, macOS 10.13 (Compatibility), macOS 10.15\n(Forward+/Mobile, Vulkan), macOS 13.0 (Forward+/Mobile, Metal), Linux distribution\nreleased after 2018\nWeb editor:\nRecent versions of mainstream browsers: Firefox and derivatives\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\nMobile device (smartphone/tablet) - Minimum\n\nCPU\nAndroid:\nSoC with any 32-bit or 64-bit ARM or x86 CPU\nExample: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430\niOS:\nSoC with any 64-bit ARM CPU\nExample: Apple A7 (iPhone 5S)\nGPU\nForward+ renderer:\nSoC featuring GPU with full Vulkan 1.0 support, or\nMetal 3 support (iOS/iPadOS)\nExample (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)\nExample (Metal): Apple A12 (iPhone XR/XS)\nMobile renderer:\nSoC featuring GPU with full Vulkan 1.0 support, or\nMetal 3 support (iOS/iPadOS)\nExample (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)\nExample (Metal): Apple A12 (iPhone XR/XS)\nCompatibility renderer:\nSoC featuring GPU with full OpenGL ES 3.0 support\nExample: Qualcomm Adreno 306, Mali-T628 MP6, Apple A7 (iPhone 5S)\nRAM\nFor native exports:\n1 GB\nFor web exports:\n2 GB\nStorage\n150 MB (used for the executable, project files and cache)\nOperating system\nFor native exports:\nAndroid 6.0 (Compatibility), Android 9.0 (Forward+/Mobile),\niOS 12.0 (Forward+/Mobile, Vulkan), iOS 16.0 (Forward+/Mobile, Metal)\nWeb editor:\nRecent versions of mainstream browsers: Firefox and derivatives\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\nThese are the\nrecommended\nspecifications to get a smooth experience with a\nsimple 2D or 3D project exported with Godot:\nDesktop or laptop PC - Recommended\n\nCPU\nWindows:\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite\nmacOS:\nx86_64 or ARM CPU (Apple Silicon)\nExample: Intel Core i5-8500, Apple M1\nLinux:\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more,\nARMv7 or ARMv8 CPU\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking\nGPU\nForward+ renderer:\nDedicated graphics with full Vulkan 1.2 support,\nMetal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\nMobile renderer:\nDedicated graphics with full Vulkan 1.2 support,\nMetal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\nCompatibility renderer:\nDedicated graphics with full OpenGL 4.6 support\nExample: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)\nRAM\nFor native exports:\n4 GB\nFor web exports:\n8 GB\nStorage\n150 MB (used for the executable, project files and cache)\nOperating system\nFor native exports:\nWindows 10, macOS 10.15 (Forward+/Mobile, Vulkan), macOS 13.0\n(Forward+/Mobile, Metal), Linux distribution released after 2020\nFor web exports:\nLatest version of Firefox, Chrome, Edge, Safari, Opera\nMobile device (smartphone/tablet) - Recommended\n\nCPU\nAndroid:\nSoC with 64-bit ARM or x86 CPU, with 3 "performance" cores or more\nExample: Qualcomm Snapdragon 845, Samsung Exynos 9810\niOS:\nSoC with 64-bit ARM CPU\nExample: Apple A14 (iPhone 12)\nGPU\nForward+ renderer:\nSoC featuring GPU with full Vulkan 1.2 support, or\nMetal 3 support (iOS/iPadOS)\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\nMobile renderer:\nSoC featuring GPU with full Vulkan 1.2 support, or\nMetal 3 support (iOS/iPadOS)\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\nCompatibility renderer:\nSoC featuring GPU with full OpenGL ES 3.2 support\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\nRAM\nFor native exports:\n2 GB\nFor web exports:\n4 GB\nStorage\n150 MB (used for the executable, project files and cache)\nOperating system\nFor native exports:\nAndroid 9.0, iOS 14.1 (Forward+/Mobile, Vulkan), iOS 16.0\n(Forward+/Mobile, Metal)\nFor web exports:\nLatest version of Firefox, Chrome, Edge, Safari, Opera,\nSamsung Internet\nNote\nGodot doesn't use OpenGL/OpenGL ES extensions introduced after OpenGL\n3.3/OpenGL ES 3.0, but GPUs supporting newer OpenGL/OpenGL ES versions\ngenerally have fewer driver issues.`
   - token_count: ~750
   - metadata: `{}`

   Let's verify constraints:
   - `chunk_id` matches `^godot-\w+:\S+` -> `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001` etc. OK.
   - `doc_version`: `stable` OK.
   - `source_url`: `https://docs.godotengine.org/en/stable/about/system_requirements.html` OK.
   - `source_file`: `pages/about__system_requirements__6f1863c2.md` OK.
   - `source_sha256`: `ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149` OK.
   - `doc_type`: `about` OK.
   - `symbol`: `""` OK.
   - `section_path`: list of strings. OK.
   - `heading`: string. OK.
   - `content`: string. OK.
   - `code_blocks`: `[]` OK.
   - `language_tags`: `[]` OK.
   - `godot_version_tags`: `["4.6"]` OK.
   - `api_symbols`: `[]` OK.
   - `token_count`: int. OK.
   - `metadata`: `{}` OK.

   I will format the JSON carefully. I'll make sure newlines in content are preserved as `\n`.
   I'll double check the exact field names and types.
   All good.
   One minor thing: `section_path` should reflect the hierarchy. For chunk 1, it's `["System requirements"]`. For chunk 2, `["System requirements", "Godot editor", "Desktop or laptop PC - Recommended"]`. For chunk 3, `["System requirements", "Exported Godot project"]`. This is fine.
   I will generate the JSON array now.
   I'll ensure no markdown code fences are used.
   I'll verify regex for chunk_id: `^godot-\w+:\S+` -> `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001` matches.
   All constraints met.
   Proceed. 
   Output matches exactly.
   One detail: `token_count` estimation. I'll just put reasonable numbers like 320, 360, 720.
   I will construct the JSON carefully.
   Let's produce it. 
   Self-Correction/Refinement during thought: 
   The prompt says "Return ONLY a JSON array — no markdown code fences, no explanation."
   I will make sure the output is raw JSON.
   I'll check `doc_type` options: `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. I used `about`. That's correct.
   `source_url` from markdown: `https://docs.godotengine.org/en/stable/about/system_requirements.html`
   `source_file`: `pages/about__system_requirements__6f1863c2.md`
   `source_sha256`: `ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149`
   All set.
   Generating. 
   [Output Generation] -> JSON array.✅
   Note: I'll escape newlines properly in JSON strings.
   I will structure it carefully.
   Done. 
   Output matches response. 
   Proceeds. 
   [Final Check of the Prompt]
   "chunk_id (str): MUST match regex ^godot-\w+:\S+. Use a deterministic value like godot-stable:pages/about__intro.md#section-0001."
   "doc_version (str): docs version such as stable, latest, 4.6, or unknown."
   "source_url (str): original docs URL if known, otherwise empty string."
   "source_file (str): exact local markdown path provided by the caller." -> `pages/about__system_requirements__6f1863c2.md`
   "source_sha256 (str): exact sha256 provided by the caller." -> `ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149`
   "doc_type (str): exactly one of class_reference, tutorial, migration, engine_details, about, other. Never use article."
   "symbol (str): class/API symbol or empty string."
   "section_path (list[str]): heading hierarchy."
   "heading (str): section heading."
   "content (str): searchable body text."
   "code_blocks (list[str]): extracted code blocks."
   "language_tags (list[str]): detected code languages."
   "godot_version_tags (list[str]): version hints."
   "api_symbols (list[str]): detected Godot symbols."
   "token_count (int): estimated token count."
   "metadata (dict): any extra metadata."
   All good.
   I will produce the JSON now. 
   One thing: I'll make sure the JSON is valid. I'll escape quotes if any, but there are none in the content. Newlines will be `\n`.
   Ready. 
   Output generation. 
   [Done] 
   *(Self-Correction/Verification during drafting)*
   I should verify that `section_path` for chunk 1 is just `["System requirements"]` or maybe `["Godot Engine 4.6 documentation in English", "System requirements"]`. The markdown starts with `# Source: ...` then `Godot Engine 4.6 documentation in English` then `System requirements`. I'll stick to `["System requirements"]` as it's the main heading. It's fine.
   I'll ensure `token_count` is an integer.
   All fields present.
   Proceeds. 
   Output matches the final JSON. 
   [Output Generation] -> *Proceeds*

Raw Conversion Response

{
  "finish_reason": "stop",
  "content": "[\n  {\n    \"chunk_id\": \"godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/system_requirements.html\",\n    \"source_file\": \"pages/about__system_requirements__6f1863c2.md\",\n    \"source_sha256\": \"ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\n      \"System requirements\"\n    ],\n    \"heading\": \"System requirements\",\n    \"content\": \"Godot Engine 4.6 documentation in English\\nSystem requirements\\nEdit on GitHub\\nLearn how to contribute!\\nSystem requirements\\n\\nThis page contains system requirements for the editor and exported projects.\\nThese specifications are given for informative purposes only, but they can be\\nreferred to if you're looking to build or upgrade a system to use Godot on.\\nGodot editor\\n\\nThese are the\\nminimum\\nspecifications required to run the Godot editor and work\\non a simple 2D or 3D project:\\nDesktop or laptop PC - Minimum\\n\\nCPU\\nWindows:\\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv8 CPU\\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite\\nmacOS:\\nx86_64 or ARM CPU (Apple Silicon)\\nExample: Intel Core 2 Duo SU9400, Apple M1\\nLinux:\\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv7 or\\nARMv8 CPU\\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4\\nGPU\\nForward+ renderer:\\nIntegrated graphics with full Vulkan 1.0 support\\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\\nMobile renderer:\\nIntegrated graphics with full Vulkan 1.0 support\\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\\nCompatibility renderer:\\nIntegrated graphics with full OpenGL 3.3 support\\nExample: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)\\nRAM\\nNative editor:\\n4 GB\\nWeb editor:\\n8 GB\\nStorage\\n200 MB (used for the executable, project files and cache).\\nExporting projects requires downloading export templates separately\\n(1.3 GB after installation).\\nOperating system\\nNative editor:\\nWindows 10, macOS 10.13 (Compatibility) or\\nmacOS 10.15 (Forward+/Mobile), Linux distribution released after 2018\\nWeb editor:\\nRecent versions of mainstream browsers: Firefox and derivatives\\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\\nNote\\nIf your x86_64 CPU does not support SSE4.2, you can still run the 32-bit Godot\\nexecutable which only has a SSE2 requirement (all x86_64 CPUs support SSE2).\\nWhile supported on Linux, we have no official minimum requirements for running on\\nrv64 (RISC-V), ppc64 & ppc32 (PowerPC), and loongarch64. In addition you must\\ncompile the editor for that platform (as well as export templates) yourself,\\nno official downloads are currently provided. RISC-V compiling instructions can be found on the\\nCompiling for Linux, *BSD\\npage.\\nMobile device (smartphone/tablet) - Minimum\\n\\nCPU\\nAndroid:\\nSoC with any 32-bit or 64-bit ARM or x86 CPU\\nExample: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430\\niOS:\\nCannot run the editor\\nGPU\\nForward+ renderer:\\nSoC featuring GPU with full Vulkan 1.0 support\\nExample: Qualcomm Adreno 505, Mali-G71 MP2\\nMobile renderer:\\nSoC featuring GPU with full Vulkan 1.0 support\\nExample: Qualcomm Adreno 505, Mali-G71 MP2\\nCompatibility renderer:\\nSoC featuring GPU with full OpenGL ES 3.0 support\\nExample: Qualcomm Adreno 306, Mali-T628 MP6\\nRAM\\nNative editor:\\n3 GB\\nWeb editor:\\n6 GB\\nStorage\\n200 MB (used for the executable, project files and cache)\\nExporting projects requires downloading export templates separately\\n(1.3 GB after installation)\\nOperating system\\nNative editor:\\nAndroid 6.0 (Compatibility) or Android 9.0 (Forward+/Mobile)\\nWeb editor:\\nRecent versions of mainstream browsers: Firefox and derivatives\\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\n      \"4.6\"\n    ],\n    \"api_symbols\": [],\n    \"token_count\": 345,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__system_requirements__6f1863c2.md#section-0002\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/system_requirements.html\",\n    \"source_file\": \"pages/about__system_requirements__6f1863c2.md\",\n    \"source_sha256\": \"ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\n      \"System requirements\",\n      \"Godot editor\",\n      \"Desktop or laptop PC - Recommended\"\n    ],\n    \"heading\": \"Godot editor recommended\",\n    \"content\": \"These are the\\nrecommended\\nspecifications to get a smooth experience with the\\nGodot editor on a simple 2D or 3D project:\\nDesktop or laptop PC - Recommended\\n\\nCPU\\nWindows:\\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU\\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite\\nmacOS:\\nx86_64 or ARM CPU (Apple Silicon)\\nExample: Intel Core i5-8500, Apple M1\\nLinux:\\nx86_64 CPU with SSE4.2 support, ARMv7 or ARMv8 CPU\\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking\\nGPU\\nForward+ renderer:\\nDedicated graphics with full Vulkan 1.2 support\\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\\nMobile renderer:\\nDedicated graphics with full Vulkan 1.2 support\\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\\nCompatibility renderer:\\nDedicated graphics with full OpenGL 4.6 support\\nExample: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)\\nRAM\\nNative editor:\\n8 GB\\nWeb editor:\\n12 GB\\nStorage\\n1.5 GB (used for the executable, project files, all export templates and cache)\\nOperating system\\nNative editor:\\nWindows 10, macOS 10.15,\\nLinux distribution released after 2020\\nWeb editor:\\nLatest version of Firefox, Chrome, Edge, Safari, Opera\\nMobile device (smartphone/tablet) - Recommended\\n\\nCPU\\nAndroid:\\nSoC with 64-bit ARM or x86 CPU, with 3 \\\"performance\\\" cores or more\\nExample: Qualcomm Snapdragon 845, Samsung Exynos 9810\\niOS:\\nCannot run the editor\\nGPU\\nForward+ renderer:\\nSoC featuring GPU with full Vulkan 1.2 support\\nExample: Qualcomm Adreno 630, Mali-G72 MP18\\nMobile renderer:\\nSoC featuring GPU with full Vulkan 1.2 support\\nExample: Qualcomm Adreno 630, Mali-G72 MP18\\nCompatibility renderer:\\nSoC featuring GPU with full OpenGL ES 3.2 support\\nExample: Qualcomm Adreno 630, Mali-G72 MP18\\nRAM\\nNative editor:\\n6 GB\\nWeb editor:\\n8 GB\\nStorage\\n1.5 GB (used for the executable, project files, all export templates and cache)\\nOperating system\\nNative editor:\\nAndroid 9.0\\nWeb editor:\\nLatest version of Firefox, Chrome, Edge, Safari, Opera,\\nSamsung Internet\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\n      \"4.6\"\n    ],\n    \"api_symbols\": [],\n    \"token_count\": 368,\n    \"metadata\": {}\n  },\n  {\n    \"chunk_id\": \"godot-stable:pages/about__system_requirements__6f1863c2.md#section-0003\",\n    \"doc_version\": \"stable\",\n    \"source_url\": \"https://docs.godotengine.org/en/stable/about/system_requirements.html\",\n    \"source_file\": \"pages/about__system_requirements__6f1863c2.md\",\n    \"source_sha256\": \"ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149\",\n    \"doc_type\": \"about\",\n    \"symbol\": \"\",\n    \"section_path\": [\n      \"System requirements\",\n      \"Exported Godot project\"\n    ],\n    \"heading\": \"Exported Godot project\",\n    \"content\": \"Exported Godot project\\n\\nWarning\\nThe requirements below are a baseline for a\\nsimple\\n2D or 3D project,\\nwith basic scripting and few visual flourishes. CPU, GPU, RAM and\\nstorage requirements will heavily vary depending on your project's scope,\\nits renderer, viewport resolution and graphics settings chosen.\\nOther programs running on the system while the project is running\\nwill also compete for resources, including RAM and video RAM.\\nIt is strongly recommended to do your own testing on low-end hardware to\\nmake sure your project runs at the desired speed. To provide scalability for\\nlow-end hardware, you will also need to introduce a\\ngraphics options menu\\nto your project.\\nThese are the\\nminimum\\nspecifications required to run a simple 2D or 3D\\nproject exported with Godot:\\nDesktop or laptop PC - Minimum\\n\\nCPU\\nWindows:\\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,\\nARMv8 CPU\\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite\\nmacOS:\\nx86_64 or ARM CPU (Apple Silicon)\\nExample: Intel Core 2 Duo SU9400, Apple M1\\nLinux:\\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,\\nARMv7 or ARMv8 CPU\\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4\\nGPU\\nForward+ renderer:\\nIntegrated graphics with full Vulkan 1.0 support,\\nMetal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)\\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\\nMobile renderer:\\nIntegrated graphics with full Vulkan 1.0 support,\\nMetal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)\\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\\nCompatibility renderer:\\nIntegrated graphics with full OpenGL 3.3 support\\nor Direct3D 11 support (Windows).\\nExample: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)\\nRAM\\nFor native exports:\\n2 GB\\nFor web exports:\\n4 GB\\nStorage\\n150 MB (used for the executable, project files and cache)\\nOperating system\\nFor native exports:\\nWindows 10, macOS 10.13 (Compatibility), macOS 10.15\\n(Forward+/Mobile, Vulkan), macOS 13.0 (Forward+/Mobile, Metal), Linux distribution\\nreleased after 2018\\nWeb editor:\\nRecent versions of mainstream browsers: Firefox and derivatives\\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\\nMobile device (smartphone/tablet) - Minimum\\n\\nCPU\\nAndroid:\\nSoC with any 32-bit or 64-bit ARM or x86 CPU\\nExample: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430\\niOS:\\nSoC with any 64-bit ARM CPU\\nExample: Apple A7 (iPhone 5S)\\nGPU\\nForward+ renderer:\\nSoC featuring GPU with full Vulkan 1.0 support, or\\nMetal 3 support (iOS/iPadOS)\\nExample (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)\\nExample (Metal): Apple A12 (iPhone XR/XS)\\nMobile renderer:\\nSoC featuring GPU with full Vulkan 1.0 support, or\\nMetal 3 support (iOS/iPadOS)\\nExample (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)\\nExample (Metal): Apple A12 (iPhone XR/XS)\\nCompatibility renderer:\\nSoC featuring GPU with full OpenGL ES 3.0 support\\nExample: Qualcomm Adreno 306, Mali-T628 MP6, Apple A7 (iPhone 5S)\\nRAM\\nFor native exports:\\n1 GB\\nFor web exports:\\n2 GB\\nStorage\\n150 MB (used for the executable, project files and cache)\\nOperating system\\nFor native exports:\\nAndroid 6.0 (Compatibility), Android 9.0 (Forward+/Mobile),\\niOS 12.0 (Forward+/Mobile, Vulkan), iOS 16.0 (Forward+/Mobile, Metal)\\nWeb editor:\\nRecent versions of mainstream browsers: Firefox and derivatives\\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\\nThese are the\\nrecommended\\nspecifications to get a smooth experience with a\\nsimple 2D or 3D project exported with Godot:\\nDesktop or laptop PC - Recommended\\n\\nCPU\\nWindows:\\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU\\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite\\nmacOS:\\nx86_64 or ARM CPU (Apple Silicon)\\nExample: Intel Core i5-8500, Apple M1\\nLinux:\\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more,\\nARMv7 or ARMv8 CPU\\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking\\nGPU\\nForward+ renderer:\\nDedicated graphics with full Vulkan 1.2 support,\\nMetal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)\\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\\nMobile renderer:\\nDedicated graphics with full Vulkan 1.2 support,\\nMetal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)\\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\\nCompatibility renderer:\\nDedicated graphics with full OpenGL 4.6 support\\nExample: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)\\nRAM\\nFor native exports:\\n4 GB\\nFor web exports:\\n8 GB\\nStorage\\n150 MB (used for the executable, project files and cache)\\nOperating system\\nFor native exports:\\nWindows 10, macOS 10.15 (Forward+/Mobile, Vulkan), macOS 13.0\\n(Forward+/Mobile, Metal), Linux distribution released after 2020\\nFor web exports:\\nLatest version of Firefox, Chrome, Edge, Safari, Opera\\nMobile device (smartphone/tablet) - Recommended\\n\\nCPU\\nAndroid:\\nSoC with 64-bit ARM or x86 CPU, with 3 \\\"performance\\\" cores or more\\nExample: Qualcomm Snapdragon 845, Samsung Exynos 9810\\niOS:\\nSoC with 64-bit ARM CPU\\nExample: Apple A14 (iPhone 12)\\nGPU\\nForward+ renderer:\\nSoC featuring GPU with full Vulkan 1.2 support, or\\nMetal 3 support (iOS/iPadOS)\\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\\nMobile renderer:\\nSoC featuring GPU with full Vulkan 1.2 support, or\\nMetal 3 support (iOS/iPadOS)\\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\\nCompatibility renderer:\\nSoC featuring GPU with full OpenGL ES 3.2 support\\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\\nRAM\\nFor native exports:\\n2 GB\\nFor web exports:\\n4 GB\\nStorage\\n150 MB (used for the executable, project files and cache)\\nOperating system\\nFor native exports:\\nAndroid 9.0, iOS 14.1 (Forward+/Mobile, Vulkan), iOS 16.0\\n(Forward+/Mobile, Metal)\\nFor web exports:\\nLatest version of Firefox, Chrome, Edge, Safari, Opera,\\nSamsung Internet\\nNote\\nGodot doesn't use OpenGL/OpenGL ES extensions introduced after OpenGL\\n3.3/OpenGL ES 3.0, but GPUs supporting newer OpenGL/OpenGL ES versions\\ngenerally have fewer driver issues.\",\n    \"code_blocks\": [],\n    \"language_tags\": [],\n    \"godot_version_tags\": [\n      \"4.6\"\n    ],\n    \"api_symbols\": [],\n    \"token_count\": 742,\n    \"metadata\": {}\n  }\n]",
  "reasoning_content": "Here's a thinking process:\n\n1.  **Analyze User Input:**\n   - **Table:** `docs_chunks`\n   - **Required Fields:** `chunk_id`, `doc_version`, `source_url`, `source_file`, `source_sha256`, `doc_type`, `symbol`, `section_path`, `heading`, `content`, `code_blocks`, `language_tags`, `godot_version_tags`, `api_symbols`, `token_count`, `metadata`\n   - **Rules:**\n     - `chunk_id`: Must match `^godot-\\w+:\\S+`. Use deterministic like `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001`. Never `chunk_0` or plain numeric.\n     - `doc_version`: e.g., `stable`, `latest`, `4.6`, `unknown`.\n     - `source_url`: original docs URL if known, else `\"\"`.\n     - `source_file`: MUST be `pages/about__system_requirements__6f1863c2.md`.\n     - `source_sha256`: MUST be `ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149` when field exists.\n     - `doc_type`: exactly one of `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. Never `article`.\n     - `symbol`: class/API symbol or `\"\"`.\n     - `section_path`: list[str] heading hierarchy.\n     - `heading`: section heading.\n     - `content`: searchable body text.\n     - `code_blocks`: list[str] extracted code blocks.\n     - `language_tags`: list[str] detected code languages.\n     - `godot_version_tags`: list[str] version hints.\n     - `api_symbols`: list[str] detected Godot symbols.\n     - `token_count`: int estimated token count.\n     - `metadata`: dict extra metadata.\n   - **Input Markdown:** A documentation page about Godot 4.6 system requirements. It has sections like \"System requirements\", \"Godot editor\", \"Desktop or laptop PC - Minimum\", \"Mobile device (smartphone/tablet) - Minimum\", \"Exported Godot project\", etc.\n   - **Output Format:** JSON array of records. No markdown fences, no explanation.\n\n2.  **Determine Chunking Strategy:**\n   The prompt asks for \"documentation chunk records\". I should split the markdown into logical chunks based on headings. I'll create one record per major section to keep it manageable, or maybe just one record for the whole page if it's short, but splitting by top-level headings is usually better for RAG. Let's look at the structure:\n   - `# Source: https://...` (header)\n   - `Godot Engine 4.6 documentation in English`\n   - `System requirements` (H1/H2?)\n   - `Godot editor` (H2)\n     - `Desktop or laptop PC - Minimum` (H3)\n     - `Mobile device (smartphone/tablet) - Minimum` (H3)\n     - `Desktop or laptop PC - Recommended` (H3)\n     - `Mobile device (smartphone/tablet) - Recommended` (H3)\n   - `Exported Godot project` (H2)\n     - `Desktop or laptop PC - Minimum` (H3)\n     - `Mobile device (smartphone/tablet) - Minimum` (H3)\n     - `Desktop or laptop PC - Recommended` (H3)\n     - `Mobile device (smartphone/tablet) - Recommended` (H3)\n   - `Note` (H3)\n\n   I'll create chunks for each major section to keep `content` focused. I'll aim for ~4-5 chunks.\n   Let's define chunks:\n   1. `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001` -> \"System requirements\" (intro + Godot editor min)\n   2. `...#section-0002` -> \"Godot editor recommended\"\n   3. `...#section-0003` -> \"Exported Godot project min\"\n   4. `...#section-0004` -> \"Exported Godot project recommended + Note\"\n\n   Actually, to be safe and follow typical chunking, I'll make one chunk per top-level heading under \"System requirements\". But the prompt says \"Return a JSON array of documentation chunk records.\" I'll just create a few logical chunks. Let's stick to 3 chunks for simplicity and completeness, or maybe just 1 chunk for the whole page if it's better. I'll go with 3 chunks covering the main sections.\n\n   Let's carefully extract content for each chunk.\n   I need to ensure `section_path` is a list of strings representing the heading hierarchy.\n   `heading` is the section heading.\n   `content` is the body text.\n   `code_blocks` and `language_tags` are empty since there are no code blocks in this markdown.\n   `godot_version_tags`: `[\"4.6\"]`\n   `api_symbols`: `[]`\n   `symbol`: `\"\"`\n   `doc_type`: `about` (since it's system requirements/about page)\n   `doc_version`: `stable` (from URL `en/stable/`)\n   `source_url`: `https://docs.godotengine.org/en/stable/about/system_requirements.html`\n   `source_file`: `pages/about__system_requirements__6f1863c2.md`\n   `source_sha256`: `ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149`\n\n   Let's draft Chunk 1:\n   - chunk_id: `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001`\n   - heading: `System requirements`\n   - section_path: `[\"System requirements\"]`\n   - content: `Godot Engine 4.6 documentation in English\\nSystem requirements\\nEdit on GitHub\\nLearn how to contribute!\\nSystem requirements\\n\\nThis page contains system requirements for the editor and exported projects.\\nThese specifications are given for informative purposes only, but they can be\\nreferred to if you're looking to build or upgrade a system to use Godot on.\\nGodot editor\\n\\nThese are the\\nminimum\\nspecifications required to run the Godot editor and work\\non a simple 2D or 3D project:\\nDesktop or laptop PC - Minimum\\n\\nCPU\\nWindows:\\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv8 CPU\\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite\\nmacOS:\\nx86_64 or ARM CPU (Apple Silicon)\\nExample: Intel Core 2 Duo SU9400, Apple M1\\nLinux:\\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support, ARMv7 or\\nARMv8 CPU\\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4\\nGPU\\nForward+ renderer:\\nIntegrated graphics with full Vulkan 1.0 support\\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\\nMobile renderer:\\nIntegrated graphics with full Vulkan 1.0 support\\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\\nCompatibility renderer:\\nIntegrated graphics with full OpenGL 3.3 support\\nExample: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)\\nRAM\\nNative editor:\\n4 GB\\nWeb editor:\\n8 GB\\nStorage\\n200 MB (used for the executable, project files and cache).\\nExporting projects requires downloading export templates separately\\n(1.3 GB after installation).\\nOperating system\\nNative editor:\\nWindows 10, macOS 10.13 (Compatibility) or\\nmacOS 10.15 (Forward+/Mobile), Linux distribution released after 2018\\nWeb editor:\\nRecent versions of mainstream browsers: Firefox and derivatives\\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\\nNote\\nIf your x86_64 CPU does not support SSE4.2, you can still run the 32-bit Godot\\nexecutable which only has a SSE2 requirement (all x86_64 CPUs support SSE2).\\nWhile supported on Linux, we have no official minimum requirements for running on\\nrv64 (RISC-V), ppc64 & ppc32 (PowerPC), and loongarch64. In addition you must\\ncompile the editor for that platform (as well as export templates) yourself,\\nno official downloads are currently provided. RISC-V compiling instructions can be found on the\\nCompiling for Linux, *BSD\\npage.\\nMobile device (smartphone/tablet) - Minimum\\n\\nCPU\\nAndroid:\\nSoC with any 32-bit or 64-bit ARM or x86 CPU\\nExample: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430\\niOS:\\nCannot run the editor\\nGPU\\nForward+ renderer:\\nSoC featuring GPU with full Vulkan 1.0 support\\nExample: Qualcomm Adreno 505, Mali-G71 MP2\\nMobile renderer:\\nSoC featuring GPU with full Vulkan 1.0 support\\nExample: Qualcomm Adreno 505, Mali-G71 MP2\\nCompatibility renderer:\\nSoC featuring GPU with full OpenGL ES 3.0 support\\nExample: Qualcomm Adreno 306, Mali-T628 MP6\\nRAM\\nNative editor:\\n3 GB\\nWeb editor:\\n6 GB\\nStorage\\n200 MB (used for the executable, project files and cache)\\nExporting projects requires downloading export templates separately\\n(1.3 GB after installation)\\nOperating system\\nNative editor:\\nAndroid 6.0 (Compatibility) or Android 9.0 (Forward+/Mobile)\\nWeb editor:\\nRecent versions of mainstream browsers: Firefox and derivatives\\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.`\n   - token_count: ~350\n   - metadata: `{}`\n\n   Chunk 2:\n   - chunk_id: `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0002`\n   - heading: `Godot editor recommended`\n   - section_path: `[\"System requirements\", \"Godot editor\", \"Desktop or laptop PC - Recommended\"]`\n   - content: `These are the\\nrecommended\\nspecifications to get a smooth experience with the\\nGodot editor on a simple 2D or 3D project:\\nDesktop or laptop PC - Recommended\\n\\nCPU\\nWindows:\\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU\\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite\\nmacOS:\\nx86_64 or ARM CPU (Apple Silicon)\\nExample: Intel Core i5-8500, Apple M1\\nLinux:\\nx86_64 CPU with SSE4.2 support, ARMv7 or ARMv8 CPU\\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking\\nGPU\\nForward+ renderer:\\nDedicated graphics with full Vulkan 1.2 support\\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\\nMobile renderer:\\nDedicated graphics with full Vulkan 1.2 support\\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\\nCompatibility renderer:\\nDedicated graphics with full OpenGL 4.6 support\\nExample: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)\\nRAM\\nNative editor:\\n8 GB\\nWeb editor:\\n12 GB\\nStorage\\n1.5 GB (used for the executable, project files, all export templates and cache)\\nOperating system\\nNative editor:\\nWindows 10, macOS 10.15,\\nLinux distribution released after 2020\\nWeb editor:\\nLatest version of Firefox, Chrome, Edge, Safari, Opera\\nMobile device (smartphone/tablet) - Recommended\\n\\nCPU\\nAndroid:\\nSoC with 64-bit ARM or x86 CPU, with 3 \"performance\" cores or more\\nExample: Qualcomm Snapdragon 845, Samsung Exynos 9810\\niOS:\\nCannot run the editor\\nGPU\\nForward+ renderer:\\nSoC featuring GPU with full Vulkan 1.2 support\\nExample: Qualcomm Adreno 630, Mali-G72 MP18\\nMobile renderer:\\nSoC featuring GPU with full Vulkan 1.2 support\\nExample: Qualcomm Adreno 630, Mali-G72 MP18\\nCompatibility renderer:\\nSoC featuring GPU with full OpenGL ES 3.2 support\\nExample: Qualcomm Adreno 630, Mali-G72 MP18\\nRAM\\nNative editor:\\n6 GB\\nWeb editor:\\n8 GB\\nStorage\\n1.5 GB (used for the executable, project files, all export templates and cache)\\nOperating system\\nNative editor:\\nAndroid 9.0\\nWeb editor:\\nLatest version of Firefox, Chrome, Edge, Safari, Opera,\\nSamsung Internet`\n   - token_count: ~380\n   - metadata: `{}`\n\n   Chunk 3:\n   - chunk_id: `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0003`\n   - heading: `Exported Godot project`\n   - section_path: `[\"System requirements\", \"Exported Godot project\"]`\n   - content: `Exported Godot project\\n\\nWarning\\nThe requirements below are a baseline for a\\nsimple\\n2D or 3D project,\\nwith basic scripting and few visual flourishes. CPU, GPU, RAM and\\nstorage requirements will heavily vary depending on your project's scope,\\nits renderer, viewport resolution and graphics settings chosen.\\nOther programs running on the system while the project is running\\nwill also compete for resources, including RAM and video RAM.\\nIt is strongly recommended to do your own testing on low-end hardware to\\nmake sure your project runs at the desired speed. To provide scalability for\\nlow-end hardware, you will also need to introduce a\\ngraphics options menu\\nto your project.\\nThese are the\\nminimum\\nspecifications required to run a simple 2D or 3D\\nproject exported with Godot:\\nDesktop or laptop PC - Minimum\\n\\nCPU\\nWindows:\\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,\\nARMv8 CPU\\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Snapdragon X Elite\\nmacOS:\\nx86_64 or ARM CPU (Apple Silicon)\\nExample: Intel Core 2 Duo SU9400, Apple M1\\nLinux:\\nx86_32 CPU with SSE2 support, x86_64 CPU with SSE4.2 support,\\nARMv7 or ARMv8 CPU\\nExample: Intel Core 2 Duo E8200, AMD FX-4100, Raspberry Pi 4\\nGPU\\nForward+ renderer:\\nIntegrated graphics with full Vulkan 1.0 support,\\nMetal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)\\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\\nMobile renderer:\\nIntegrated graphics with full Vulkan 1.0 support,\\nMetal 3 support (macOS) or Direct3D 12 (12_0 feature level) support (Windows)\\nExample: Intel HD Graphics 510 (Skylake), AMD Radeon R5 Graphics (Kaveri)\\nCompatibility renderer:\\nIntegrated graphics with full OpenGL 3.3 support\\nor Direct3D 11 support (Windows).\\nExample: Intel HD Graphics 2500 (Ivy Bridge), AMD Radeon R5 Graphics (Kaveri)\\nRAM\\nFor native exports:\\n2 GB\\nFor web exports:\\n4 GB\\nStorage\\n150 MB (used for the executable, project files and cache)\\nOperating system\\nFor native exports:\\nWindows 10, macOS 10.13 (Compatibility), macOS 10.15\\n(Forward+/Mobile, Vulkan), macOS 13.0 (Forward+/Mobile, Metal), Linux distribution\\nreleased after 2018\\nWeb editor:\\nRecent versions of mainstream browsers: Firefox and derivatives\\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\\nMobile device (smartphone/tablet) - Minimum\\n\\nCPU\\nAndroid:\\nSoC with any 32-bit or 64-bit ARM or x86 CPU\\nExample: Qualcomm Snapdragon 430, Samsung Exynos 5 Octa 5430\\niOS:\\nSoC with any 64-bit ARM CPU\\nExample: Apple A7 (iPhone 5S)\\nGPU\\nForward+ renderer:\\nSoC featuring GPU with full Vulkan 1.0 support, or\\nMetal 3 support (iOS/iPadOS)\\nExample (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)\\nExample (Metal): Apple A12 (iPhone XR/XS)\\nMobile renderer:\\nSoC featuring GPU with full Vulkan 1.0 support, or\\nMetal 3 support (iOS/iPadOS)\\nExample (Vulkan): Qualcomm Adreno 505, Mali-G71 MP2, Apple A12 (iPhone XR/XS)\\nExample (Metal): Apple A12 (iPhone XR/XS)\\nCompatibility renderer:\\nSoC featuring GPU with full OpenGL ES 3.0 support\\nExample: Qualcomm Adreno 306, Mali-T628 MP6, Apple A7 (iPhone 5S)\\nRAM\\nFor native exports:\\n1 GB\\nFor web exports:\\n2 GB\\nStorage\\n150 MB (used for the executable, project files and cache)\\nOperating system\\nFor native exports:\\nAndroid 6.0 (Compatibility), Android 9.0 (Forward+/Mobile),\\niOS 12.0 (Forward+/Mobile, Vulkan), iOS 16.0 (Forward+/Mobile, Metal)\\nWeb editor:\\nRecent versions of mainstream browsers: Firefox and derivatives\\n(including ESR), Chrome and Chromium derivatives, Safari and WebKit derivatives.\\nThese are the\\nrecommended\\nspecifications to get a smooth experience with a\\nsimple 2D or 3D project exported with Godot:\\nDesktop or laptop PC - Recommended\\n\\nCPU\\nWindows:\\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more, ARMv8 CPU\\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Snapdragon X Elite\\nmacOS:\\nx86_64 or ARM CPU (Apple Silicon)\\nExample: Intel Core i5-8500, Apple M1\\nLinux:\\nx86_64 CPU with SSE4.2 support, with 4 physical cores or more,\\nARMv7 or ARMv8 CPU\\nExample: Intel Core i5-6600K, AMD Ryzen 5 1600, Raspberry Pi 5 with overclocking\\nGPU\\nForward+ renderer:\\nDedicated graphics with full Vulkan 1.2 support,\\nMetal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)\\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\\nMobile renderer:\\nDedicated graphics with full Vulkan 1.2 support,\\nMetal 3 support (macOS), or Direct3D 12 (12_0 feature level) support (Windows)\\nExample: NVIDIA GeForce GTX 1050 (Pascal), AMD Radeon RX 460 (GCN 4.0)\\nCompatibility renderer:\\nDedicated graphics with full OpenGL 4.6 support\\nExample: NVIDIA GeForce GTX 650 (Kepler), AMD Radeon HD 7750 (GCN 1.0)\\nRAM\\nFor native exports:\\n4 GB\\nFor web exports:\\n8 GB\\nStorage\\n150 MB (used for the executable, project files and cache)\\nOperating system\\nFor native exports:\\nWindows 10, macOS 10.15 (Forward+/Mobile, Vulkan), macOS 13.0\\n(Forward+/Mobile, Metal), Linux distribution released after 2020\\nFor web exports:\\nLatest version of Firefox, Chrome, Edge, Safari, Opera\\nMobile device (smartphone/tablet) - Recommended\\n\\nCPU\\nAndroid:\\nSoC with 64-bit ARM or x86 CPU, with 3 \"performance\" cores or more\\nExample: Qualcomm Snapdragon 845, Samsung Exynos 9810\\niOS:\\nSoC with 64-bit ARM CPU\\nExample: Apple A14 (iPhone 12)\\nGPU\\nForward+ renderer:\\nSoC featuring GPU with full Vulkan 1.2 support, or\\nMetal 3 support (iOS/iPadOS)\\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\\nMobile renderer:\\nSoC featuring GPU with full Vulkan 1.2 support, or\\nMetal 3 support (iOS/iPadOS)\\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\\nCompatibility renderer:\\nSoC featuring GPU with full OpenGL ES 3.2 support\\nExample: Qualcomm Adreno 630, Mali-G72 MP18, Apple A14 (iPhone 12)\\nRAM\\nFor native exports:\\n2 GB\\nFor web exports:\\n4 GB\\nStorage\\n150 MB (used for the executable, project files and cache)\\nOperating system\\nFor native exports:\\nAndroid 9.0, iOS 14.1 (Forward+/Mobile, Vulkan), iOS 16.0\\n(Forward+/Mobile, Metal)\\nFor web exports:\\nLatest version of Firefox, Chrome, Edge, Safari, Opera,\\nSamsung Internet\\nNote\\nGodot doesn't use OpenGL/OpenGL ES extensions introduced after OpenGL\\n3.3/OpenGL ES 3.0, but GPUs supporting newer OpenGL/OpenGL ES versions\\ngenerally have fewer driver issues.`\n   - token_count: ~750\n   - metadata: `{}`\n\n   Let's verify constraints:\n   - `chunk_id` matches `^godot-\\w+:\\S+` -> `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001` etc. OK.\n   - `doc_version`: `stable` OK.\n   - `source_url`: `https://docs.godotengine.org/en/stable/about/system_requirements.html` OK.\n   - `source_file`: `pages/about__system_requirements__6f1863c2.md` OK.\n   - `source_sha256`: `ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149` OK.\n   - `doc_type`: `about` OK.\n   - `symbol`: `\"\"` OK.\n   - `section_path`: list of strings. OK.\n   - `heading`: string. OK.\n   - `content`: string. OK.\n   - `code_blocks`: `[]` OK.\n   - `language_tags`: `[]` OK.\n   - `godot_version_tags`: `[\"4.6\"]` OK.\n   - `api_symbols`: `[]` OK.\n   - `token_count`: int. OK.\n   - `metadata`: `{}` OK.\n\n   I will format the JSON carefully. I'll make sure newlines in content are preserved as `\\n`.\n   I'll double check the exact field names and types.\n   All good.\n   One minor thing: `section_path` should reflect the hierarchy. For chunk 1, it's `[\"System requirements\"]`. For chunk 2, `[\"System requirements\", \"Godot editor\", \"Desktop or laptop PC - Recommended\"]`. For chunk 3, `[\"System requirements\", \"Exported Godot project\"]`. This is fine.\n   I will generate the JSON array now.\n   I'll ensure no markdown code fences are used.\n   I'll verify regex for chunk_id: `^godot-\\w+:\\S+` -> `godot-stable:pages/about__system_requirements__6f1863c2.md#section-0001` matches.\n   All constraints met.\n   Proceed. \n   Output matches exactly.\n   One detail: `token_count` estimation. I'll just put reasonable numbers like 320, 360, 720.\n   I will construct the JSON carefully.\n   Let's produce it. \n   Self-Correction/Refinement during thought: \n   The prompt says \"Return ONLY a JSON array — no markdown code fences, no explanation.\"\n   I will make sure the output is raw JSON.\n   I'll check `doc_type` options: `class_reference`, `tutorial`, `migration`, `engine_details`, `about`, `other`. I used `about`. That's correct.\n   `source_url` from markdown: `https://docs.godotengine.org/en/stable/about/system_requirements.html`\n   `source_file`: `pages/about__system_requirements__6f1863c2.md`\n   `source_sha256`: `ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149`\n   All set.\n   Generating. \n   [Output Generation] -> JSON array.✅\n   Note: I'll escape newlines properly in JSON strings.\n   I will structure it carefully.\n   Done. \n   Output matches response. \n   Proceeds. \n   [Final Check of the Prompt]\n   \"chunk_id (str): MUST match regex ^godot-\\w+:\\S+. Use a deterministic value like godot-stable:pages/about__intro.md#section-0001.\"\n   \"doc_version (str): docs version such as stable, latest, 4.6, or unknown.\"\n   \"source_url (str): original docs URL if known, otherwise empty string.\"\n   \"source_file (str): exact local markdown path provided by the caller.\" -> `pages/about__system_requirements__6f1863c2.md`\n   \"source_sha256 (str): exact sha256 provided by the caller.\" -> `ec1de3531b1038ee9003b6fd79b98184967cf13a95159575513ceac6c9349149`\n   \"doc_type (str): exactly one of class_reference, tutorial, migration, engine_details, about, other. Never use article.\"\n   \"symbol (str): class/API symbol or empty string.\"\n   \"section_path (list[str]): heading hierarchy.\"\n   \"heading (str): section heading.\"\n   \"content (str): searchable body text.\"\n   \"code_blocks (list[str]): extracted code blocks.\"\n   \"language_tags (list[str]): detected code languages.\"\n   \"godot_version_tags (list[str]): version hints.\"\n   \"api_symbols (list[str]): detected Godot symbols.\"\n   \"token_count (int): estimated token count.\"\n   \"metadata (dict): any extra metadata.\"\n   All good.\n   I will produce the JSON now. \n   One thing: I'll make sure the JSON is valid. I'll escape quotes if any, but there are none in the content. Newlines will be `\\n`.\n   Ready. \n   Output generation. \n   [Done] \n   *(Self-Correction/Verification during drafting)*\n   I should verify that `section_path` for chunk 1 is just `[\"System requirements\"]` or maybe `[\"Godot Engine 4.6 documentation in English\", \"System requirements\"]`. The markdown starts with `# Source: ...` then `Godot Engine 4.6 documentation in English` then `System requirements`. I'll stick to `[\"System requirements\"]` as it's the main heading. It's fine.\n   I'll ensure `token_count` is an integer.\n   All fields present.\n   Proceeds. \n   Output matches the final JSON. \n   [Output Generation] -> *Proceeds*\n"
}

Purpose

Observation Timestamp State

Processing Log

Classification Debug

1. pages/404__8fea2a72.md

Request Message Summary

Full Classification Prompt Sent To Qwen

Classification Response Finish Reason

Classification Response Content

Classification Response Reasoning Content

Raw Classification Response

2. pages/about__complying_with_licenses__d36558dd.md

Request Message Summary

Full Classification Prompt Sent To Qwen

Classification Response Finish Reason

Classification Response Content

Classification Response Reasoning Content

Raw Classification Response

3. pages/about__docs_changelog__67dbc069.md

Request Message Summary

Full Classification Prompt Sent To Qwen

Classification Response Finish Reason

Classification Response Content

Classification Response Reasoning Content

Raw Classification Response

4. pages/about__faq__32bebcf7.md

Request Message Summary

Full Classification Prompt Sent To Qwen

Classification Response Finish Reason

Classification Response Content

Classification Response Reasoning Content

Raw Classification Response

5. pages/about__introduction__344b3840.md

Request Message Summary

Full Classification Prompt Sent To Qwen

Classification Response Finish Reason

Classification Response Content

Classification Response Reasoning Content

Raw Classification Response

6. pages/about__list_of_features__273abdc4.md

Request Message Summary

Full Classification Prompt Sent To Qwen

Classification Response Finish Reason

Classification Response Content

Classification Response Reasoning Content

Raw Classification Response

7. pages/about__release_policy__9f3af805.md

Request Message Summary

Full Classification Prompt Sent To Qwen

Classification Response Finish Reason

Classification Response Content

Classification Response Reasoning Content

Raw Classification Response

8. pages/about__system_requirements__6f1863c2.md

Request Message Summary

Full Classification Prompt Sent To Qwen

Classification Response Finish Reason

Classification Response Content

Classification Response Reasoning Content

Raw Classification Response

9. pages/classes__class___40gdscript__a254d64e.md

Request Message Summary

Full Classification Prompt Sent To Qwen

Classification Response Finish Reason

Classification Response Content

Classification Response Reasoning Content

Raw Classification Response

Conversion Debug

1. pages/about__complying_with_licenses__d36558dd.md::docs_chunks

Request Message Summary

Full Conversion Prompt Sent To Qwen

Conversion Response Finish Reason

Conversion Response Content

Conversion Response Reasoning Content

Raw Conversion Response

2. pages/about__docs_changelog__67dbc069.md::docs_chunks

Request Message Summary

Full Conversion Prompt Sent To Qwen

Conversion Response Content

3. pages/about__faq__32bebcf7.md::docs_chunks

4. pages/aboutfaq32bebcf7.md

5. pages/aboutintroduction344b3840.md

9. pages/classesclass_40gdscript__a254d64e.md

3. pages/aboutfaq32bebcf7.md::docs_chunks

4. pages/aboutintroduction344b3840.md::docs_chunks