text:
# Awesome Annual Security Reports [![Awesome](https://awesome.re/badge.svg)](https://awesome.re)
> A curated list of annual cyber security reports - Centralized cybersecurity information free from sales nuisance.

**Definition:** The state of being secure has a temporal dimension which security vendors utilize to stay relevant through annual reports. CIO, CISO, and security leaders are faced with the challenge of sifting the valuable information from marketing material. In addition to filtering for type of information leaders are challenged with staying abreast of new security vendors and partnerships. This list seeks to lower the barrier for access to this information while remaining agnostic to providers.

**Disclaimer:** The reports in this collection are limited to content which does not require a paid subscription, membership, or service contract. There are a variety of different business models and drivers that would cause information to be put behind a paywall, I would like to respect those companies and individuals. Consult the original authors for licensing of any report content.

**Limitations:** This is **not** a collection of project based information such as white papers, intelligence reports, technical specifications, or standards. I welcome all user submitted uploads or report requests, but we should draw a box around this _awesome_ list. All reports will be sourced from the original author when possible and uploaded to [Hybrid Analysis](https://www.hybrid-analysis.com/) for an additional level of confidence, result link will be included in the readme.md commit notes.

**Acknowledgement:** I would like to give recognition for other works that inspired this collection. [Richard Stiennon](https://it-harvest.com/about/) and his annual analysis of the cybersecurity industry is much more comprehensive than this repository. [Rick Howard](https://www.paloaltonetworks.com/blog/author/rick/) and his cyber cannon list of must read books is a tremendous resource, at both leadership and practitioner levels.

## Contents
- [Reports](#reports)
  - [Analysis](#analysis)
  - [Surveys](#surveys)
- [Resources](#resources)
  - [Research Consulting](#research-consulting)
  - [Working Groups](#working-groups)
- [Contributing](#contributing)
---
## Reports
Reports have been classified into two categories by the source of data.
1. **Analysis:** Reports generated from quantifying and qualifying intelligence from sensor networks or services.
2. **Survey:** Reports generated from observations and feedback from surveys or consulting engagements.

### Analysis
|Provider|Report Name|Year|Data Type|
|:---|:---|:---|:---|
|[Accenture](https://www.accenture.com/us-en/insights/security/cyber-threat-intelligence-report-2021)|[Cyber Threat Intelligence Report](Annual%20Security%20Reports/2021/Accenture-Cyber-Threat-Intelligence-Report-2021.pdf)|2021|Attacks|
|[Accenture](https://www.accenture.com/us-en/insights/security/cyber-threat-intelligence-report-2021-vol-2)|[Cyber Threat Intelligence Report Volume 2](Annual%20Security%20Reports/2022/Accenture-Cyber-Threat-Intelligence-Report-Vol2-2022.pdf)|2022|Attacks|
|[Aon](https://insights.aon.com/2021-cyber-risk-report/home/)|[Cybersecurity Risk Report](Annual%20Security%20Reports/2020/Aon-Cyber-Security-Risk-Report-2020.pdf)|2020|Industry|
|[CheckPoint](https://pages.checkpoint.com/cyber-security-report-2022.html)|[Cybersecurity Report](Annual%20Security%20Reports/2023/CheckPoint-Cybersecurity-Report-2023.pdf)|2023|Attacks|
|[Cisco](https://learn-cloudsecurity.cisco.com/umbrella-resources/umbrella/2022-dns-discoveries#page=1)|[DNS Discoveries](Annual%20Security%20Reports/2022/Cisco-DNS-Discoveries-2022.pdf)|2022|Attacks|
|[Cofense](https://cofense.com/annualreport)|[Annual State of Email Security](Annual%20Security%20Reports/2023/Cofense-Annual-State-of-Email-Security-Report-2023.pdf)|2023|Attacks|
|[CrowdStrike](https://www.crowdstrike.com/resources/reports/overwatch-threat-hunting-report/)|[Threat Hunting Report](Annual%20Security%20Reports/2022/Crowdstrike-Threat-Hunting-Report-2022.pdf)|2021|Attacks|
|[CrowdStrike](https://www.crowdstrike.com/resources/reports/global-threat-report/)|[Global Threat Report](Annual%20Security%20Reports/2023/Crowdstrike-Global-Threat-Report-2023.pdf)|2023|Attacks|
|[DarkTrace](https://www.darktrace.com/en/request-resources/?pp=research-cybersecurity-insiders)|[Insider Threat Report](Annual%20Security%20Reports/2020/DarkTrace-Insider-Threat-Report-2020.pdf)|2020|Attacks|
|[DeepInstinct](https://www.deepinstinct.com/blog/2022-cyber-threat-landscape-report)|[Threat Landscape Report](Deep-Instinct-Cyber-Threat-Landscape-Report-2022.pdf)|2022|Attacks|
|[Flashpoint](https://www.riskbasedsecurity.com/download-year-end-vulnerability-report/)|[Year End Vulnerability QuickView Report](RiskBasedSecurity-Year-End-Vulnerability-QuickView-Report-2021.pdf)|2021|Attacks|
|[Flashpoint](https://www.riskbasedsecurity.com/download-year-end-data-breach-report)|[Year End Data Breach QuickView Report](RiskBasedSecurity-Year-End-Data-Breach-QuickView-Report-2021.pdf)|2021|Breaches|
|[IBM](https://www.ibm.com/security/data-breach/threat-intelligence/)|[X-Force Cloud Threat Landscape Report](Annual%20Security%20Reports/2022/IBM-X-Force-Cloud-Threat-Landscape-Report-2022.pdf)|2022|Attacks|
|[IBM](https://www.ibm.com/security/data-breach/threat-intelligence/)|[X-Force Threat Intelligence Index](Annual%20Security%20Reports/2023/IBM-X-Force-Threat-Intelligence-Index-2023.pdf)|2023|Attacks|
|[IBM](https://www.ibm.com/security/data-breach)|[Cost of a Data Breach Report](Annual%20Security%20Reports/2022/IBM-Cost-of-a-Data-Breach-Report-2022.pdf)|2022|Breaches|
|[Mandiant](https://www.mandiant.com/m-trends)|[MTrends Cyber Security Insights](Annual%20Security%20Reports/2023/Mandiant-MTrends-Cybersecurity-Insights-Report-2023.pdf)|2023|Attacks|
|[Microsoft](https://www.microsoft.com/en-us/security/business/microsoft-digital-defense-report-2022)|[Digital Defense Report](Annual%20Security%20Reports/2022/Microsoft-Digital-Defense-Report-2022.pdf)|2022|Attacks|
|[NCC Group](https://research.nccgroup.com/2022/01/10/2021-annual-research-report/)|[Annual Research Report](Annual%20Security%20Reports/2021/NCCGroup-Annual-Research-Report-2021.pdf)|2021|Industry|
|[PaloAlto](https://start.paloaltonetworks.com/unit-42-iot-threat-report)|[Unit 42 IoT Threat Report](Annual%20Security%20Reports/2021/PaloAlto-Unit-42-IoT-Threat-Report-2021.pdf)|2023|Attacks|
|[PaloAlto](https://start.paloaltonetworks.com/2023-unit42-ransomware-extortion-report)|[Unit 42 Ransomware Extortion Report](Annual%20Security%20Reports/2023/PaloAlto-Unit-42-Ransomeware-Extortion-Report-2023.pdf)|2021|Attacks|
|[Proofpoint](https://www.proofpoint.com/us/resources/threat-reports/state-of-phish)|[State of the Phish](Annual%20Security%20Reports/2023/Proofpoint-State-of-the-Phish-2023.pdf)|2023|Attacks|
|[Proofpoint](https://go.proofpoint.com/Human-Factor-Report-2022-TY.html)|[Human Factor Report](Annual%20Security%20Reports/2023/Proofpoint-Human-Factor-Report-2023.pdf)|2023|Attacks|
|[Proofpoint](https://www.proofpoint.com/us/resources/threat-reports/cost-of-insider-threats)|[Cost of Insider Threats Global Report](Annual%20Security%20Reports/2022/Proofpoint-Ponemon-Cost-of-Insider-Threats-Global-Report-2022.pdf)|2022|Industry|
|[PwC](https://www.pwc.com/us/en/services/consulting/cybersecurity-risk-regulatory/library/cyber-threats-year-in-retrospect.html)|[Cyber Threat Retrospect](Annual%20Security%20Reports/2022/PwC-Cyber-Threats-Retrospect-2022.pdf)|2022|Industry|
|[Rapid7](https://www.rapid7.com/research/report/2021-industry-cyber-exposure-report/)|[Industry Cyber Exposure Report](Annual%20Security%20Reports/2021/Rapid7-Industry-Cyber-Exposure-Report-2021.pdf)|2021|Attacks|
|[RedCanary](https://redcanary.com/threat-detection-report/)|[Threat Detection Report](Annual%20Security%20Reports/2022/RedCanary-Threat-Detection-Report-2022.pdf)|2022|Attacks|
|[Secureworks](https://www.secureworks.com/resources/rp-state-of-the-threat-2022)|[State of the Threat](Annual%20Security%20Reports/2022/Secureworks-State-of-the-Threat-Report-2022.pdf)|2022|Attacks|
|[Snyk](https://go.snyk.io/IaC-Report-2021.html)|[Infrastructure as Code Report](Annual%20Security%20Reports/2021/Snyk-Infrastructure-as-Code-Report-2021.pdf)|2021|Industry|
|[SonicWall](https://www.sonicwall.com/2023-cyber-threat-report/)|[Cyber Threat Report](Annual%20Security%20Reports/2023/SonicWall-Cyber-Threat-Report-2023.pdf)|2022|Attacks|
|[Sophos](https://www.sophos.com/en-us/labs/security-threat-report)|[Threat Report](Annual%20Security%20Reports/2023/Sophos-Threat-Report-2023.pdf)|2023|Attacks|
|[Synopsys](https://www.synopsys.com/software-integrity/resources/analyst-reports/open-source-security-risk-analysis.html)|[Open Source Risk Analysis Report](Annual%20Security%20Reports/2023/Synopsys-Open-Source-Risk-Analysis-Report-2023.pdf)|2023|Attacks|
|[Synopsys](https://www.synopsys.com/software-integrity/resources/analyst-reports/software-vulnerability-trends.html)|[Software Vulnerability Snapshot](Annual%20Security%20Reports/2022/Synopsys-Software-Vulnerability-Snapshot-2022.pdf)|2022|Attacks|
|[Tenable](https://www.tenable.com/cyber-exposure/2021-threat-landscape-retrospective)|[Threat Landscape Retrospective](Annual%20Security%20Reports/2021/Tenable-Threat-Landscape-Retrospective-2021.pdf)|2021|Attacks|
|[Trellix](https://www.trellix.com/en-us/threat-center/threat-reports/jan-2022.html)|[Advanced Threat Research Report](Annual%20Security%20Reports/2022/Trelllix-Advanced-Threat-Research-Report-2022.pdf)|2022|Attacks|
|[TrendMicro](https://www.trendmicro.com/vinfo/us/security/research-and-analysis/threat-reports/roundup/attacks-from-all-angles-2021-midyear-security-roundup)|[Attacks From All Angles](Annual%20Security%20Reports/2021/TrendMicro-Attacks-From-All-Angles-2021.pdf)|2021|Attacks|
|[TrendMicro](https://www.trendmicro.com/vinfo/us/security/research-and-analysis/threat-reports/roundup/defending-the-expanding-attack-surface-trend-micro-2022-midyear-cybersecurity-report)|[Defending The Expanding Attack Surface](Annual%20Security%20Reports/2022/TrendMicro-Defending-The-Expanding-Attack-Surface-2022.pdf)|2022|Attacks|
|[Veracode](https://www.veracode.com/state-of-software-security-report)|[State of Software Security v12](Annual%20Security%20Reports/2021/Veracode-State-of-Software-Security-V12-2021.pdf)|2022|Attacks|
|[Verizon](https://www.verizon.com/business/resources/reports/cyber-espionage-report/)|[Cyber Espionage Report](Annual%20Security%20Reports/2020/Verizon-Cyber-Espionage-Report-2020.pdf)|2020|Attacks|
|[Verizon](https://www.verizon.com/business/resources/reports/dbir/)|[Data Breach Investigations Report](Annual%20Security%20Reports/2023/Verizon-Data-Breach-Investigations-Report-2023.pdf)|2023|Breaches|
|[WhiteSource](https://www.whitesourcesoftware.com/resources/research-reports/the-state-of-open-source-vulnerabilities/)|[State of Open Source Vulnerabilities](Annual%20Security%20Reports/2021/WhiteSource-State-of-Open-Source-Vulnerabilities-2021.pdf)|2021|Attacks|

### Surveys
|Provider|Report Name|Year|Data Type|
|:---|:---|:---|:---|
|[Accenture](https://www.accenture.com/us-en/insights/security/invest-cyber-resilience)|[State of Cybersecurity Report](Annual%20Security%20Reports/2021/Accenture-State-of-Cybersecurity-2021.pdf)|2021|Industry|
|[Checkmarx](https://checkmarx.com/resources/reports/2021-state-of-devsecops-report)|[State of DevSecOps Report](Annual%20Security%20Reports/2021/Checkmarx-State-of-Devsecops-Report-2021.pdf)|2021|Industry|
|[Checkmarx](https://checkmarx.com/resources/appsec-training-for-developers/global-secure-coding-education-survey)|[Global Secure Coding Education Survey](Annual%20Security%20Reports/2021/Checkmarx-Global-Secure-Coding-Education-Survey-2021.pdf)|2021|Industry|
|[Cisco](https://www.cisco.com/c/en/us/products/security/security-outcomes-study.html)|[Security Outcomes Study Volume 1](Annual%20Security%20Reports/2021/Cisco-Security-Outcomes-Study-Vol1-2021.pdf)|2021|Industry|
|[Cisco](https://www.cisco.com/c/en/us/products/security/security-outcomes-study-vol-2.html)|[Security Outcomes Study Volume 2](Annual%20Security%20Reports/2021/Cisco-Security-Outcomes-Study-Vol2-2021.pdf)|2021|Industry|
|[Cisco](https://www.cisco.com/c/en/us/products/security/security-outcomes-study-vol-3.html)|[Security Outcomes Study Volume 3](Annual%20Security%20Reports/2022/Cisco-Security-Outcomes-Study-Vol3-2022.pdf)|2022|Industry|
|[Cisco](https://www.cisco.com/c/en/us/about/trust-center/data-privacy-benchmark-study.html)|[Data Privacy Benchmark Study](Annual%20Security%20Reports/2023/Cisco-Data-Privacy-Benchmark-Study-2023.pdf)|2023|Breaches|
|[Cobalt](https://www.cobalt.io/state-of-pentesting-2022)|[State of Pentesting](Annual%20Security%20Reports/2022/Cobalt-State-of-Pentesting-2022.pdf)|2022|Industry|
|[CoreSecurity](https://www.coresecurity.com/resources/guides/2020-pen-testing-survey-report-1)|[Penetration Testing Report](Annual%20Security%20Reports/2020/CoreSecurity-Penetration-Testing-Report-2020.pdf)|2020|Industry|
|[CrowdStrike](https://www.crowdstrike.com/resources/reports/global-security-attitude-survey-2021/)|[Global Security Attitude Survey](Annual%20Security%20Reports/2021/Crowdstrike-Global-Security-Attitude-Survey-2021.pdf)|2021|Attacks|
|[Deloitte](https://www2.deloitte.com/us/en/pages/advisory/articles/future-of-cyber-survey.html)|[Future of Cyber Survey](Annual%20Security%20Reports/2021/Deloitte-Future-of-Cyber-Survey-2021.pdf)|2021|Industry|
|[Fidelis](https://fidelissecurity.com/resource/report/2022-aws-cloud-security-report/)|[AWS Cloud Security Report](Annual%20Security%20Reports/2022/Fidelis-AWS-Cloud-Security-Report-2022.pdf)|2022|Industry|
|[FireEye](https://www.fireeye.com/offers/rpt-cyber-trendscape.html)|[Cyber Trendscape Report](Annual%20Security%20Reports/2020/FireEye-Cyber-Trendscape-Report-2020.pdf)|2020|Industry|
|[Fortinet](https://www.fortinet.com/blog/industry-trends/cloud-security-2021-latest-trends-and-insights)|[Cloud Security Report](Annual%20Security%20Reports/2021/Fortinet-Cloud-Security-Report-2021.pdf)|2021|Industry|
|[Fortra](https://www.fortra.com/services/consulting/cybersecurity/penetration-testing)|[Penetration Testing Report](Annual%20Security%20Reports/2022/Fortra-Pentesting-Report-2022.pdf)|2022|Industry|
|[ISC2](https://www.isc2.org/Landing/cloud-security-report)|[Cloud Security Report](Annual%20Security%20Reports/2022/ISC2-Cloud-Security-Report-2022.pdf)|2022|Industry|
|[ISC2](https://www.isc2.org/landing/Cyberthreat-Defense-Report)|[Cyberthreat Defense Report](Annual%20Security%20Reports/2022/ISC2-Cyberthreat-Defense-Report-2022.pdf)|2022|Industry|
|[KnowBe4](https://www.knowbe4.com/organizational-cyber-security-culture-research-report)|[Cybersecurity Culture Report](Annual%20Security%20Reports/2022/KnowBe4-Cybersecurity-Culture-Report-2022.pdf)|2022|Industry|
|[Norton](https://www.nortonlifelock.com/us/en/newsroom/press-kits/2022-norton-cyber-safety-insights-report-special-release-online-creeping/)|[Cyber Safety Insights Report](Annual%20Security%20Reports/2022/Norton-Cyber-Safety-Insights-Report-2022.pdf)|2022|Industry|
|[PaloAlto](https://www.paloaltonetworks.com/state-of-cloud-native-security)|[State of Cloud Native Security Report](Annual%20Security%20Reports/2023/PaloAlto-State-of-Cloud-Native-Security-2023.pdf)|2023|Industry|
|[Proofpoint](https://go.proofpoint.com/Voice-of-the-CISO-Report.html)|[Voice of the CISO Report](Annual%20Security%20Reports/2023/Proofpoint-Voice-of-the-CISO-Report-2023.pdf)|2023|Industry|
|[PwC](https://www.pwc.com/us/en/services/consulting/cybersecurity-risk-regulatory/library/global-digital-trust-insights.html)|[Global Digital Trust Insights](Annual%20Security%20Reports/2023/PwC-Global-Digital-Trust-Insights-2023.pdf)|2023|Industry|
|[RecordedFuture](https://go.recordedfuture.com/sans-cyber-threat-intelligence-survey-2020)|[SANS Cyber Threat Intelligence Survey](Annual%20Security%20Reports/2020/RecordedFuture-SANS-Cyber-Threat-Intelligence-Survey-2020.pdf)|2020|Industry|
|[Snyk](https://go.snyk.io/2021-state-of-cnas-report)|[State of Cloud Native Application Security](Annual%20Security%20Reports/2021/Snyk-Infrastructure-as-Code-Report-2021.pdf)|2021|Industry|
|[Sonatype](https://resources.fugue.co/state-of-cloud-security-2021-report)|[The State of Cloud Security Report](Annual%20Security%20Reports/2021/Sonatype-State-of-Cloud-Security-2021.pdf)|2021|Industry|
|[Sonatype](https://www.sonatype.com/resources/state-of-the-software-supply-chain-2021)|[The State of Software Supply Chain Report](Annual%20Security%20Reports/2021/Sonatype-State%20of-the-Software-Supplychain-2021.pdf)|2021|Industry|
|[Sophos](https://secure2.sophos.com/en-us/content/state-of-cloud-security)|[State of Cloud Security Report](Annual%20Security%20Reports/2020/Sophos-State-of-Cloud-Security-2020.pdf)|2020|Industry|
|[Splunk](https://www.splunk.com/en_us/campaigns/state-of-security.html)|[State of Security](Annual%20Security%20Reports/2022/Splunk-State-of-Security-2022.pdf)|2022|Industry|
|[Synopsys](https://www.synopsys.com/software-integrity/resources/analyst-reports/devsecops-practices-open-source-management.html)|[DevSecOps Practices and Open Source Management](Annual%20Security%20Reports/2020/Synopsys-DevSecOps-Practices-and-Open-Source-Management-2020.pdf)|2020|Industry|
|[USTelecom](https://www.ustelecom.org/research/2021-cybersecurity-survey-critical-infrastructure-small-and-medium-sized-businesses/)|[Cybersecurity Survey](Annual%20Security%20Reports/2021/USTelecom-Cyber-Survey-2021.pdf)|2021|Attacks|

## Resources
Annual reports are composed by a combination of paid and non-profit research both internal and external to the organization. Examples of paid and government sponsored research are listed as research consulting. Examples of sponsored and non-profit research include professional societies and standards organizations which are listed as working groups. Both of these research resource types rely on sponsorship that’s often commercial.

### Research Consulting
- [Forrester Research](https://www.forrester.com/) is an advisory company that offers paid research, consulting, and event services specialized in market research for information technology.
- [Gartner](https://www.gartner.com/) is a technology research and consulting firm which offers private paid consulting as well as executive programs and conferences.
- [MITRE Corporation](https://www.mitre.org/) is an American not-for-profit organization which conducts research and development supporting various U.S. government agencies.
- [Ponemon Institute](https://www.ponemon.org/) is considered the pre-eminent research center dedicated to privacy, data protection and information security policy.
- [SANS Institute](https://www.sans.org/) is a private U.S. for-profit company which conducts research for consumers of their cybersecurity training and certifications.
- [(ISC)²](https://www.isc2.org/) is a non-profit organization which conducts research for consumers of their cybersecurity training and certifications.

### Working Groups
- [ISACA](https://www.isaca.org/) is an international professional association focused on IT governance, which conducts research for and on behalf of the members.
- [OWASP](https://owasp.org/) is a professional community that produces research concerning web application security, made freely available to the online community.
- [ISO](https://www.iso.org/) is an international organizational body composed of representatives which conduct closed research for creation of standards.

## Contributing
[Please refer to the guidelines at CONTRIBUTING.md for details](CONTRIBUTING.md).


text:
option('godot-cpp-lib-name', type : 'string', value : 'libgodot-cpp', description : 'GDNative C++ bindings static library name')
option('static-runtime', type : 'boolean', value : false, description : 'Link libraries statically for better portability')
option('builtin-runtime', type : 'boolean', value : true, description : 'Use the built-in libraries')
option('use-graphite2', type : 'boolean', value : true, description : 'Enable Graphite2 complementary shaper')
option('use-ubsan', type : 'boolean', value : false, description : 'Use LLVM/GCC compiler undefined behavior sanitizer')
option('use-asan', type : 'boolean', value : false, description : 'Use LLVM/GCC compiler address sanitizer')
option('use-lsan', type : 'boolean', value : false, description : 'Use LLVM/GCC compiler leak sanitizer')
option('use-tsan', type : 'boolean', value : false, description : 'Use LLVM/GCC compiler thread sanitizer')

repo_language: C

mime_type: text/x-c


text:
diff --git a/editor/SCsub b/editor/SCsub
index 67787ca49d..b679c7f9b1 100644
--- a/editor/SCsub
+++ b/editor/SCsub
@@ -78,6 +78,9 @@ if env["tools"]:
     env.Depends("#editor/builtin_fonts.gen.h", flist)
     env.CommandNoCache("#editor/builtin_fonts.gen.h", flist, run_in_subprocess(editor_builders.make_fonts_header))

+    env.Append(CXXFLAGS=["-DGODOT_MODULE"])
+    env.Append(CPPPATH=["#modules/godot_tl/src/resources", "#modules/godot_tl/src", "#modules/godot_tl/subprojects/graphite2/include", "#modules/godot_tl/subprojects/harfbuzz/src", "#modules/godot_tl/subprojects/icu4c/source/common"])
+
     env.add_source_files(env.editor_sources, "*.cpp")

     SConscript("collada/SCsub")
diff --git a/editor/editor_fonts.cpp b/editor/editor_fonts.cpp
index 39a825ea73..65470aed09 100644
--- a/editor/editor_fonts.cpp
+++ b/editor/editor_fonts.cpp
@@ -35,69 +35,31 @@
 #include "editor_scale.h"
 #include "editor_settings.h"
 #include "scene/resources/default_theme/default_theme.h"
-#include "scene/resources/dynamic_font.h"
-
-#define MAKE_FALLBACKS(m_name)          \
-	m_name->add_fallback(FontArabic);   \
-	m_name->add_fallback(FontHebrew);   \
-	m_name->add_fallback(FontThai);     \
-	m_name->add_fallback(FontHindi);    \
-	m_name->add_fallback(FontJapanese); \
-	m_name->add_fallback(FontFallback);
-
-// Enable filtering and mipmaps on the editor fonts to improve text appearance
-// in editors that are zoomed in/out without having dedicated fonts to generate.
-// This is the case in GraphEdit-based editors such as the visual script and
-// visual shader editors.
-
-// the custom spacings might only work with Noto Sans
+#include "scene/resources/theme.h"
+#include "modules/godot_tl/src/resources/tl_font_family.hpp"
+#include "modules/godot_tl/src/resources/tl_dynamic_font.hpp"
+#include "modules/godot_tl/src/resources/tl_gd_font_wrapper.hpp"
+
 #define MAKE_DEFAULT_FONT(m_name, m_size)                       \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	m_name->set_use_filter(true);                               \
-	m_name->set_use_mipmaps(true);                              \
-	if (CustomFont.is_valid()) {                                \
-		m_name->set_font_data(CustomFont);                      \
-		m_name->add_fallback(DefaultFont);                      \
-	} else {                                                    \
-		m_name->set_font_data(DefaultFont);                     \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Default");                     \
+	m_name->set_base_font_size(m_size);

 #define MAKE_BOLD_FONT(m_name, m_size)                          \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	m_name->set_use_filter(true);                               \
-	m_name->set_use_mipmaps(true);                              \
-	if (CustomFontBold.is_valid()) {                            \
-		m_name->set_font_data(CustomFontBold);                  \
-		m_name->add_fallback(DefaultFontBold);                  \
-	} else {                                                    \
-		m_name->set_font_data(DefaultFontBold);                 \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Bold");                        \
+	m_name->set_base_font_size(m_size);

 #define MAKE_SOURCE_FONT(m_name, m_size)                        \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	m_name->set_use_filter(true);                               \
-	m_name->set_use_mipmaps(true);                              \
-	if (CustomFontSource.is_valid()) {                          \
-		m_name->set_font_data(CustomFontSource);                \
-		m_name->add_fallback(dfmono);                           \
-	} else {                                                    \
-		m_name->set_font_data(dfmono);                          \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Bold");                        \
+	m_name->set_base_font_size(m_size);

 void editor_register_fonts(Ref<Theme> p_theme) {
 	DirAccess *dir = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
@@ -107,7 +69,7 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	bool font_antialiased = (bool)EditorSettings::get_singleton()->get("interface/editor/font_antialiased");
 	int font_hinting_setting = (int)EditorSettings::get_singleton()->get("interface/editor/font_hinting");

-	DynamicFontData::Hinting font_hinting;
+	DynamicFaceHinting font_hinting;
 	switch (font_hinting_setting) {
 		case 0:
 			// The "Auto" setting uses the setting that best matches the OS' font rendering:
@@ -115,27 +77,26 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 			// - Windows uses ClearType, which is in between "Light" and "Normal" hinting.
 			// - Linux has configurable font hinting, but most distributions including Ubuntu default to "Light".
 #ifdef OSX_ENABLED
-			font_hinting = DynamicFontData::HINTING_NONE;
+			font_hinting = DF_HINTING_NONE;
 #else
-			font_hinting = DynamicFontData::HINTING_LIGHT;
+			font_hinting = DF_HINTING_LIGHT;
 #endif
 			break;
 		case 1:
-			font_hinting = DynamicFontData::HINTING_NONE;
+			font_hinting = DF_HINTING_NONE;
 			break;
 		case 2:
-			font_hinting = DynamicFontData::HINTING_LIGHT;
+			font_hinting = DF_HINTING_LIGHT;
 			break;
 		default:
-			font_hinting = DynamicFontData::HINTING_NORMAL;
+			font_hinting = DF_HINTING_NORMAL;
 			break;
 	}

 	String custom_font_path = EditorSettings::get_singleton()->get("interface/editor/main_font");
-	Ref<DynamicFontData> CustomFont;
+	Ref<TLDynamicFontFace> CustomFont;
 	if (custom_font_path.length() > 0 && dir->file_exists(custom_font_path)) {
 		CustomFont.instance();
-		CustomFont->set_antialiased(font_antialiased);
 		CustomFont->set_hinting(font_hinting);
 		CustomFont->set_font_path(custom_font_path);
 		CustomFont->set_force_autohinter(true); //just looks better..i think?
@@ -146,10 +107,9 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	/* Custom Bold font */

 	String custom_font_path_bold = EditorSettings::get_singleton()->get("interface/editor/main_font_bold");
-	Ref<DynamicFontData> CustomFontBold;
+	Ref<TLDynamicFontFace> CustomFontBold;
 	if (custom_font_path_bold.length() > 0 && dir->file_exists(custom_font_path_bold)) {
 		CustomFontBold.instance();
-		CustomFontBold->set_antialiased(font_antialiased);
 		CustomFontBold->set_hinting(font_hinting);
 		CustomFontBold->set_font_path(custom_font_path_bold);
 		CustomFontBold->set_force_autohinter(true); //just looks better..i think?
@@ -160,10 +120,9 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	/* Custom source code font */

 	String custom_font_path_source = EditorSettings::get_singleton()->get("interface/editor/code_font");
-	Ref<DynamicFontData> CustomFontSource;
+	Ref<TLDynamicFontFace> CustomFontSource;
 	if (custom_font_path_source.length() > 0 && dir->file_exists(custom_font_path_source)) {
 		CustomFontSource.instance();
-		CustomFontSource->set_antialiased(font_antialiased);
 		CustomFontSource->set_hinting(font_hinting);
 		CustomFontSource->set_font_path(custom_font_path_source);
 	} else {
@@ -174,72 +133,104 @@ void editor_register_fonts(Ref<Theme> p_theme) {

 	/* Droid Sans */

-	Ref<DynamicFontData> DefaultFont;
+	Ref<TLDynamicFontFace> DefaultFont;
 	DefaultFont.instance();
-	DefaultFont->set_antialiased(font_antialiased);
 	DefaultFont->set_hinting(font_hinting);
 	DefaultFont->set_font_ptr(_font_NotoSansUI_Regular, _font_NotoSansUI_Regular_size);
 	DefaultFont->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> DefaultFontBold;
+	Ref<TLDynamicFontFace> DefaultFontBold;
 	DefaultFontBold.instance();
-	DefaultFontBold->set_antialiased(font_antialiased);
 	DefaultFontBold->set_hinting(font_hinting);
 	DefaultFontBold->set_font_ptr(_font_NotoSansUI_Bold, _font_NotoSansUI_Bold_size);
 	DefaultFontBold->set_force_autohinter(true); // just looks better..i think?

-	Ref<DynamicFontData> FontFallback;
+	Ref<TLDynamicFontFace> FontFallback;
 	FontFallback.instance();
-	FontFallback->set_antialiased(font_antialiased);
 	FontFallback->set_hinting(font_hinting);
 	FontFallback->set_font_ptr(_font_DroidSansFallback, _font_DroidSansFallback_size);
 	FontFallback->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontJapanese;
+	Ref<TLDynamicFontFace> FontJapanese;
 	FontJapanese.instance();
-	FontJapanese->set_antialiased(font_antialiased);
 	FontJapanese->set_hinting(font_hinting);
 	FontJapanese->set_font_ptr(_font_DroidSansJapanese, _font_DroidSansJapanese_size);
 	FontJapanese->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontArabic;
+	Ref<TLDynamicFontFace> FontArabic;
 	FontArabic.instance();
-	FontArabic->set_antialiased(font_antialiased);
 	FontArabic->set_hinting(font_hinting);
 	FontArabic->set_font_ptr(_font_NotoNaskhArabicUI_Regular, _font_NotoNaskhArabicUI_Regular_size);
 	FontArabic->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontHebrew;
+	Ref<TLDynamicFontFace> FontHebrew;
 	FontHebrew.instance();
-	FontHebrew->set_antialiased(font_antialiased);
 	FontHebrew->set_hinting(font_hinting);
 	FontHebrew->set_font_ptr(_font_NotoSansHebrew_Regular, _font_NotoSansHebrew_Regular_size);
 	FontHebrew->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontThai;
+	Ref<TLDynamicFontFace> FontThai;
 	FontThai.instance();
-	FontThai->set_antialiased(font_antialiased);
 	FontThai->set_hinting(font_hinting);
 	FontThai->set_font_ptr(_font_NotoSansThaiUI_Regular, _font_NotoSansThaiUI_Regular_size);
 	FontThai->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontHindi;
+	Ref<TLDynamicFontFace> FontHindi;
 	FontHindi.instance();
-	FontHindi->set_antialiased(font_antialiased);
 	FontHindi->set_hinting(font_hinting);
 	FontHindi->set_font_ptr(_font_NotoSansDevanagariUI_Regular, _font_NotoSansDevanagariUI_Regular_size);
 	FontHindi->set_force_autohinter(true); //just looks better..i think?

 	/* Hack */

-	Ref<DynamicFontData> dfmono;
+	Ref<TLDynamicFontFace> dfmono;
 	dfmono.instance();
-	dfmono->set_antialiased(font_antialiased);
 	dfmono->set_hinting(font_hinting);
 	dfmono->set_font_ptr(_font_Hack_Regular, _font_Hack_Regular_size);

 	int default_font_size = int(EDITOR_GET("interface/editor/main_font_size")) * EDSCALE;

+	Ref<TLFontFamily> dff;
+	dff.instance();
+	dff->add_style("Default");
+	dff->add_style("Bold");
+	dff->add_style("Source");
+	if (CustomFont.is_valid()) {
+		dff->add_face("Default", CustomFont);
+	}
+	dff->add_face("Default", DefaultFont);
+	dff->add_face("Default", FontArabic);
+	dff->add_face("Default", FontHebrew);
+	dff->add_face("Default", FontThai);
+	dff->add_face("Default", FontHindi);
+	dff->add_face("Default", FontJapanese);
+	dff->add_face("Default", FontFallback);
+
+	if (CustomFontBold.is_valid()) {
+		dff->add_face("Bold", CustomFontBold);
+	}
+	dff->add_face("Bold", DefaultFontBold);
+	dff->add_face("Bold", DefaultFont);
+	dff->add_face("Bold", FontArabic);
+	dff->add_face("Bold", FontHebrew);
+	dff->add_face("Bold", FontThai);
+	dff->add_face("Bold", FontHindi);
+	dff->add_face("Bold", FontJapanese);
+	dff->add_face("Bold", FontFallback);
+
+	if (CustomFontSource.is_valid()) {
+		dff->add_face("Source", CustomFontSource);
+	}
+	dff->add_face("Source", dfmono);
+	dff->add_face("Source", DefaultFontBold);
+	dff->add_face("Source", DefaultFont);
+	dff->add_face("Source", FontArabic);
+	dff->add_face("Source", FontHebrew);
+	dff->add_face("Source", FontThai);
+	dff->add_face("Source", FontHindi);
+	dff->add_face("Source", FontJapanese);
+	dff->add_face("Source", FontFallback);
+
 	// Default font
 	MAKE_DEFAULT_FONT(df, default_font_size);
 	p_theme->set_default_theme_font(df);
diff --git a/editor/editor_settings.cpp b/editor/editor_settings.cpp
index 6fed5737de..4e90fc27ca 100644
--- a/editor/editor_settings.cpp
+++ b/editor/editor_settings.cpp
@@ -264,7 +264,7 @@ void EditorSettings::_load_defaults(Ref<ConfigFile> p_extra_config) {
 		// Some locales are not properly supported currently in Godot due to lack of font shaping
 		// (e.g. Arabic or Hindi), so even though we have work in progress translations for them,
 		// we skip them as they don't render properly. (GH-28577)
-		const Vector<String> locales_to_skip = String("ar,bn,fa,he,hi,ml,si,ta,te,ur").split(",");
+		//const Vector<String> locales_to_skip = String("ar,bn,fa,he,hi,ml,si,ta,te,ur").split(",");

 		String best;

@@ -276,10 +276,10 @@ void EditorSettings::_load_defaults(Ref<ConfigFile> p_extra_config) {
 			// Skip locales which we can't render properly (see above comment).
 			// Test against language code without regional variants (e.g. ur_PK).
 			String lang_code = locale.get_slice("_", 0);
-			if (locales_to_skip.find(lang_code) != -1) {
-				etl++;
-				continue;
-			}
+			//if (locales_to_skip.find(lang_code) != -1) {
+			//	etl++;
+			//	continue;
+			//}

 			lang_hint += ",";
 			lang_hint += locale;


text:
diff --git a/editor/SCsub b/editor/SCsub
index 2b560f68e8..0481837354 100644
--- a/editor/SCsub
+++ b/editor/SCsub
@@ -78,6 +78,8 @@ if env['tools']:
     env.Depends('#editor/builtin_fonts.gen.h', flist)
     env.CommandNoCache('#editor/builtin_fonts.gen.h', flist, run_in_subprocess(editor_builders.make_fonts_header))

+    env.Append(CXXFLAGS=['-DGODOT_MODULE'])
+    env.Append(CPPPATH=['#modules/godot_tl/src/resources', '#modules/godot_tl/src', '#modules/godot_tl/subprojects/graphite2/include', '#modules/godot_tl/subprojects/harfbuzz/src', '#modules/godot_tl/subprojects/icu4c/source/common'])
     env.add_source_files(env.editor_sources, "*.cpp")

     SConscript('collada/SCsub')
diff --git a/editor/editor_fonts.cpp b/editor/editor_fonts.cpp
index 171b7a2176..a5f3a9700e 100644
--- a/editor/editor_fonts.cpp
+++ b/editor/editor_fonts.cpp
@@ -35,58 +35,31 @@
 #include "editor_scale.h"
 #include "editor_settings.h"
 #include "scene/resources/default_theme/default_theme.h"
-#include "scene/resources/dynamic_font.h"
+#include "scene/resources/theme.h"
+#include "modules/godot_tl/src/resources/tl_font_family.hpp"
+#include "modules/godot_tl/src/resources/tl_dynamic_font.hpp"
+#include "modules/godot_tl/src/resources/tl_gd_font_wrapper.hpp"

-#define MAKE_FALLBACKS(m_name)          \
-	m_name->add_fallback(FontArabic);   \
-	m_name->add_fallback(FontHebrew);   \
-	m_name->add_fallback(FontThai);     \
-	m_name->add_fallback(FontHindi);    \
-	m_name->add_fallback(FontJapanese); \
-	m_name->add_fallback(FontFallback);
-
-// the custom spacings might only work with Noto Sans
 #define MAKE_DEFAULT_FONT(m_name, m_size)                       \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	if (CustomFont.is_valid()) {                                \
-		m_name->set_font_data(CustomFont);                      \
-		m_name->add_fallback(DefaultFont);                      \
-	} else {                                                    \
-		m_name->set_font_data(DefaultFont);                     \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Default");                     \
+	m_name->set_base_font_size(m_size);                         \

 #define MAKE_BOLD_FONT(m_name, m_size)                          \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	if (CustomFontBold.is_valid()) {                            \
-		m_name->set_font_data(CustomFontBold);                  \
-		m_name->add_fallback(DefaultFontBold);                  \
-	} else {                                                    \
-		m_name->set_font_data(DefaultFontBold);                 \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Bold");                        \
+	m_name->set_base_font_size(m_size);                         \

 #define MAKE_SOURCE_FONT(m_name, m_size)                        \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	if (CustomFontSource.is_valid()) {                          \
-		m_name->set_font_data(CustomFontSource);                \
-		m_name->add_fallback(dfmono);                           \
-	} else {                                                    \
-		m_name->set_font_data(dfmono);                          \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Bold");                        \
+	m_name->set_base_font_size(m_size);                         \

 void editor_register_fonts(Ref<Theme> p_theme) {
 	DirAccess *dir = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
@@ -96,7 +69,7 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	bool font_antialiased = (bool)EditorSettings::get_singleton()->get("interface/editor/font_antialiased");
 	int font_hinting_setting = (int)EditorSettings::get_singleton()->get("interface/editor/font_hinting");

-	DynamicFontData::Hinting font_hinting;
+	DynamicFaceHinting font_hinting;
 	switch (font_hinting_setting) {
 		case 0:
 			// The "Auto" setting uses the setting that best matches the OS' font rendering:
@@ -104,27 +77,26 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 			// - Windows uses ClearType, which is in between "Light" and "Normal" hinting.
 			// - Linux has configurable font hinting, but most distributions including Ubuntu default to "Light".
 #ifdef OSX_ENABLED
-			font_hinting = DynamicFontData::HINTING_NONE;
+			font_hinting = DF_HINTING_NONE;
 #else
-			font_hinting = DynamicFontData::HINTING_LIGHT;
+			font_hinting = DF_HINTING_LIGHT;
 #endif
 			break;
 		case 1:
-			font_hinting = DynamicFontData::HINTING_NONE;
+			font_hinting = DF_HINTING_NONE;
 			break;
 		case 2:
-			font_hinting = DynamicFontData::HINTING_LIGHT;
+			font_hinting = DF_HINTING_LIGHT;
 			break;
 		default:
-			font_hinting = DynamicFontData::HINTING_NORMAL;
+			font_hinting = DF_HINTING_NORMAL;
 			break;
 	}

 	String custom_font_path = EditorSettings::get_singleton()->get("interface/editor/main_font");
-	Ref<DynamicFontData> CustomFont;
+	Ref<TLDynamicFontFace> CustomFont;
 	if (custom_font_path.length() > 0 && dir->file_exists(custom_font_path)) {
 		CustomFont.instance();
-		CustomFont->set_antialiased(font_antialiased);
 		CustomFont->set_hinting(font_hinting);
 		CustomFont->set_font_path(custom_font_path);
 		CustomFont->set_force_autohinter(true); //just looks better..i think?
@@ -135,10 +107,9 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	/* Custom Bold font */

 	String custom_font_path_bold = EditorSettings::get_singleton()->get("interface/editor/main_font_bold");
-	Ref<DynamicFontData> CustomFontBold;
+	Ref<TLDynamicFontFace> CustomFontBold;
 	if (custom_font_path_bold.length() > 0 && dir->file_exists(custom_font_path_bold)) {
 		CustomFontBold.instance();
-		CustomFontBold->set_antialiased(font_antialiased);
 		CustomFontBold->set_hinting(font_hinting);
 		CustomFontBold->set_font_path(custom_font_path_bold);
 		CustomFontBold->set_force_autohinter(true); //just looks better..i think?
@@ -149,10 +120,9 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	/* Custom source code font */

 	String custom_font_path_source = EditorSettings::get_singleton()->get("interface/editor/code_font");
-	Ref<DynamicFontData> CustomFontSource;
+	Ref<TLDynamicFontFace> CustomFontSource;
 	if (custom_font_path_source.length() > 0 && dir->file_exists(custom_font_path_source)) {
 		CustomFontSource.instance();
-		CustomFontSource->set_antialiased(font_antialiased);
 		CustomFontSource->set_hinting(font_hinting);
 		CustomFontSource->set_font_path(custom_font_path_source);
 	} else {
@@ -163,72 +133,104 @@ void editor_register_fonts(Ref<Theme> p_theme) {

 	/* Droid Sans */

-	Ref<DynamicFontData> DefaultFont;
+	Ref<TLDynamicFontFace> DefaultFont;
 	DefaultFont.instance();
-	DefaultFont->set_antialiased(font_antialiased);
 	DefaultFont->set_hinting(font_hinting);
 	DefaultFont->set_font_ptr(_font_NotoSansUI_Regular, _font_NotoSansUI_Regular_size);
 	DefaultFont->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> DefaultFontBold;
+	Ref<TLDynamicFontFace> DefaultFontBold;
 	DefaultFontBold.instance();
-	DefaultFontBold->set_antialiased(font_antialiased);
 	DefaultFontBold->set_hinting(font_hinting);
 	DefaultFontBold->set_font_ptr(_font_NotoSansUI_Bold, _font_NotoSansUI_Bold_size);
 	DefaultFontBold->set_force_autohinter(true); // just looks better..i think?

-	Ref<DynamicFontData> FontFallback;
+	Ref<TLDynamicFontFace> FontFallback;
 	FontFallback.instance();
-	FontFallback->set_antialiased(font_antialiased);
 	FontFallback->set_hinting(font_hinting);
 	FontFallback->set_font_ptr(_font_DroidSansFallback, _font_DroidSansFallback_size);
 	FontFallback->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontJapanese;
+	Ref<TLDynamicFontFace> FontJapanese;
 	FontJapanese.instance();
-	FontJapanese->set_antialiased(font_antialiased);
 	FontJapanese->set_hinting(font_hinting);
 	FontJapanese->set_font_ptr(_font_DroidSansJapanese, _font_DroidSansJapanese_size);
 	FontJapanese->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontArabic;
+	Ref<TLDynamicFontFace> FontArabic;
 	FontArabic.instance();
-	FontArabic->set_antialiased(font_antialiased);
 	FontArabic->set_hinting(font_hinting);
 	FontArabic->set_font_ptr(_font_NotoNaskhArabicUI_Regular, _font_NotoNaskhArabicUI_Regular_size);
 	FontArabic->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontHebrew;
+	Ref<TLDynamicFontFace> FontHebrew;
 	FontHebrew.instance();
-	FontHebrew->set_antialiased(font_antialiased);
 	FontHebrew->set_hinting(font_hinting);
 	FontHebrew->set_font_ptr(_font_NotoSansHebrew_Regular, _font_NotoSansHebrew_Regular_size);
 	FontHebrew->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontThai;
+	Ref<TLDynamicFontFace> FontThai;
 	FontThai.instance();
-	FontThai->set_antialiased(font_antialiased);
 	FontThai->set_hinting(font_hinting);
 	FontThai->set_font_ptr(_font_NotoSansThaiUI_Regular, _font_NotoSansThaiUI_Regular_size);
 	FontThai->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontHindi;
+	Ref<TLDynamicFontFace> FontHindi;
 	FontHindi.instance();
-	FontHindi->set_antialiased(font_antialiased);
 	FontHindi->set_hinting(font_hinting);
 	FontHindi->set_font_ptr(_font_NotoSansDevanagariUI_Regular, _font_NotoSansDevanagariUI_Regular_size);
 	FontHindi->set_force_autohinter(true); //just looks better..i think?

 	/* Hack */

-	Ref<DynamicFontData> dfmono;
+	Ref<TLDynamicFontFace> dfmono;
 	dfmono.instance();
-	dfmono->set_antialiased(font_antialiased);
 	dfmono->set_hinting(font_hinting);
 	dfmono->set_font_ptr(_font_Hack_Regular, _font_Hack_Regular_size);

 	int default_font_size = int(EDITOR_GET("interface/editor/main_font_size")) * EDSCALE;

+	Ref<TLFontFamily> dff;
+	dff.instance();
+	dff->add_style("Default");
+	dff->add_style("Bold");
+	dff->add_style("Source");
+	if (CustomFont.is_valid()) {
+		dff->add_face("Default", CustomFont);
+	}
+	dff->add_face("Default", DefaultFont);
+	dff->add_face("Default", FontArabic);
+	dff->add_face("Default", FontHebrew);
+	dff->add_face("Default", FontThai);
+	dff->add_face("Default", FontHindi);
+	dff->add_face("Default", FontJapanese);
+	dff->add_face("Default", FontFallback);
+
+	if (CustomFontBold.is_valid()) {
+		dff->add_face("Bold", CustomFontBold);
+	}
+	dff->add_face("Bold", DefaultFontBold);
+	dff->add_face("Bold", DefaultFont);
+	dff->add_face("Bold", FontArabic);
+	dff->add_face("Bold", FontHebrew);
+	dff->add_face("Bold", FontThai);
+	dff->add_face("Bold", FontHindi);
+	dff->add_face("Bold", FontJapanese);
+	dff->add_face("Bold", FontFallback);
+
+	if (CustomFontSource.is_valid()) {
+		dff->add_face("Source", CustomFontSource);
+	}
+	dff->add_face("Source", dfmono);
+	dff->add_face("Source", DefaultFontBold);
+	dff->add_face("Source", DefaultFont);
+	dff->add_face("Source", FontArabic);
+	dff->add_face("Source", FontHebrew);
+	dff->add_face("Source", FontThai);
+	dff->add_face("Source", FontHindi);
+	dff->add_face("Source", FontJapanese);
+	dff->add_face("Source", FontFallback);
+
 	// Default font
 	MAKE_DEFAULT_FONT(df, default_font_size);
 	p_theme->set_default_theme_font(df);
diff --git a/editor/editor_settings.cpp b/editor/editor_settings.cpp
index 92e3f61ca5..98fc6d5742 100644
--- a/editor/editor_settings.cpp
+++ b/editor/editor_settings.cpp
@@ -272,7 +272,7 @@ void EditorSettings::_load_defaults(Ref<ConfigFile> p_extra_config) {
 		// Some locales are not properly supported currently in Godot due to lack of font shaping
 		// (e.g. Arabic or Hindi), so even though we have work in progress translations for them,
 		// we skip them as they don't render properly. (GH-28577)
-		const Vector<String> locales_to_skip = String("ar,bn,fa,he,hi,ml,si,ta,te,ur").split(",");
+		//const Vector<String> locales_to_skip = String("ar,bn,fa,he,hi,ml,si,ta,te,ur").split(",");

 		String best;

@@ -285,10 +285,10 @@ void EditorSettings::_load_defaults(Ref<ConfigFile> p_extra_config) {
 			// Skip locales which we can't render properly (see above comment).
 			// Test against language code without regional variants (e.g. ur_PK).
 			String lang_code = locale.get_slice("_", 0);
-			if (locales_to_skip.find(lang_code) != -1) {
-				etl++;
-				continue;
-			}
+			//if (locales_to_skip.find(lang_code) != -1) {
+			//	etl++;
+			//	continue;
+			//}

 			lang_hint += ",";
 			lang_hint += locale;


text:
diff --git a/SConstruct b/SConstruct
index 1f06a0a..a91a5b5 100644
--- a/SConstruct
+++ b/SConstruct
@@ -212,13 +212,6 @@ if env['platform'] == 'linux' or env['platform'] == 'freebsd':
     elif env['target'] == 'release':
         env.Append(CCFLAGS=['-O3'])

-    if env['bits'] == '64':
-        env.Append(CCFLAGS=['-m64'])
-        env.Append(LINKFLAGS=['-m64'])
-    elif env['bits'] == '32':
-        env.Append(CCFLAGS=['-m32'])
-        env.Append(LINKFLAGS=['-m32'])
-
 elif env['platform'] == 'osx':
     # Use Clang on macOS by default
     env['CXX'] = 'clang++'


text:
diff --git a/scene/gui/line_edit.cpp b/scene/gui/line_edit.cpp
index 7cc47d351e..2156edb911 100644
--- a/scene/gui/line_edit.cpp
+++ b/scene/gui/line_edit.cpp
@@ -28,6 +28,8 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/

+#if 0
+
 #include "line_edit.h"

 #include "core/message_queue.h"
@@ -1878,3 +1880,5 @@ LineEdit::LineEdit() {

 LineEdit::~LineEdit() {
 }
+
+#endif
diff --git a/scene/gui/line_edit.h b/scene/gui/line_edit.h
index 037238d682..961411b5ec 100644
--- a/scene/gui/line_edit.h
+++ b/scene/gui/line_edit.h
@@ -31,6 +31,31 @@
 #ifndef LINE_EDIT_H
 #define LINE_EDIT_H

+#include "modules/godot_tl/src/controls/tl_line_edit.hpp"
+#include "modules/godot_tl/src/resources/tl_gd_font_wrapper.hpp"
+
+class LineEdit : public TLLineEdit {
+	GDCLASS(LineEdit, TLLineEdit);
+public:
+	void _notification(int p_what) {
+		if ((p_what == NOTIFICATION_THEME_CHANGED) || (p_what == NOTIFICATION_POST_ENTER_TREE)) {
+			Ref<Font> font_w = get_font("font");
+			TLGDFontWrapper *fw_ref = cast_to<TLGDFontWrapper>(*font_w);
+			if (fw_ref) {
+				set_base_font(fw_ref->get_base_font());
+				set_base_font_style(fw_ref->get_base_font_style());
+				set_base_font_size(fw_ref->get_base_font_size());
+			}
+		}
+	}
+
+	LineEdit() {
+		_init();
+	}
+};
+
+#if 0
+
 #include "scene/gui/control.h"
 #include "scene/gui/popup_menu.h"

@@ -244,3 +269,5 @@ VARIANT_ENUM_CAST(LineEdit::Align);
 VARIANT_ENUM_CAST(LineEdit::MenuItems);

 #endif
+
+#endif
diff --git a/scene/gui/spin_box.cpp b/scene/gui/spin_box.cpp
index 92377949f8..93cc621dfa 100644
--- a/scene/gui/spin_box.cpp
+++ b/scene/gui/spin_box.cpp
@@ -218,12 +218,12 @@ void SpinBox::_notification(int p_what) {
 	}
 }

-void SpinBox::set_align(LineEdit::Align p_align) {
+void SpinBox::set_align(int p_align) {

 	line_edit->set_align(p_align);
 }

-LineEdit::Align SpinBox::get_align() const {
+int SpinBox::get_align() const {

 	return line_edit->get_align();
 }
diff --git a/scene/gui/spin_box.h b/scene/gui/spin_box.h
index 04491c8477..5ba31ece9f 100644
--- a/scene/gui/spin_box.h
+++ b/scene/gui/spin_box.h
@@ -76,8 +76,8 @@ public:

 	virtual Size2 get_minimum_size() const;

-	void set_align(LineEdit::Align p_align);
-	LineEdit::Align get_align() const;
+	void set_align(int p_align);
+	int get_align() const;

 	void set_editable(bool p_editable);
 	bool is_editable() const;


text:
diff --git a/editor/SCsub b/editor/SCsub
index 2b560f68e8..0481837354 100644
--- a/editor/SCsub
+++ b/editor/SCsub
@@ -78,5 +78,7 @@
     env.Depends("#editor/builtin_fonts.gen.h", flist)
     env.CommandNoCache("#editor/builtin_fonts.gen.h", flist, run_in_subprocess(editor_builders.make_fonts_header))

+    env.Append(CXXFLAGS=["-DGODOT_MODULE"])
+    env.Append(CPPPATH=["#modules/godot_tl/src/resources", "#modules/godot_tl/src", "#modules/godot_tl/subprojects/graphite2/include", "#modules/godot_tl/subprojects/harfbuzz/src", "#modules/godot_tl/subprojects/icu4c/source/common"])
     env.add_source_files(env.editor_sources, "*.cpp")

     SConscript('collada/SCsub')
diff --git a/editor/editor_fonts.cpp b/editor/editor_fonts.cpp
index 171b7a2176..a5f3a9700e 100644
--- a/editor/editor_fonts.cpp
+++ b/editor/editor_fonts.cpp
@@ -35,58 +35,31 @@
 #include "editor_scale.h"
 #include "editor_settings.h"
 #include "scene/resources/default_theme/default_theme.h"
-#include "scene/resources/dynamic_font.h"
+#include "scene/resources/theme.h"
+#include "modules/godot_tl/src/resources/tl_font_family.hpp"
+#include "modules/godot_tl/src/resources/tl_dynamic_font.hpp"
+#include "modules/godot_tl/src/resources/tl_gd_font_wrapper.hpp"

-#define MAKE_FALLBACKS(m_name)          \
-	m_name->add_fallback(FontArabic);   \
-	m_name->add_fallback(FontHebrew);   \
-	m_name->add_fallback(FontThai);     \
-	m_name->add_fallback(FontHindi);    \
-	m_name->add_fallback(FontJapanese); \
-	m_name->add_fallback(FontFallback);
-
-// the custom spacings might only work with Noto Sans
 #define MAKE_DEFAULT_FONT(m_name, m_size)                       \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	if (CustomFont.is_valid()) {                                \
-		m_name->set_font_data(CustomFont);                      \
-		m_name->add_fallback(DefaultFont);                      \
-	} else {                                                    \
-		m_name->set_font_data(DefaultFont);                     \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Default");                     \
+	m_name->set_base_font_size(m_size);                         \

 #define MAKE_BOLD_FONT(m_name, m_size)                          \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	if (CustomFontBold.is_valid()) {                            \
-		m_name->set_font_data(CustomFontBold);                  \
-		m_name->add_fallback(DefaultFontBold);                  \
-	} else {                                                    \
-		m_name->set_font_data(DefaultFontBold);                 \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Bold");                        \
+	m_name->set_base_font_size(m_size);                         \

 #define MAKE_SOURCE_FONT(m_name, m_size)                        \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	if (CustomFontSource.is_valid()) {                          \
-		m_name->set_font_data(CustomFontSource);                \
-		m_name->add_fallback(dfmono);                           \
-	} else {                                                    \
-		m_name->set_font_data(dfmono);                          \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Bold");                        \
+	m_name->set_base_font_size(m_size);                         \

 void editor_register_fonts(Ref<Theme> p_theme) {
 	DirAccess *dir = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
@@ -96,7 +69,7 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	bool font_antialiased = (bool)EditorSettings::get_singleton()->get("interface/editor/font_antialiased");
 	int font_hinting_setting = (int)EditorSettings::get_singleton()->get("interface/editor/font_hinting");

-	DynamicFontData::Hinting font_hinting;
+	DynamicFaceHinting font_hinting;
 	switch (font_hinting_setting) {
 		case 0:
 			// The "Auto" setting uses the setting that best matches the OS' font rendering:
@@ -104,27 +77,26 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 			// - Windows uses ClearType, which is in between "Light" and "Normal" hinting.
 			// - Linux has configurable font hinting, but most distributions including Ubuntu default to "Light".
 #ifdef OSX_ENABLED
-			font_hinting = DynamicFontData::HINTING_NONE;
+			font_hinting = DF_HINTING_NONE;
 #else
-			font_hinting = DynamicFontData::HINTING_LIGHT;
+			font_hinting = DF_HINTING_LIGHT;
 #endif
 			break;
 		case 1:
-			font_hinting = DynamicFontData::HINTING_NONE;
+			font_hinting = DF_HINTING_NONE;
 			break;
 		case 2:
-			font_hinting = DynamicFontData::HINTING_LIGHT;
+			font_hinting = DF_HINTING_LIGHT;
 			break;
 		default:
-			font_hinting = DynamicFontData::HINTING_NORMAL;
+			font_hinting = DF_HINTING_NORMAL;
 			break;
 	}

 	String custom_font_path = EditorSettings::get_singleton()->get("interface/editor/main_font");
-	Ref<DynamicFontData> CustomFont;
+	Ref<TLDynamicFontFace> CustomFont;
 	if (custom_font_path.length() > 0 && dir->file_exists(custom_font_path)) {
 		CustomFont.instance();
-		CustomFont->set_antialiased(font_antialiased);
 		CustomFont->set_hinting(font_hinting);
 		CustomFont->set_font_path(custom_font_path);
 		CustomFont->set_force_autohinter(true); //just looks better..i think?
@@ -135,10 +107,9 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	/* Custom Bold font */

 	String custom_font_path_bold = EditorSettings::get_singleton()->get("interface/editor/main_font_bold");
-	Ref<DynamicFontData> CustomFontBold;
+	Ref<TLDynamicFontFace> CustomFontBold;
 	if (custom_font_path_bold.length() > 0 && dir->file_exists(custom_font_path_bold)) {
 		CustomFontBold.instance();
-		CustomFontBold->set_antialiased(font_antialiased);
 		CustomFontBold->set_hinting(font_hinting);
 		CustomFontBold->set_font_path(custom_font_path_bold);
 		CustomFontBold->set_force_autohinter(true); //just looks better..i think?
@@ -149,10 +120,9 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	/* Custom source code font */

 	String custom_font_path_source = EditorSettings::get_singleton()->get("interface/editor/code_font");
-	Ref<DynamicFontData> CustomFontSource;
+	Ref<TLDynamicFontFace> CustomFontSource;
 	if (custom_font_path_source.length() > 0 && dir->file_exists(custom_font_path_source)) {
 		CustomFontSource.instance();
-		CustomFontSource->set_antialiased(font_antialiased);
 		CustomFontSource->set_hinting(font_hinting);
 		CustomFontSource->set_font_path(custom_font_path_source);
 	} else {
@@ -163,72 +133,104 @@ void editor_register_fonts(Ref<Theme> p_theme) {

 	/* Droid Sans */

-	Ref<DynamicFontData> DefaultFont;
+	Ref<TLDynamicFontFace> DefaultFont;
 	DefaultFont.instance();
-	DefaultFont->set_antialiased(font_antialiased);
 	DefaultFont->set_hinting(font_hinting);
 	DefaultFont->set_font_ptr(_font_NotoSansUI_Regular, _font_NotoSansUI_Regular_size);
 	DefaultFont->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> DefaultFontBold;
+	Ref<TLDynamicFontFace> DefaultFontBold;
 	DefaultFontBold.instance();
-	DefaultFontBold->set_antialiased(font_antialiased);
 	DefaultFontBold->set_hinting(font_hinting);
 	DefaultFontBold->set_font_ptr(_font_NotoSansUI_Bold, _font_NotoSansUI_Bold_size);
 	DefaultFontBold->set_force_autohinter(true); // just looks better..i think?

-	Ref<DynamicFontData> FontFallback;
+	Ref<TLDynamicFontFace> FontFallback;
 	FontFallback.instance();
-	FontFallback->set_antialiased(font_antialiased);
 	FontFallback->set_hinting(font_hinting);
 	FontFallback->set_font_ptr(_font_DroidSansFallback, _font_DroidSansFallback_size);
 	FontFallback->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontJapanese;
+	Ref<TLDynamicFontFace> FontJapanese;
 	FontJapanese.instance();
-	FontJapanese->set_antialiased(font_antialiased);
 	FontJapanese->set_hinting(font_hinting);
 	FontJapanese->set_font_ptr(_font_DroidSansJapanese, _font_DroidSansJapanese_size);
 	FontJapanese->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontArabic;
+	Ref<TLDynamicFontFace> FontArabic;
 	FontArabic.instance();
-	FontArabic->set_antialiased(font_antialiased);
 	FontArabic->set_hinting(font_hinting);
 	FontArabic->set_font_ptr(_font_NotoNaskhArabicUI_Regular, _font_NotoNaskhArabicUI_Regular_size);
 	FontArabic->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontHebrew;
+	Ref<TLDynamicFontFace> FontHebrew;
 	FontHebrew.instance();
-	FontHebrew->set_antialiased(font_antialiased);
 	FontHebrew->set_hinting(font_hinting);
 	FontHebrew->set_font_ptr(_font_NotoSansHebrew_Regular, _font_NotoSansHebrew_Regular_size);
 	FontHebrew->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontThai;
+	Ref<TLDynamicFontFace> FontThai;
 	FontThai.instance();
-	FontThai->set_antialiased(font_antialiased);
 	FontThai->set_hinting(font_hinting);
 	FontThai->set_font_ptr(_font_NotoSansThaiUI_Regular, _font_NotoSansThaiUI_Regular_size);
 	FontThai->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontHindi;
+	Ref<TLDynamicFontFace> FontHindi;
 	FontHindi.instance();
-	FontHindi->set_antialiased(font_antialiased);
 	FontHindi->set_hinting(font_hinting);
 	FontHindi->set_font_ptr(_font_NotoSansDevanagariUI_Regular, _font_NotoSansDevanagariUI_Regular_size);
 	FontHindi->set_force_autohinter(true); //just looks better..i think?

 	/* Hack */

-	Ref<DynamicFontData> dfmono;
+	Ref<TLDynamicFontFace> dfmono;
 	dfmono.instance();
-	dfmono->set_antialiased(font_antialiased);
 	dfmono->set_hinting(font_hinting);
 	dfmono->set_font_ptr(_font_Hack_Regular, _font_Hack_Regular_size);

 	int default_font_size = int(EDITOR_GET("interface/editor/main_font_size")) * EDSCALE;

+	Ref<TLFontFamily> dff;
+	dff.instance();
+	dff->add_style("Default");
+	dff->add_style("Bold");
+	dff->add_style("Source");
+	if (CustomFont.is_valid()) {
+		dff->add_face("Default", CustomFont);
+	}
+	dff->add_face("Default", DefaultFont);
+	dff->add_face("Default", FontArabic);
+	dff->add_face("Default", FontHebrew);
+	dff->add_face("Default", FontThai);
+	dff->add_face("Default", FontHindi);
+	dff->add_face("Default", FontJapanese);
+	dff->add_face("Default", FontFallback);
+
+	if (CustomFontBold.is_valid()) {
+		dff->add_face("Bold", CustomFontBold);
+	}
+	dff->add_face("Bold", DefaultFontBold);
+	dff->add_face("Bold", DefaultFont);
+	dff->add_face("Bold", FontArabic);
+	dff->add_face("Bold", FontHebrew);
+	dff->add_face("Bold", FontThai);
+	dff->add_face("Bold", FontHindi);
+	dff->add_face("Bold", FontJapanese);
+	dff->add_face("Bold", FontFallback);
+
+	if (CustomFontSource.is_valid()) {
+		dff->add_face("Source", CustomFontSource);
+	}
+	dff->add_face("Source", dfmono);
+	dff->add_face("Source", DefaultFontBold);
+	dff->add_face("Source", DefaultFont);
+	dff->add_face("Source", FontArabic);
+	dff->add_face("Source", FontHebrew);
+	dff->add_face("Source", FontThai);
+	dff->add_face("Source", FontHindi);
+	dff->add_face("Source", FontJapanese);
+	dff->add_face("Source", FontFallback);
+
 	// Default font
 	MAKE_DEFAULT_FONT(df, default_font_size);
 	p_theme->set_default_theme_font(df);
diff --git a/editor/editor_settings.cpp b/editor/editor_settings.cpp
index 92e3f61ca5..98fc6d5742 100644
--- a/editor/editor_settings.cpp
+++ b/editor/editor_settings.cpp
@@ -272,7 +272,7 @@ void EditorSettings::_load_defaults(Ref<ConfigFile> p_extra_config) {
 		// Some locales are not properly supported currently in Godot due to lack of font shaping
 		// (e.g. Arabic or Hindi), so even though we have work in progress translations for them,
 		// we skip them as they don't render properly. (GH-28577)
-		const Vector<String> locales_to_skip = String("ar,bn,fa,he,hi,ml,si,ta,te,ur").split(",");
+		//const Vector<String> locales_to_skip = String("ar,bn,fa,he,hi,ml,si,ta,te,ur").split(",");

 		String best;

@@ -285,10 +285,10 @@ void EditorSettings::_load_defaults(Ref<ConfigFile> p_extra_config) {
 			// Skip locales which we can't render properly (see above comment).
 			// Test against language code without regional variants (e.g. ur_PK).
 			String lang_code = locale.get_slice("_", 0);
-			if (locales_to_skip.find(lang_code) != -1) {
-				etl++;
-				continue;
-			}
+			//if (locales_to_skip.find(lang_code) != -1) {
+			//	etl++;
+			//	continue;
+			//}

 			lang_hint += ",";
 			lang_hint += locale;


text:
diff --git a/editor/SCsub b/editor/SCsub
index 67787ca49d..b679c7f9b1 100644
--- a/editor/SCsub
+++ b/editor/SCsub
@@ -90,6 +90,9 @@ if env["tools"]:
     env.Depends("#editor/builtin_fonts.gen.h", flist)
     env.CommandNoCache("#editor/builtin_fonts.gen.h", flist, run_in_subprocess(editor_builders.make_fonts_header))

+    env.Append(CXXFLAGS=["-DGODOT_MODULE"])
+    env.Append(CPPPATH=["#modules/godot_tl/src/resources", "#modules/godot_tl/src", "#modules/godot_tl/subprojects/graphite2/include", "#modules/godot_tl/subprojects/harfbuzz/src", "#modules/godot_tl/subprojects/icu4c/source/common"])
+
     env.add_source_files(env.editor_sources, "*.cpp")
     env.add_source_files(env.editor_sources, "register_exporters.gen.cpp")

diff --git a/editor/editor_fonts.cpp b/editor/editor_fonts.cpp
index 39a825ea73..65470aed09 100644
--- a/editor/editor_fonts.cpp
+++ b/editor/editor_fonts.cpp
@@ -35,69 +35,31 @@
 #include "editor_scale.h"
 #include "editor_settings.h"
 #include "scene/resources/default_theme/default_theme.h"
-#include "scene/resources/dynamic_font.h"
-
-#define MAKE_FALLBACKS(m_name)          \
-	m_name->add_fallback(FontArabic);   \
-	m_name->add_fallback(FontHebrew);   \
-	m_name->add_fallback(FontThai);     \
-	m_name->add_fallback(FontHindi);    \
-	m_name->add_fallback(FontJapanese); \
-	m_name->add_fallback(FontFallback);
-
-// Enable filtering and mipmaps on the editor fonts to improve text appearance
-// in editors that are zoomed in/out without having dedicated fonts to generate.
-// This is the case in GraphEdit-based editors such as the visual script and
-// visual shader editors.
-
-// the custom spacings might only work with Noto Sans
+#include "scene/resources/theme.h"
+#include "modules/godot_tl/src/resources/tl_font_family.hpp"
+#include "modules/godot_tl/src/resources/tl_dynamic_font.hpp"
+#include "modules/godot_tl/src/resources/tl_gd_font_wrapper.hpp"
+
 #define MAKE_DEFAULT_FONT(m_name, m_size)                       \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	m_name->set_use_filter(true);                               \
-	m_name->set_use_mipmaps(true);                              \
-	if (CustomFont.is_valid()) {                                \
-		m_name->set_font_data(CustomFont);                      \
-		m_name->add_fallback(DefaultFont);                      \
-	} else {                                                    \
-		m_name->set_font_data(DefaultFont);                     \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Default");                     \
+	m_name->set_base_font_size(m_size);

 #define MAKE_BOLD_FONT(m_name, m_size)                          \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	m_name->set_use_filter(true);                               \
-	m_name->set_use_mipmaps(true);                              \
-	if (CustomFontBold.is_valid()) {                            \
-		m_name->set_font_data(CustomFontBold);                  \
-		m_name->add_fallback(DefaultFontBold);                  \
-	} else {                                                    \
-		m_name->set_font_data(DefaultFontBold);                 \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Bold");                        \
+	m_name->set_base_font_size(m_size);

 #define MAKE_SOURCE_FONT(m_name, m_size)                        \
-	Ref<DynamicFont> m_name;                                    \
+	Ref<TLGDFontWrapper> m_name;                                \
 	m_name.instance();                                          \
-	m_name->set_size(m_size);                                   \
-	m_name->set_use_filter(true);                               \
-	m_name->set_use_mipmaps(true);                              \
-	if (CustomFontSource.is_valid()) {                          \
-		m_name->set_font_data(CustomFontSource);                \
-		m_name->add_fallback(dfmono);                           \
-	} else {                                                    \
-		m_name->set_font_data(dfmono);                          \
-	}                                                           \
-	m_name->set_spacing(DynamicFont::SPACING_TOP, -EDSCALE);    \
-	m_name->set_spacing(DynamicFont::SPACING_BOTTOM, -EDSCALE); \
-	MAKE_FALLBACKS(m_name);
+	m_name->set_base_font(dff);                                 \
+	m_name->set_base_font_style("Bold");                        \
+	m_name->set_base_font_size(m_size);

 void editor_register_fonts(Ref<Theme> p_theme) {
 	DirAccess *dir = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
@@ -107,7 +69,7 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	bool font_antialiased = (bool)EditorSettings::get_singleton()->get("interface/editor/font_antialiased");
 	int font_hinting_setting = (int)EditorSettings::get_singleton()->get("interface/editor/font_hinting");

-	DynamicFontData::Hinting font_hinting;
+	DynamicFaceHinting font_hinting;
 	switch (font_hinting_setting) {
 		case 0:
 			// The "Auto" setting uses the setting that best matches the OS' font rendering:
@@ -115,27 +77,26 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 			// - Windows uses ClearType, which is in between "Light" and "Normal" hinting.
 			// - Linux has configurable font hinting, but most distributions including Ubuntu default to "Light".
 #ifdef OSX_ENABLED
-			font_hinting = DynamicFontData::HINTING_NONE;
+			font_hinting = DF_HINTING_NONE;
 #else
-			font_hinting = DynamicFontData::HINTING_LIGHT;
+			font_hinting = DF_HINTING_LIGHT;
 #endif
 			break;
 		case 1:
-			font_hinting = DynamicFontData::HINTING_NONE;
+			font_hinting = DF_HINTING_NONE;
 			break;
 		case 2:
-			font_hinting = DynamicFontData::HINTING_LIGHT;
+			font_hinting = DF_HINTING_LIGHT;
 			break;
 		default:
-			font_hinting = DynamicFontData::HINTING_NORMAL;
+			font_hinting = DF_HINTING_NORMAL;
 			break;
 	}

 	String custom_font_path = EditorSettings::get_singleton()->get("interface/editor/main_font");
-	Ref<DynamicFontData> CustomFont;
+	Ref<TLDynamicFontFace> CustomFont;
 	if (custom_font_path.length() > 0 && dir->file_exists(custom_font_path)) {
 		CustomFont.instance();
-		CustomFont->set_antialiased(font_antialiased);
 		CustomFont->set_hinting(font_hinting);
 		CustomFont->set_font_path(custom_font_path);
 		CustomFont->set_force_autohinter(true); //just looks better..i think?
@@ -146,10 +107,9 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	/* Custom Bold font */

 	String custom_font_path_bold = EditorSettings::get_singleton()->get("interface/editor/main_font_bold");
-	Ref<DynamicFontData> CustomFontBold;
+	Ref<TLDynamicFontFace> CustomFontBold;
 	if (custom_font_path_bold.length() > 0 && dir->file_exists(custom_font_path_bold)) {
 		CustomFontBold.instance();
-		CustomFontBold->set_antialiased(font_antialiased);
 		CustomFontBold->set_hinting(font_hinting);
 		CustomFontBold->set_font_path(custom_font_path_bold);
 		CustomFontBold->set_force_autohinter(true); //just looks better..i think?
@@ -160,10 +120,9 @@ void editor_register_fonts(Ref<Theme> p_theme) {
 	/* Custom source code font */

 	String custom_font_path_source = EditorSettings::get_singleton()->get("interface/editor/code_font");
-	Ref<DynamicFontData> CustomFontSource;
+	Ref<TLDynamicFontFace> CustomFontSource;
 	if (custom_font_path_source.length() > 0 && dir->file_exists(custom_font_path_source)) {
 		CustomFontSource.instance();
-		CustomFontSource->set_antialiased(font_antialiased);
 		CustomFontSource->set_hinting(font_hinting);
 		CustomFontSource->set_font_path(custom_font_path_source);
 	} else {
@@ -174,72 +133,104 @@ void editor_register_fonts(Ref<Theme> p_theme) {

 	/* Droid Sans */

-	Ref<DynamicFontData> DefaultFont;
+	Ref<TLDynamicFontFace> DefaultFont;
 	DefaultFont.instance();
-	DefaultFont->set_antialiased(font_antialiased);
 	DefaultFont->set_hinting(font_hinting);
 	DefaultFont->set_font_ptr(_font_NotoSansUI_Regular, _font_NotoSansUI_Regular_size);
 	DefaultFont->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> DefaultFontBold;
+	Ref<TLDynamicFontFace> DefaultFontBold;
 	DefaultFontBold.instance();
-	DefaultFontBold->set_antialiased(font_antialiased);
 	DefaultFontBold->set_hinting(font_hinting);
 	DefaultFontBold->set_font_ptr(_font_NotoSansUI_Bold, _font_NotoSansUI_Bold_size);
 	DefaultFontBold->set_force_autohinter(true); // just looks better..i think?

-	Ref<DynamicFontData> FontFallback;
+	Ref<TLDynamicFontFace> FontFallback;
 	FontFallback.instance();
-	FontFallback->set_antialiased(font_antialiased);
 	FontFallback->set_hinting(font_hinting);
 	FontFallback->set_font_ptr(_font_DroidSansFallback, _font_DroidSansFallback_size);
 	FontFallback->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontJapanese;
+	Ref<TLDynamicFontFace> FontJapanese;
 	FontJapanese.instance();
-	FontJapanese->set_antialiased(font_antialiased);
 	FontJapanese->set_hinting(font_hinting);
 	FontJapanese->set_font_ptr(_font_DroidSansJapanese, _font_DroidSansJapanese_size);
 	FontJapanese->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontArabic;
+	Ref<TLDynamicFontFace> FontArabic;
 	FontArabic.instance();
-	FontArabic->set_antialiased(font_antialiased);
 	FontArabic->set_hinting(font_hinting);
 	FontArabic->set_font_ptr(_font_NotoNaskhArabicUI_Regular, _font_NotoNaskhArabicUI_Regular_size);
 	FontArabic->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontHebrew;
+	Ref<TLDynamicFontFace> FontHebrew;
 	FontHebrew.instance();
-	FontHebrew->set_antialiased(font_antialiased);
 	FontHebrew->set_hinting(font_hinting);
 	FontHebrew->set_font_ptr(_font_NotoSansHebrew_Regular, _font_NotoSansHebrew_Regular_size);
 	FontHebrew->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontThai;
+	Ref<TLDynamicFontFace> FontThai;
 	FontThai.instance();
-	FontThai->set_antialiased(font_antialiased);
 	FontThai->set_hinting(font_hinting);
 	FontThai->set_font_ptr(_font_NotoSansThaiUI_Regular, _font_NotoSansThaiUI_Regular_size);
 	FontThai->set_force_autohinter(true); //just looks better..i think?

-	Ref<DynamicFontData> FontHindi;
+	Ref<TLDynamicFontFace> FontHindi;
 	FontHindi.instance();
-	FontHindi->set_antialiased(font_antialiased);
 	FontHindi->set_hinting(font_hinting);
 	FontHindi->set_font_ptr(_font_NotoSansDevanagariUI_Regular, _font_NotoSansDevanagariUI_Regular_size);
 	FontHindi->set_force_autohinter(true); //just looks better..i think?

 	/* Hack */

-	Ref<DynamicFontData> dfmono;
+	Ref<TLDynamicFontFace> dfmono;
 	dfmono.instance();
-	dfmono->set_antialiased(font_antialiased);
 	dfmono->set_hinting(font_hinting);
 	dfmono->set_font_ptr(_font_Hack_Regular, _font_Hack_Regular_size);

 	int default_font_size = int(EDITOR_GET("interface/editor/main_font_size")) * EDSCALE;

+	Ref<TLFontFamily> dff;
+	dff.instance();
+	dff->add_style("Default");
+	dff->add_style("Bold");
+	dff->add_style("Source");
+	if (CustomFont.is_valid()) {
+		dff->add_face("Default", CustomFont);
+	}
+	dff->add_face("Default", DefaultFont);
+	dff->add_face("Default", FontArabic);
+	dff->add_face("Default", FontHebrew);
+	dff->add_face("Default", FontThai);
+	dff->add_face("Default", FontHindi);
+	dff->add_face("Default", FontJapanese);
+	dff->add_face("Default", FontFallback);
+
+	if (CustomFontBold.is_valid()) {
+		dff->add_face("Bold", CustomFontBold);
+	}
+	dff->add_face("Bold", DefaultFontBold);
+	dff->add_face("Bold", DefaultFont);
+	dff->add_face("Bold", FontArabic);
+	dff->add_face("Bold", FontHebrew);
+	dff->add_face("Bold", FontThai);
+	dff->add_face("Bold", FontHindi);
+	dff->add_face("Bold", FontJapanese);
+	dff->add_face("Bold", FontFallback);
+
+	if (CustomFontSource.is_valid()) {
+		dff->add_face("Source", CustomFontSource);
+	}
+	dff->add_face("Source", dfmono);
+	dff->add_face("Source", DefaultFontBold);
+	dff->add_face("Source", DefaultFont);
+	dff->add_face("Source", FontArabic);
+	dff->add_face("Source", FontHebrew);
+	dff->add_face("Source", FontThai);
+	dff->add_face("Source", FontHindi);
+	dff->add_face("Source", FontJapanese);
+	dff->add_face("Source", FontFallback);
+
 	// Default font
 	MAKE_DEFAULT_FONT(df, default_font_size);
 	p_theme->set_default_theme_font(df);
diff --git a/editor/editor_settings.cpp b/editor/editor_settings.cpp
index 6fed5737de..4e90fc27ca 100644
--- a/editor/editor_settings.cpp
+++ b/editor/editor_settings.cpp
@@ -264,7 +264,7 @@ void EditorSettings::_load_defaults(Ref<ConfigFile> p_extra_config) {
 		// Some locales are not properly supported currently in Godot due to lack of font shaping
 		// (e.g. Arabic or Hindi), so even though we have work in progress translations for them,
 		// we skip them as they don't render properly. (GH-28577)
-		const Vector<String> locales_to_skip = String("ar,bn,fa,he,hi,ml,si,ta,te,ur").split(",");
+		//const Vector<String> locales_to_skip = String("ar,bn,fa,he,hi,ml,si,ta,te,ur").split(",");

 		String best;

@@ -276,10 +276,10 @@ void EditorSettings::_load_defaults(Ref<ConfigFile> p_extra_config) {
 			// Skip locales which we can't render properly (see above comment).
 			// Test against language code without regional variants (e.g. ur_PK).
 			String lang_code = locale.get_slice("_", 0);
-			if (locales_to_skip.find(lang_code) != -1) {
-				etl++;
-				continue;
-			}
+			//if (locales_to_skip.find(lang_code) != -1) {
+			//	etl++;
+			//	continue;
+			//}

 			lang_hint += ",";
 			lang_hint += locale;


text:
project(
	'libgdtl',
	'cpp',
	meson_version : '>= 0.38'
)
library_version = '0.1.0'

godot_cpp = meson.get_compiler('cpp').find_library(get_option('godot-cpp-lib-name'), dirs: join_paths(meson.current_source_dir(), 'godot-cpp', 'bin'))

if (get_option('builtin-runtime'))
	ft = subproject('freetype2').get_variable('freetype2_dep')
	png = subproject('libpng').get_variable('libpng_dep')
	zlib = subproject('zlib').get_variable('zlib_dep')
	hb = subproject('harfbuzz', default_options : ['use-graphite2=' + get_option('use-graphite2').to_string()]).get_variable('harfbuzz_dep')
	icu = subproject('icu4c').get_variable('icu4c_dep')
else
	ft = dependency('freetype2', version : '>=2.9.1', static : get_option('static-runtime'))
	png = dependency('libpng', version : '>=1.6.36', static : get_option('static-runtime'))
	zlib = dependency('zlib', version : '>=1.2.11', static : get_option('static-runtime'))
	hb = dependency('harfbuzz-icu', version : '>=2.1.1', static : get_option('static-runtime'))
	icu = dependency('icu-uc', version : '>=62.1', static : get_option('static-runtime'))
endif

prefix = ''
cpp_args = []
link_args = []
dependencies = [
	godot_cpp,
	hb,
	icu,
	ft,
	png,
	zlib
]

sources = [
	'src/tl_core.cpp',
	'src/resources/tl_font.cpp',
	'src/resources/tl_bitmap_font.cpp',
	'src/resources/tl_dynamic_font.cpp',
	'src/resources/tl_font_family.cpp',
	'src/resources/tl_shaped_string.cpp',
	'src/resources/tl_shaped_attributed_string.cpp',
	'src/resources/tl_shaped_paragraph.cpp',
	'src/resources/tl_icu_data_loader.cpp',
	'src/controls/tl_rich_text_edit.cpp',
	'src/controls/tl_label.cpp',
	'src/controls/tl_line_edit.cpp',
]

if get_option('use-graphite2')
	if (get_option('builtin-runtime'))
		gr = subproject('graphite2').get_variable('graphite2_dep')
	else
		gr = dependency('graphite2', version : '>=1.3.12', static : get_option('static-runtime'))
	endif
	dependencies += [gr]
	cpp_args += ['-DHAVE_GRAPHITE2']
endif

if get_option('use-ubsan')
	cpp_args += ['-fsanitize=undefined']
	link_args += ['-fsanitize=undefined']
endif

if get_option('use-asan')
	cpp_args += ['-fsanitize=address']
	link_args += ['-fsanitize=address']
endif

if get_option('use-lsan')
	cpp_args += ['-fsanitize=leak']
	link_args += ['-fsanitize=leak']
endif

if get_option('use-tsan')
	cpp_args += ['-fsanitize=thread']
	link_args += ['-fsanitize=thread']
endif

if host_machine.system() == 'linux'
	cpp_args += [
		'-std=c++14',
		'-Wno-unused-parameter',
		'-Wno-sign-compare'
	]
	if get_option('static-runtime')
		link_args += [
			'-static-libgcc',
			'-static-libstdc++'
		]
	endif
	link_args += [
		'-ldl',
		'-Wl,--no-undefined',
		'-Wl,-R,\'\$ORIGIN\'',
	]
elif host_machine.system() == 'android'
	cpp_args += [
		'-std=c++14',
		'-Wno-unused-parameter',
		'-Wno-sign-compare'
	]
	link_args += [
		'-ldl'
	]
elif host_machine.system() == 'windows'
	if meson.get_compiler('cpp').get_id() == 'msvc'
		prefix = 'lib'
		cpp_args += [
			'/MD',
			'/TP',
			'/EHsc'
		]
		link_args += [
			'/WX'
		]
	else
		cpp_args += [
			'-std=c++14',
			'-Wno-unused-parameter',
			'-Wno-sign-compare'
		]
		if get_option('static-runtime')
			link_args += [
				'-static',
				'-static-libgcc',
				'-static-libstdc++'
			]
		endif
		link_args += [
			'-Wl,--no-undefined'
		]
	endif
elif host_machine.system() == 'darwin' or host_machine.system() == 'ios'
	cpp_args += [
		'-std=c++14',
		'-Wno-unused-parameter',
		'-Wno-sign-compare'
	]
	link_args += [
		'-framework', 'Cocoa',
		'-Wl,-undefined,dynamic_lookup'
	]
endif

if host_machine.system() == 'ios'
	static_library(
		prefix + 'gdtl',
		sources,
		dependencies : dependencies,
		link_args : link_args,
		cpp_args : cpp_args,
		include_directories : include_directories('src', 'godot-core', 'godot-cpp/include', 'godot-cpp/include/core', 'godot-cpp/include/gen', 'godot-cpp/godot-headers')
	)
else
	shared_library(
		prefix + 'gdtl',
		sources,
		dependencies : dependencies,
		link_args : link_args,
		cpp_args : cpp_args,
		include_directories : include_directories('src', 'godot-core', 'godot-cpp/include', 'godot-cpp/include/core', 'godot-cpp/include/gen', 'godot-cpp/godot-headers')
	)
endif


text:
/*************************************************************************/
/*  register_types.h                                                     */
/*************************************************************************/

void register_godot_tl_types();
void unregister_godot_tl_types();


text:
<!--- Provide a general summary of the issue in the Title above -->

## Expected Behavior
<!--- If you're describing a bug, tell us what should happen -->
<!--- If you're suggesting a change/improvement, tell us how it should work -->

## Current Behavior
<!--- If describing a bug, tell us what happens instead of the expected behavior -->
<!--- If suggesting a change/improvement, explain the difference from current behavior -->

## Possible Solution
<!--- Not obligatory, but suggest a fix/reason for the bug, -->
<!--- or ideas how to implement the addition or change -->

## Steps to Reproduce (for bugs)
<!--- Provide a link to a live example, or an unambiguous set of steps to -->
<!--- reproduce this bug. Include code to reproduce, if relevant -->

## Context
<!--- How has this issue affected you? What are you trying to accomplish? -->
<!--- Providing context helps us come up with a solution that is most useful in the real world -->

## Your Environment
<!--- Include as many relevant details about the environment you experienced the bug in -->
* Library version used:
* godot-cpp version used:
* Godot version used:
* Operating System and version:

## Minimal reproduction project
<!-- Recommended as it greatly speeds up debugging. Drag and drop a zip archive to upload it -->


text:
#!/usr/bin/env python

Import('env')
Import('env_modules')

from compat import isbasestring

SConscript('src/SCsub')

if env['builtin_runtime']:
	SConscript('subprojects/harfbuzz/SCsub')
	SConscript('subprojects/icu4c/SCsub')
	if env['use_graphite2']:
		SConscript('subprojects/graphite2/SCsub')
else:
	pass


text:
diff --git a/scene/gui/line_edit.cpp b/scene/gui/line_edit.cpp
index 7cc47d351e..2156edb911 100644
--- a/scene/gui/line_edit.cpp
+++ b/scene/gui/line_edit.cpp
@@ -28,6 +28,8 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/

+#if 0
+
 #include "line_edit.h"

 #include "core/message_queue.h"
@@ -1878,3 +1880,5 @@ LineEdit::LineEdit() {

 LineEdit::~LineEdit() {
 }
+
+#endif
diff --git a/scene/gui/line_edit.h b/scene/gui/line_edit.h
index 037238d682..961411b5ec 100644
--- a/scene/gui/line_edit.h
+++ b/scene/gui/line_edit.h
@@ -31,6 +31,31 @@
 #ifndef LINE_EDIT_H
 #define LINE_EDIT_H

+#include "modules/godot_tl/src/controls/tl_line_edit.hpp"
+#include "modules/godot_tl/src/resources/tl_gd_font_wrapper.hpp"
+
+class LineEdit : public TLLineEdit {
+	GDCLASS(LineEdit, TLLineEdit);
+public:
+	void _notification(int p_what) {
+		if ((p_what == NOTIFICATION_THEME_CHANGED) || (p_what == NOTIFICATION_POST_ENTER_TREE)) {
+			Ref<Font> font_w = get_font("font");
+			TLGDFontWrapper *fw_ref = cast_to<TLGDFontWrapper>(*font_w);
+			if (fw_ref) {
+				set_base_font(fw_ref->get_base_font());
+				set_base_font_style(fw_ref->get_base_font_style());
+				set_base_font_size(fw_ref->get_base_font_size());
+			}
+		}
+	}
+
+	LineEdit() {
+		_init();
+	}
+};
+
+#if 0
+
 #include "scene/gui/control.h"
 #include "scene/gui/popup_menu.h"

@@ -244,3 +269,5 @@ VARIANT_ENUM_CAST(LineEdit::Align);
 VARIANT_ENUM_CAST(LineEdit::MenuItems);

 #endif
+
+#endif
diff --git a/scene/gui/spin_box.cpp b/scene/gui/spin_box.cpp
index 92377949f8..93cc621dfa 100644
--- a/scene/gui/spin_box.cpp
+++ b/scene/gui/spin_box.cpp
@@ -202,10 +202,10 @@ void SpinBox::_notification(int p_what) {
 	}
 }

-void SpinBox::set_align(LineEdit::Align p_align) {
+void SpinBox::set_align(int p_align) {
 	line_edit->set_align(p_align);
 }

-LineEdit::Align SpinBox::get_align() const {
+int SpinBox::get_align() const {
 	return line_edit->get_align();
 }
diff --git a/scene/gui/spin_box.h b/scene/gui/spin_box.h
index 04491c8477..5ba31ece9f 100644
--- a/scene/gui/spin_box.h
+++ b/scene/gui/spin_box.h
@@ -76,8 +76,8 @@ public:

 	virtual Size2 get_minimum_size() const;

-	void set_align(LineEdit::Align p_align);
-	LineEdit::Align get_align() const;
+	void set_align(int p_align);
+	int get_align() const;

 	void set_editable(bool p_editable);
 	bool is_editable() const;


text:
diff --git a/platform/javascript/detect.py b/platform/javascript/detect.py
old mode 100644
new mode 100644
index b527336f83..60af313de0
--- a/platform/javascript/detect.py
+++ b/platform/javascript/detect.py
@@ -98,7 +98,7 @@ def configure(env):
     else:
         # Disable exceptions and rtti on non-tools (template) builds
         # These flags help keep the file size down.
-        env.Append(CCFLAGS=["-fno-exceptions", "-fno-rtti"])
+        env.Append(CCFLAGS=["-fno-exceptions"])
         # Don't use dynamic_cast, necessary with no-rtti.
         env.Append(CPPDEFINES=["NO_SAFE_CAST"])


text:
<!--- Provide a general summary of your changes in the Title above -->

## Description
<!--- Describe your changes in detail -->

## Motivation and Context
<!--- Why is this change required? What problem does it solve? -->
<!--- If it fixes an open issue, please link to the issue here. -->

## How Has This Been Tested?
<!--- Please describe in detail how you tested your changes. -->
<!--- Include details of your testing environment, and the tests you ran to -->
<!--- see how your change affects other areas of the code, etc. -->

## Screenshots (if appropriate)

## Types of changes
<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to change)

## Checklist
<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
<!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
- [ ] My code follows the code style of this project.
- [ ] My change requires a change to the documentation.
- [ ] I have updated the documentation accordingly.

## Copyright waiver
I dedicate any and all copyright interest in this software to the public domain. I make this dedication for the benefit of the public at large and to the detriment of my heirs and successors. I intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.

To the best of my knowledge and belief, my contributions are either originally authored by me or are derived from prior works which I have verified are also in the public domain and are not subject to claims of copyright by other parties.

To the best of my knowledge and belief, no individual, business, organization, government, or other entity has any copyright interest in my contributions, and I affirm that I will not make contributions that are otherwise encumbered.


text:
from SCons.Script import BoolVariable, Dir, Environment, File, SCons, Variables

def can_build(env, platform):
    return True

def configure(env):
    envvars = Variables()
    envvars.Add(BoolVariable('builtin_runtime', 'Use the built-in libraries', True))
    envvars.Add(BoolVariable('use_graphite2', 'Enable Graphite2 complementary shaper', True))
    envvars.Add(BoolVariable('use_font_wrapper', 'Enable Godot font wrapper', False))
    envvars.Update(env)

def get_doc_classes():
    return [
            "TLICUDataLoader",
            "TLFontFace",
            "TLBitmapFontFace",
            "TLDynamicFontFace",
            "TLFontFamily",
            "TLShapedString",
            "TLShapedAttributedString",
            "TLShapedParagraph",
            "TLRichTextEdit",
            "TLRichTextEditSelection",
            "TLLabel",
            "TLLineEdit",
            "TLFontIterator",
            "TLGDFontWrapper"
    ]

def get_doc_path():
    return "doc_classes"


text:
diff --git a/platform/android/java/lib/build.gradle b/platform/android/java/lib/build.gradle
old mode 100644
new mode 100755
index 663ba73d40..478425d223
--- a/platform/android/java/lib/build.gradle
+++ b/platform/android/java/lib/build.gradle
@@ -106,7 +106,7 @@ android {
         def taskName = getSconsTaskName(buildType)
         tasks.create(name: taskName, type: Exec) {
             executable sconsExecutableFile.absolutePath
-            args "--directory=${pathToRootDir}", "platform=android", "target=${releaseTarget}", "android_arch=${defaultAbi}", "-j" + Runtime.runtime.availableProcessors()
+            args "BUILD_NAME=gdtl", "--directory=${pathToRootDir}", "use_font_wrapper=yes", "platform=android", "target=${releaseTarget}", "android_arch=${defaultAbi}", "-j" + Runtime.runtime.availableProcessors()
         }

         // Schedule the tasks so the generated libs are present before the aar file is packaged.


text:
diff --git a/scene/gui/label.cpp b/scene/gui/label.cpp
index 9b542cb179..1fed2d0d1e 100644
--- a/scene/gui/label.cpp
+++ b/scene/gui/label.cpp
@@ -28,6 +28,8 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/

+#if 0
+
 #include "label.h"
 #include "core/print_string.h"
 #include "core/project_settings.h"
@@ -723,3 +725,5 @@ Label::~Label() {
 		memdelete(current);
 	}
 }
+
+#endif
diff --git a/scene/gui/label.h b/scene/gui/label.h
index ba6e627c58..eec4937166 100644
--- a/scene/gui/label.h
+++ b/scene/gui/label.h
@@ -31,6 +31,31 @@
 #ifndef LABEL_H
 #define LABEL_H

+#include "modules/godot_tl/src/controls/tl_label.hpp"
+#include "modules/godot_tl/src/resources/tl_gd_font_wrapper.hpp"
+
+class Label : public TLLabel {
+	GDCLASS(Label, TLLabel);
+public:
+	void _notification(int p_what) {
+		if ((p_what == NOTIFICATION_THEME_CHANGED) || (p_what == NOTIFICATION_POST_ENTER_TREE)) {
+			Ref<Font> font_w = get_font("font");
+			TLGDFontWrapper *fw_ref = cast_to<TLGDFontWrapper>(*font_w);
+			if (fw_ref) {
+				set_base_font(fw_ref->get_base_font());
+				set_base_font_style(fw_ref->get_base_font_style());
+				set_base_font_size(fw_ref->get_base_font_size());
+			}
+		}
+	};
+	Label(const String &p_text = String()) {
+		_init();
+		set_text(p_text);
+	}
+};
+
+#if 0
+
 #include "scene/gui/control.h"

 class Label : public Control {
@@ -149,3 +174,5 @@ VARIANT_ENUM_CAST(Label::Align);
 VARIANT_ENUM_CAST(Label::VAlign);

 #endif
+
+#endif


text:
diff --git a/scene/resources/font.h b/scene/resources/font.h
index 9b99b85d22..dcedc602ee 100644
--- a/scene/resources/font.h
+++ b/scene/resources/font.h
@@ -49,12 +49,12 @@ public:
 	virtual float get_descent() const = 0;

 	virtual Size2 get_char_size(CharType p_char, CharType p_next = 0) const = 0;
-	Size2 get_string_size(const String &p_string) const;
+	virtual Size2 get_string_size(const String &p_string) const;
 	Size2 get_wordwrap_string_size(const String &p_string, float p_width) const;

 	virtual bool is_distance_field_hint() const = 0;

-	void draw(RID p_canvas_item, const Point2 &p_pos, const String &p_text, const Color &p_modulate = Color(1, 1, 1), int p_clip_w = -1, const Color &p_outline_modulate = Color(1, 1, 1)) const;
+	virtual void draw(RID p_canvas_item, const Point2 &p_pos, const String &p_text, const Color &p_modulate = Color(1, 1, 1), int p_clip_w = -1, const Color &p_outline_modulate = Color(1, 1, 1)) const;
 	void draw_halign(RID p_canvas_item, const Point2 &p_pos, HAlign p_align, float p_width, const String &p_text, const Color &p_modulate = Color(1, 1, 1), const Color &p_outline_modulate = Color(1, 1, 1)) const;

 	virtual bool has_outline() const { return false; }


text:
diff --git a/scene/gui/dialogs.cpp b/scene/gui/dialogs.cpp
index d5e8d04390..b350b94c3f 100644
--- a/scene/gui/dialogs.cpp
+++ b/scene/gui/dialogs.cpp
@@ -206,7 +206,7 @@ void WindowDialog::_notification(int p_what) {
 			Ref<Font> title_font = get_font("title_font", "WindowDialog");
 			Color title_color = get_color("title_color", "WindowDialog");
 			int title_height = get_constant("title_height", "WindowDialog");
-			int font_height = title_font->get_height() - title_font->get_descent() * 2;
+			int font_height = title_font->get_height();
 			int x = (size.x - title_font->get_string_size(xl_title).x) / 2;
 			int y = (-title_height + font_height) / 2;
 			title_font->draw(canvas, Point2(x, y), xl_title, title_color, size.x - panel->get_minimum_size().x);


text:
diff --git a/SConstruct b/SConstruct
index 1f06a0a..ba80f6a 100644
--- a/SConstruct
+++ b/SConstruct
@@ -386,7 +386,8 @@ elif env['platform'] == 'android':
     # Setup tools
     env['CC'] = toolchain + "/bin/clang"
     env['CXX'] = toolchain + "/bin/clang++"
-    env['AR'] = toolchain + "/bin/" + arch_info['tool_path'] + "-ar"
+    env['AR'] = toolchain + "/bin/llvm-ar"
+    env['RANLIB'] = toolchain + "/bin/llvm-ranlib"

     env.Append(CCFLAGS=['--target=' + arch_info['target'] + env['android_api_level'], '-march=' + arch_info['march'], '-fPIC'])#, '-fPIE', '-fno-addrsig', '-Oz'])
     env.Append(CCFLAGS=arch_info['ccflags'])