diff --git a/.github/workflows/static_checks.yml b/.github/workflows/static_checks.yml
index 9d9e1874..c327db34 100644
--- a/.github/workflows/static_checks.yml
+++ b/.github/workflows/static_checks.yml
@@ -31,7 +31,7 @@ jobs:
       - name: Checkout workaround
         run: |
           mv tmp/misc/scripts misc/scripts
-          cp misc/formatting/clang_format.sh misc/scripts/clang_format.sh
+          cp clang_format.sh misc/scripts/clang_format.sh
 
       - name: Install APT dependencies
         uses: awalsh128/cache-apt-pkgs-action@latest
@@ -62,10 +62,6 @@ jobs:
         run: |
           bash ./misc/scripts/file_format.sh changed.txt
 
-      - name: Header guards formatting checks (header_guards.sh)
-        run: |
-          bash ./misc/scripts/header_guards.sh changed.txt
-
       - name: Python scripts static analysis (mypy_check.sh)
         run: |
           if grep -qE '\.py$|SConstruct|SCsub' changed.txt || [ -z "$(cat changed.txt)" ]; then
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index b3aae617..21824c08 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -20,12 +20,13 @@
   - ``.github``: Runs custom CI/CD in GitHub
   - ``docs``: Add some additional stuff for README.md
   - ``src``: Contains custom C++ code
+    - [language](src/language/README.md)
 
 
 ## Preparing your PR
 
 The project is using [`clang-format`](https://clang.llvm.org/docs/ClangFormat.html) to format C++ files. 
-You need to run `bash ./misc/formatting/clang_format.sh` before your PR for a successful pipeline.
+You need to run `bash clang_format.sh` before your PR for a successful pipeline.
 
 Furthermore, there is an `utf-8` and `LF` checker to fix file formats. Additionally, some spellchecks run inside the [pipeline](.github/workflows/static_checks.yml).
 
diff --git a/SCsub b/SCsub
index 5b87ceee..0246a116 100644
--- a/SCsub
+++ b/SCsub
@@ -69,7 +69,6 @@ if env["tests"]:
 
 sources = [
     "register_types.cpp",
-    "javascript_language.cpp",
     "javascript_instance.cpp",
     "javascript.cpp",
 ]
@@ -77,6 +76,17 @@ sources = [
 # Add all required files for "Javascript" language into godot
 env_javascript.Append(CPPPATH=["#modules/javascript"])
 env_javascript.add_source_files(env.modules_sources, sources)
+env_javascript.add_source_files(env.modules_sources, "src/language/*.cpp")
+env_javascript.add_source_files(env.modules_sources, "src/language/templates/*.cpp")
+
+# --- Generate template files ---
+from misc.generate.templates import get_templates_header
+from misc.generate.templates import get_templates_files
+from misc.generate.generate_files import generate_templates
+
+files = get_templates_files()
+generate_templates(javascript_dir, get_templates_header(), files)
+env_javascript.add_source_files(env.modules_sources, files.keys())
 
 # --- Generate binding files ---
 # Binding script to run at engine initializing
diff --git a/misc/formatting/clang_format.sh b/clang_format.sh
similarity index 100%
rename from misc/formatting/clang_format.sh
rename to clang_format.sh
diff --git a/editor/editor_tools.cpp b/editor/editor_tools.cpp
index 875405dc..5741eb56 100644
--- a/editor/editor_tools.cpp
+++ b/editor/editor_tools.cpp
@@ -8,7 +8,7 @@
 #include "editor/editor_help.h"
 #include "editor/filesystem_dock.h"
 
-#include "../javascript_language.h"
+#include "../src/language/javascript_language.h"
 
 #define TS_IGNORE "//@ts-ignore\n"
 static HashMap<String, HashSet<String>> ts_ignore_errors;
diff --git a/javascript.cpp b/javascript.cpp
index 7ad4b3b8..98eadbbd 100644
--- a/javascript.cpp
+++ b/javascript.cpp
@@ -2,11 +2,10 @@
 /* After loading it contains the code/bytecode of the loaded file. */
 
 #include "javascript.h"
-#include "core/config/engine.h"
 #include "core/io/file_access_encrypted.h"
 #include "javascript_instance.h"
-#include "javascript_language.h"
 #include "scene/resources/resource_format_text.h"
+#include "src/language/javascript_language.h"
 
 ScriptLanguage *JavaScript::get_language() const {
 	return JavaScriptLanguage::get_singleton();
diff --git a/javascript.h b/javascript.h
index 2813c89d..98bfc4eb 100644
--- a/javascript.h
+++ b/javascript.h
@@ -9,7 +9,9 @@
 
 #include "javascript_binder.h"
 
+#define EXT_NAME "JavaScript"
 #define EXT_JSCLASS "mjs"
+#define EXT_TSCLASS "ts"
 #define EXT_JSMODULE "js"
 #define EXT_JSON "json"
 
diff --git a/javascript_instance.cpp b/javascript_instance.cpp
index af0e67b8..4c286ace 100644
--- a/javascript_instance.cpp
+++ b/javascript_instance.cpp
@@ -1,6 +1,6 @@
 #include "javascript_instance.h"
 #include "javascript.h"
-#include "javascript_language.h"
+#include "src/language/javascript_language.h"
 
 Ref<Script> JavaScriptInstance::get_script() const {
 	return script;
diff --git a/javascript_language.cpp b/javascript_language.cpp
deleted file mode 100644
index aa041490..00000000
--- a/javascript_language.cpp
+++ /dev/null
@@ -1,368 +0,0 @@
-/* This is the language server implementation. It handles how/when to use JS Scripts. */
-
-#include "javascript_language.h"
-#include "core/io/file_access.h"
-#include "core/object/class_db.h"
-
-#include "javascript_binder.h"
-#include "thirdparty/quickjs/quickjs_binder.h"
-
-JavaScriptLanguage *JavaScriptLanguage::singleton = nullptr;
-
-namespace JavaScriptInstanceBindingCallbacks {
-
-static void *create_callback(void *p_token, void *p_instance) {
-	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
-		return binder->alloc_object_binding_data(static_cast<Object *>(p_instance));
-	}
-	return nullptr;
-}
-
-static void free_callback(void *p_token, void *p_instance, void *p_binding) {
-	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
-		return binder->free_object_binding_data(static_cast<JavaScriptGCHandler *>(p_binding));
-	}
-}
-
-static GDExtensionBool reference_callback(void *p_token, void *p_binding, GDExtensionBool p_reference) {
-	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
-		if (p_reference) {
-			binder->godot_refcount_incremented(static_cast<JavaScriptGCHandler *>(p_binding));
-			return false;
-		} else {
-			return binder->godot_refcount_decremented(static_cast<JavaScriptGCHandler *>(p_binding));
-		}
-	}
-	return true;
-}
-
-} // namespace JavaScriptInstanceBindingCallbacks
-
-JavaScriptLanguage::JavaScriptLanguage() {
-	ERR_FAIL_COND(singleton);
-	singleton = this;
-	main_binder = memnew(QuickJSBinder);
-	callable_middleman = memnew(CallableMiddleman);
-	instance_binding_callbacks.create_callback = JavaScriptInstanceBindingCallbacks::create_callback;
-	instance_binding_callbacks.free_callback = JavaScriptInstanceBindingCallbacks::free_callback;
-	instance_binding_callbacks.reference_callback = JavaScriptInstanceBindingCallbacks::reference_callback;
-}
-
-JavaScriptLanguage::~JavaScriptLanguage() {
-	memdelete(main_binder);
-	memdelete(callable_middleman);
-}
-
-void JavaScriptLanguage::init() {
-	ERR_FAIL_NULL(main_binder);
-	main_binder->initialize();
-}
-
-void JavaScriptLanguage::finish() {
-	ERR_FAIL_NULL(main_binder);
-	main_binder->uninitialize();
-	main_binder->language_finalize();
-}
-
-Error JavaScriptLanguage::execute_file(const String &code) {
-	ERR_FAIL_NULL_V(main_binder, ERR_BUG);
-	JavaScriptGCHandler eval_ret;
-	const Error err = main_binder->eval_string(code, JavaScriptBinder::EVAL_TYPE_GLOBAL, "test.js", eval_ret);
-	return err;
-}
-
-void JavaScriptLanguage::get_reserved_words(List<String> *p_words) const {
-	static const char *_reserved_words[] = {
-		"null",
-		"false",
-		"true",
-		"if",
-		"else",
-		"return",
-		"var",
-		"this",
-		"delete",
-		"void",
-		"typeof",
-		"new",
-		"in",
-		"instanceof",
-		"do",
-		"while",
-		"for",
-		"break",
-		"continue",
-		"switch",
-		"case",
-		"default",
-		"throw",
-		"try",
-		"catch",
-		"finally",
-		"function",
-		"debugger",
-		"with",
-		"class",
-		"const",
-		"enum",
-		"export",
-		"default",
-		"extends",
-		"import",
-		"super",
-		"implements",
-		"interface",
-		"let",
-		"package",
-		"private",
-		"protected",
-		"public",
-		"static",
-		"yield",
-		"await",
-		"prototype",
-		"constructor",
-		"get",
-		"set",
-		"of",
-		"__proto__",
-		"undefined",
-		"number",
-		"boolean",
-		"string",
-		"object",
-		"symbol",
-		"arguments",
-		"join",
-		"global",
-		"as",
-		"from",
-		"default",
-		"*",
-		"then",
-		"resolve",
-		"reject",
-		"promise",
-		"proxy",
-		"revoke",
-		"async",
-		"globalThis",
-		"Object",
-		"Array",
-		"Error",
-		"Number",
-		"String",
-		"Boolean",
-		"Symbol",
-		"Arguments",
-		"Math",
-		"JSON",
-		"Date",
-		"Function",
-		"GeneratorFunction",
-		"ForInIterator",
-		"RegExp",
-		"ArrayBuffer",
-		"SharedArrayBuffer",
-		"Uint8ClampedArray",
-		"Int8Array",
-		"Uint8Array",
-		"Int16Array",
-		"Uint16Array",
-		"Int32Array",
-		"Uint32Array",
-		"BigInt64Array",
-		"BigUint64Array",
-		"Float32Array",
-		"Float64Array",
-		"DataView",
-		"Map",
-		"Set",
-		"WeakMap",
-		"WeakSet",
-		"Generator",
-		"Proxy",
-		"Promise",
-		0
-	};
-
-	const char **w = _reserved_words;
-
-	while (*w) {
-		p_words->push_back(*w);
-		w++;
-	}
-}
-
-bool JavaScriptLanguage::is_control_flow_keyword(String p_keyword) const {
-	return p_keyword == "if" ||
-			p_keyword == "else" ||
-			p_keyword == "return" ||
-			p_keyword == "do" ||
-			p_keyword == "while" ||
-			p_keyword == "for" ||
-			p_keyword == "break" ||
-			p_keyword == "continue" ||
-			p_keyword == "switch" ||
-			p_keyword == "case" ||
-			p_keyword == "throw" ||
-			p_keyword == "try" ||
-			p_keyword == "catch" ||
-			p_keyword == "finally";
-}
-
-void JavaScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
-	p_delimiters->push_back("//"); // single-line comment
-	p_delimiters->push_back("/* */"); // delimited comment
-}
-
-void JavaScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
-	p_delimiters->push_back("' '");
-	p_delimiters->push_back("\" \"");
-	p_delimiters->push_back("` `");
-}
-
-Ref<Script> JavaScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
-	Ref<JavaScript> javaScript;
-	javaScript.instantiate();
-	String src = p_template.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
-	javaScript->set_source_code(src);
-	return javaScript;
-}
-
-Vector<ScriptLanguage::ScriptTemplate> JavaScriptLanguage::get_built_in_templates(StringName p_object) {
-	Vector<ScriptLanguage::ScriptTemplate> templates;
-#ifdef TOOLS_ENABLED
-	constexpr int len = 2;
-	static const struct ScriptLanguage::ScriptTemplate TEMPLATES[len] = {
-		{ "Node",
-				"Default",
-				"Base template for Node with default Godot cycle methods",
-				"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
-				"    \n"
-				"    constructor() {\n"
-				"        super();\n"
-				"    }\n"
-				"    \n"
-				"    // Called when the node enters the scene tree for the first time.\n"
-				"    _ready() {\n"
-				"        \n"
-				"    }\n"
-				"    \n"
-				"    // Called every frame. 'delta' is the elapsed time since the previous frame.\n"
-				"    _process(delta) {\n"
-				"        \n"
-				"    }\n"
-				"}\n" },
-		{ "Object",
-				"Empty",
-				"Empty template suitable for all Objects",
-				"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
-				"    \n"
-				"    // Declare member variables here. Examples:\n"
-				"    a = 2;\n"
-				"    b = \"text\";\n"
-				"    \n"
-				"    constructor() {\n"
-				"        super();\n"
-				"    }\n"
-				"    \n"
-				"}\n" },
-	};
-
-	for (int i = 0; i < len; i++) {
-		if (TEMPLATES[i].inherit == p_object) {
-			templates.append(TEMPLATES[i]);
-		}
-	}
-#endif
-
-	return templates;
-}
-
-bool JavaScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptError> *r_errors, List<Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
-	JavaScriptError script_error;
-	bool ret = main_binder->validate(p_script, p_path, &script_error);
-	if (!ret) {
-		ScriptError se;
-		se.line = script_error.line;
-		se.column = script_error.column;
-		se.message = script_error.message;
-		r_errors->push_back(se);
-	}
-	return ret;
-}
-
-Script *JavaScriptLanguage::create_script() const {
-	return memnew(JavaScript);
-}
-
-void JavaScriptLanguage::reload_all_scripts() {
-#ifdef TOOLS_ENABLED
-	for (const Ref<JavaScript> &s : scripts) {
-		reload_script(s, true);
-	}
-#endif
-}
-
-void JavaScriptLanguage::reload_script(const Ref<Script> &p_script, bool p_soft_reload) {
-	Ref<JavaScript> s = p_script;
-	if (s.is_valid()) {
-		Error err = OK;
-		Ref<JavaScriptModule> module = ResourceFormatLoaderJavaScriptModule::load_static(s->get_script_path(), "", &err);
-
-		if (err != ERR_FILE_NOT_FOUND) {
-			// We don't need to reload a script if it isn't existing
-
-			ERR_FAIL_COND_MSG(err != OK, ("Cannot reload script file '" + s->get_script_path() + "'."));
-			s->set_source_code(module->get_source_code());
-			err = s->reload(p_soft_reload);
-			ERR_FAIL_COND_MSG(err != OK, "Parse source code from file '" + s->get_script_path() + "' failed.");
-		} else {
-			// If we are in the editor we need to erase the script from the language server to avoid reload on focus (editor_tools.cpp[_notification()])
-#ifdef TOOLS_ENABLED
-			singleton->get_scripts().erase(s);
-#endif
-		}
-	}
-}
-
-void JavaScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
-	p_extensions->push_back(EXT_JSMODULE);
-	p_extensions->push_back(EXT_JSCLASS);
-	p_extensions->push_back(EXT_JSON);
-}
-
-void JavaScriptLanguage::frame() {
-	main_binder->frame();
-}
-
-String JavaScriptLanguage::globalize_relative_path(const String &p_relative, const String &p_base_dir) {
-	String file = p_relative;
-	if (file.begins_with(".")) {
-		String base_dir = p_base_dir;
-		while (base_dir.ends_with(".")) {
-			if (base_dir.ends_with("..")) {
-				base_dir = base_dir.get_base_dir().get_base_dir();
-			} else {
-				base_dir = base_dir.get_base_dir();
-			}
-		}
-		String file_path = file;
-		while (file_path.begins_with(".")) {
-			if (file_path.begins_with("../")) {
-				base_dir = base_dir.get_base_dir();
-				file_path = file_path.substr(3);
-			} else if (file_path.begins_with("./")) {
-				file_path = file_path.substr(2);
-			} else {
-				file_path = file_path.get_basename();
-				break;
-			}
-		}
-		if (!base_dir.ends_with("/"))
-			base_dir += "/";
-		file = base_dir + file_path;
-	}
-	return file;
-}
diff --git a/misc/generate/bindings.py b/misc/generate/bindings.py
index bb2e260e..64bdedd9 100644
--- a/misc/generate/bindings.py
+++ b/misc/generate/bindings.py
@@ -1,6 +1,9 @@
 def get_bindings_header():
     return (
-        '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "../javascript_binder.h"\nString JavaScriptBinder::{} = \n{};'
+        '/* THIS FILE IS GENERATED DO NOT EDIT */\n'
+        '#include "../javascript_binder.h"\n'
+        'String JavaScriptBinder::{} = \n'
+        '{};'
     )
 
 
diff --git a/misc/generate/editor_tools.py b/misc/generate/editor_tools.py
index 8b42e57f..63014b8f 100644
--- a/misc/generate/editor_tools.py
+++ b/misc/generate/editor_tools.py
@@ -1,6 +1,9 @@
 def get_editor_tools_header():
     return (
-        '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
+        '/* THIS FILE IS GENERATED DO NOT EDIT */\n'
+        '#include "editor_tools.h"\n'
+        'String JavaScriptPlugin::{} = \n'
+        '{};'
     )
 
 
diff --git a/misc/generate/generate_files.py b/misc/generate/generate_files.py
index a6a58ebf..0cef6fb9 100644
--- a/misc/generate/generate_files.py
+++ b/misc/generate/generate_files.py
@@ -27,11 +27,21 @@ def dump_text_file_to_cpp(javascript_dir, path):
     return source
 
 
-def generate(javascript_dir, header, tool_fns):
-    for fn, subs in tool_fns.items():
+def generate(javascript_dir, header, files):
+    for fn, subs in files.items():
         with open_file(javascript_dir, fn, "w") as fh:
             name = subs[0]
             file = dump_text_file_to_cpp(javascript_dir, subs[1])
             fh.write(header.format(name, file))
 
 
+def generate_templates(javascript_dir, header, files):
+    for fn, subs in files.items():
+        with (open_file(javascript_dir, fn, "w") as fh):
+            cpp_name = subs[0]
+            inherit = subs[1]
+            template_name = subs[2]
+            template_description = subs[3]
+            file = dump_text_file_to_cpp(javascript_dir, subs[4])
+            file = file.replace("GODOT_OBJECT_NAME", "\" GODOT_OBJECT_NAME \"")
+            fh.write(header.format(cpp_name, inherit, template_name, template_description, file))
diff --git a/misc/generate/templates.py b/misc/generate/templates.py
new file mode 100644
index 00000000..7eea9fa0
--- /dev/null
+++ b/misc/generate/templates.py
@@ -0,0 +1,31 @@
+def get_templates_header():
+    return (
+        '/* THIS FILE IS GENERATED DO NOT EDIT */\n'
+        '#include "javascript_template_manager.h"\n'
+        'ScriptLanguage::ScriptTemplate JavaScriptLanguageManager::{} = \n'
+        '{{\n'
+        '"{}",\n'
+        '"{}",\n'
+        '"{}",\n'
+        '{}\n'
+        '}};'
+    )
+
+
+def get_templates_files():
+    return {
+        "src/language/templates/default_template.gen.cpp": (
+            "DEFAULT_TEMPLATE",  # Name of the C++ variable
+            "Node",  # Inherits from Godot Object
+            "Default",  # Name of the template
+            "Base template for Node with default Godot cycle methods",  # Description of the template
+            "misc/template-contents/default.js",  # Path of the template
+        ),
+        "src/language/templates/empty_template.gen.cpp": (
+            "EMPTY_TEMPLATE",  # Name of the C++ variable
+            "Object",  # Inherits from Godot Object
+            "Empty",  # Name of the template
+            "Empty template suitable for all Objects",  # Description of the template
+            "misc/template-contents/empty.js",  # Path of the template
+        ),
+    }
diff --git a/misc/generate/test_manager.py b/misc/generate/test_manager.py
index 78215830..bd0e3f42 100644
--- a/misc/generate/test_manager.py
+++ b/misc/generate/test_manager.py
@@ -1,6 +1,9 @@
 def get_test_manager_header():
     return (
-        '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "test_manager.h"\nString TestManager::{} = \n{};'
+        '/* THIS FILE IS GENERATED DO NOT EDIT */\n'
+        '#include "test_manager.h"\n'
+        'String TestManager::{} = \n'
+        '{};'
     )
 
 
diff --git a/misc/template-contents/default.js b/misc/template-contents/default.js
new file mode 100644
index 00000000..0faa8aed
--- /dev/null
+++ b/misc/template-contents/default.js
@@ -0,0 +1,11 @@
+export default class CLASS extends GODOT_OBJECT_NAME.BASE {
+  constructor() {
+    super();
+  }
+
+  // Called when the node enters the scene tree for the first time.
+  _ready() {}
+
+  // Called every frame. 'delta' is the elapsed time since the previous frame.
+  _process(delta) {}
+}
diff --git a/misc/template-contents/empty.js b/misc/template-contents/empty.js
new file mode 100644
index 00000000..f6337286
--- /dev/null
+++ b/misc/template-contents/empty.js
@@ -0,0 +1,9 @@
+export default class CLASS extends GODOT_OBJECT_NAME.BASE {
+  // Declare member variables here. Examples:
+  a = 2;
+  b = "text";
+
+  constructor() {
+    super();
+  }
+}
diff --git a/register_types.cpp b/register_types.cpp
index 6dc37e74..f2f6d43b 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -1,10 +1,9 @@
 #include "register_types.h"
 
 #include "javascript.h"
-#include "javascript_language.h"
+#include "src/language/javascript_language.h"
 
 #ifdef TOOLS_ENABLED
-#include "core/io/file_access_encrypted.h"
 #include "editor/editor_node.h"
 #include "editor/editor_tools.h"
 #include "editor/export/editor_export.h"
@@ -20,7 +19,7 @@ class EditorExportJavaScript : public EditorExportPlugin {
 			return;
 		}
 	}
-	virtual String _get_name() const override { return "JavaScript"; }
+	virtual String _get_name() const override { return EXT_NAME; }
 };
 
 #endif
diff --git a/src/language/README.md b/src/language/README.md
new file mode 100644
index 00000000..ece05a07
--- /dev/null
+++ b/src/language/README.md
@@ -0,0 +1,31 @@
+# JavaScriptLanguage
+
+This class is a singleton which acts as a bridge between JavaScript (QuickJSBinder) and Godot Editor.
+
+It handles how the language is structured and how script files should be reloaded and created.
+
+## Unimplemented features
+
+> **Note:** Some features aren't fully implemented yet (marked with "\*\_todo\_\*".cpp)
+
+> - debugger
+> - doctools
+> - multithread
+> - profiling
+> - texteditor
+
+## Editor templates
+
+Furthermore, the singleton handles creation of new files via templates.
+
+The templates will be generated.
+To update or include new ones look at `misc/generate/templates.py` and `misc/template-contents/**`.
+
+The plain JS methods will be located inside `misc/template-contents/**`.
+You need to use `export default class CLASS extends GODOT_OBJECT_NAME.BASE` as class definition, those will be replaced on generation.
+
+Inside `misc/generate/templates.py` ou need to add a new template where you need to add some template name and description.
+
+If you want to add a new template you need to add the variable as well inside `src/language/templates/javascript_template_manager.h`, like
+`static ScriptLanguage::ScriptTemplate DEFAULT_TEMPLATE;`.
+And you need to append it into the `get_templates` function inside `src/language/templates/javascript_template_manager.cpp`.
diff --git a/src/language/javascript_instance_binding_callbacks.cpp b/src/language/javascript_instance_binding_callbacks.cpp
new file mode 100644
index 00000000..4484ed7b
--- /dev/null
+++ b/src/language/javascript_instance_binding_callbacks.cpp
@@ -0,0 +1,28 @@
+/* Instantiates global functions to allocate/free objets for godot */
+
+#include "javascript_language.h"
+
+void *JavaScriptLanguage::create_callback(void *p_token, void *p_instance) {
+	if (JavaScriptBinder *binder = get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		return binder->alloc_object_binding_data(static_cast<Object *>(p_instance));
+	}
+	return nullptr;
+}
+
+void JavaScriptLanguage::free_callback(void *p_token, void *p_instance, void *p_binding) {
+	if (JavaScriptBinder *binder = get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		return binder->free_object_binding_data(static_cast<JavaScriptGCHandler *>(p_binding));
+	}
+}
+
+GDExtensionBool JavaScriptLanguage::reference_callback(void *p_token, void *p_binding, GDExtensionBool p_reference) {
+	if (JavaScriptBinder *binder = get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		if (p_reference) {
+			binder->godot_refcount_incremented(static_cast<JavaScriptGCHandler *>(p_binding));
+			return false;
+		} else {
+			return binder->godot_refcount_decremented(static_cast<JavaScriptGCHandler *>(p_binding));
+		}
+	}
+	return true;
+}
diff --git a/src/language/javascript_language.cpp b/src/language/javascript_language.cpp
new file mode 100644
index 00000000..cb04aa96
--- /dev/null
+++ b/src/language/javascript_language.cpp
@@ -0,0 +1,100 @@
+/* This is the language server implementation. It handles how/when to use JS Scripts. */
+
+#include "core/io/file_access.h"
+#include "core/object/class_db.h"
+
+#include "../../thirdparty/quickjs/quickjs_binder.h"
+#include "javascript_language.h"
+
+JavaScriptLanguage *JavaScriptLanguage::singleton = nullptr;
+
+JavaScriptLanguage::JavaScriptLanguage() {
+	ERR_FAIL_COND(singleton);
+	singleton = this;
+	main_binder = memnew(QuickJSBinder);
+	callable_middleman = memnew(CallableMiddleman);
+	instance_binding_callbacks.create_callback = create_callback;
+	instance_binding_callbacks.free_callback = free_callback;
+	instance_binding_callbacks.reference_callback = reference_callback;
+}
+
+JavaScriptLanguage::~JavaScriptLanguage() {
+	memdelete(main_binder);
+	memdelete(callable_middleman);
+}
+
+void JavaScriptLanguage::init() {
+	ERR_FAIL_NULL(main_binder);
+	main_binder->initialize();
+}
+
+void JavaScriptLanguage::finish() {
+	ERR_FAIL_NULL(main_binder);
+	main_binder->uninitialize();
+	main_binder->language_finalize();
+}
+
+Error JavaScriptLanguage::execute_file(const String &code) {
+	ERR_FAIL_NULL_V(main_binder, ERR_BUG);
+	JavaScriptGCHandler eval_ret;
+	const Error err = main_binder->eval_string(code, JavaScriptBinder::EVAL_TYPE_GLOBAL, "test.js", eval_ret);
+	return err;
+}
+
+bool JavaScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptError> *r_errors, List<Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
+	JavaScriptError script_error;
+	const bool ret = main_binder->validate(p_script, p_path, &script_error);
+	if (!ret) {
+		ScriptError se;
+		se.line = script_error.line;
+		se.column = script_error.column;
+		se.message = script_error.message;
+		r_errors->push_back(se);
+	}
+	return ret;
+}
+
+Script *JavaScriptLanguage::create_script() const {
+	return memnew(JavaScript);
+}
+
+void JavaScriptLanguage::reload_all_scripts() {
+#ifdef TOOLS_ENABLED
+	for (const Ref<JavaScript> &s : scripts) {
+		reload_script(s, true);
+	}
+#endif
+}
+
+void JavaScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) { reload_script(p_script, p_soft_reload); }
+
+void JavaScriptLanguage::reload_script(const Ref<Script> &p_script, bool p_soft_reload) {
+	const Ref<JavaScript> s = p_script;
+	if (s.is_valid()) {
+		Error err = OK;
+		const Ref<JavaScriptModule> module = ResourceFormatLoaderJavaScriptModule::load_static(s->get_script_path(), "", &err);
+
+		if (err != ERR_FILE_NOT_FOUND) {
+			// We don't need to reload a script if it isn't existing
+
+			ERR_FAIL_COND_MSG(err != OK, ("Cannot reload script file '" + s->get_script_path() + "'."));
+			s->set_source_code(module->get_source_code());
+			err = s->reload(p_soft_reload);
+			ERR_FAIL_COND_MSG(err != OK, "Parse source code from file '" + s->get_script_path() + "' failed.");
+		} else {
+			// If we are in the editor we need to erase the script from the language server to avoid reload on focus (editor_tools.cpp[_notification()])
+#ifdef TOOLS_ENABLED
+			singleton->get_scripts().erase(s);
+#endif
+		}
+	}
+}
+
+void JavaScriptLanguage::frame() {
+	main_binder->frame();
+}
+
+// TODO
+void JavaScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) {}
+void JavaScriptLanguage::add_named_global_constant(const StringName &p_name, const Variant &p_value) {}
+void JavaScriptLanguage::remove_named_global_constant(const StringName &p_name) {}
diff --git a/javascript_language.h b/src/language/javascript_language.h
similarity index 53%
rename from javascript_language.h
rename to src/language/javascript_language.h
index 76f029c1..fab1026e 100644
--- a/javascript_language.h
+++ b/src/language/javascript_language.h
@@ -4,8 +4,8 @@
 
 #include "core/object/script_language.h"
 
-#include "javascript.h"
-#include "javascript_binder.h"
+#include "../../javascript.h"
+#include "../../javascript_binder.h"
 
 class CallableMiddleman : public Object {
 	GDCLASS(CallableMiddleman, Object);
@@ -31,6 +31,85 @@ class JavaScriptLanguage : public ScriptLanguage {
 #endif
 
 public:
+	/* LANGUAGE FUNCTIONS */
+	virtual String get_name() const override;
+	virtual String get_type() const override;
+	virtual String get_extension() const override;
+	virtual bool has_named_classes() const override;
+	virtual bool supports_builtin_mode() const override;
+	virtual void get_recognized_extensions(List<String> *p_extensions) const override;
+	virtual void get_reserved_words(List<String> *p_words) const override;
+	virtual bool is_control_flow_keyword(String p_keywords) const override;
+	virtual void get_comment_delimiters(List<String> *p_delimiters) const override;
+	virtual void get_string_delimiters(List<String> *p_delimiters) const override;
+
+	virtual void init() override;
+	virtual void finish() override;
+	virtual void frame() override;
+	virtual Script *create_script() const override;
+	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const override;
+	virtual void reload_all_scripts() override;
+	virtual void reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) override;
+
+	/**
+	 * Add a global before autoload
+	 * @param p_variable Name of the global constant
+	 * @param p_value Value of the global constant
+	 */
+	virtual void add_global_constant(const StringName &p_variable, const Variant &p_value) override;
+	virtual void add_named_global_constant(const StringName &p_name, const Variant &p_value) override;
+	virtual void remove_named_global_constant(const StringName &p_name) override;
+
+	/* TEXT EDITOR FUNCTIONS */
+	virtual int find_function(const String &p_function, const String &p_code) const override;
+	virtual String make_function(const String &p_class, const String &p_name, const PackedStringArray &p_args) const override;
+	virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const override;
+
+	virtual bool supports_documentation() const override;
+	virtual bool can_inherit_from_file() const override;
+	virtual Error open_in_external_editor(const Ref<Script> &p_script, int p_line, int p_col) override;
+	virtual bool overrides_external_editor() override;
+	virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<CodeCompletionOption> *r_options, bool &r_force, String &r_call_hint) override;
+	virtual Error lookup_code(const String &p_code, const String &p_symbol, const String &p_path, Object *p_owner, LookupResult &r_result) override;
+
+	/* SCRIPT GLOBAL CLASS FUNCTIONS */
+	/*TODO*/ virtual bool handles_global_class_type(const String &p_type) const override { return false; }
+	/*TODO*/ virtual String get_global_class_name(const String &p_path, String *r_base_type = NULL, String *r_icon_path = NULL) const override { return String(); }
+
+	/* DEBUGGER FUNCTIONS */
+	virtual String debug_get_error() const override;
+	virtual int debug_get_stack_level_count() const override;
+	virtual int debug_get_stack_level_line(int p_level) const override;
+	virtual String debug_get_stack_level_function(int p_level) const override;
+	virtual String debug_get_stack_level_source(int p_level) const override;
+	virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override;
+	virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override;
+	virtual void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override;
+	virtual String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) override;
+	virtual Vector<StackInfo> debug_get_current_stack_info() override;
+
+	/* MULTITHREAD FUNCTIONS */
+	virtual void thread_enter() override;
+	virtual void thread_exit() override;
+
+	/* TEMPLATE Functions */
+	virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const override;
+	virtual Vector<ScriptTemplate> get_built_in_templates(StringName p_object) override;
+	virtual bool is_using_templates() override;
+
+	/* DOCTOOL FUNCTIONS */
+	virtual void get_public_functions(List<MethodInfo> *p_functions) const override;
+	virtual void get_public_constants(List<Pair<String, Variant>> *p_constants) const override;
+	virtual void get_public_annotations(List<MethodInfo> *p_annotations) const override;
+
+	/* Profiling Functions */
+	virtual void profiling_start() override;
+	virtual void profiling_stop() override;
+
+	virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) override;
+	virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) override;
+
+	/* ----------- Custom Functions ----------- */
 	_FORCE_INLINE_ static JavaScriptLanguage *get_singleton() { return singleton; }
 	_FORCE_INLINE_ static JavaScriptBinder *get_main_binder() { return singleton->main_binder; }
 	_FORCE_INLINE_ static JavaScriptBinder *get_thread_binder(Thread::ID p_id) {
@@ -39,23 +118,15 @@ class JavaScriptLanguage : public ScriptLanguage {
 		}
 		return nullptr;
 	}
-
-	_FORCE_INLINE_ CallableMiddleman *get_callable_middleman() const {
-		return callable_middleman;
-	}
-
-	_FORCE_INLINE_ virtual String get_name() const override { return "JavaScript"; }
+	_FORCE_INLINE_ CallableMiddleman *get_callable_middleman() const { return callable_middleman; }
 	const GDExtensionInstanceBindingCallbacks *get_instance_binding_callbacks() const { return &instance_binding_callbacks; }
-#ifdef TOOLS_ENABLED
-	_FORCE_INLINE_ HashSet<Ref<JavaScript>> &get_scripts() { return scripts; }
-#endif
-	/* LANGUAGE FUNCTIONS */
 
-	_FORCE_INLINE_ virtual String get_type() const override { return "JavaScript"; }
-	_FORCE_INLINE_ virtual String get_extension() const override { return EXT_JSCLASS; }
-
-	virtual void init() override;
-	virtual void finish() override;
+	/**
+	 * Helper function to reload a single script
+	 * @param p_script Pointer to the JS script
+	 * @param p_soft_reload Pointer to boolean if script should be soft reloaded
+	 */
+	static void reload_script(const Ref<Script> &p_script, bool p_soft_reload);
 
 	/**
 	 * Executes a js file with JavaScriptBinder - currently used via init() for testing the editor in cicd
@@ -64,67 +135,35 @@ class JavaScriptLanguage : public ScriptLanguage {
 	 */
 	virtual Error execute_file(const String &code);
 
-	virtual void get_reserved_words(List<String> *p_words) const override;
-	virtual bool is_control_flow_keyword(String p_keywords) const override;
-	virtual void get_comment_delimiters(List<String> *p_delimiters) const override;
-	virtual void get_string_delimiters(List<String> *p_delimiters) const override;
-
-	virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const override;
-	virtual Vector<ScriptTemplate> get_built_in_templates(StringName p_object) override;
-	virtual bool is_using_templates() override { return true; }
-
-	virtual Script *create_script() const override;
-	_FORCE_INLINE_ virtual bool has_named_classes() const override { return true; }
-	_FORCE_INLINE_ virtual bool supports_builtin_mode() const override { return false; }
-
-	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const override;
-
-	virtual int find_function(const String &p_function, const String &p_code) const override { return -1; }
-	virtual String make_function(const String &p_class, const String &p_name, const PackedStringArray &p_args) const override { return ""; }
-
-	virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const override {}
-	virtual void add_global_constant(const StringName &p_variable, const Variant &p_value) override {}
-
-	virtual void thread_enter() override {}
-	virtual void thread_exit() override {}
-
-	/* DEBUGGER FUNCTIONS */
-
-	/* DEBUGGER FUNCTIONS */
-	virtual String debug_get_error() const override { return ""; }
-	virtual int debug_get_stack_level_count() const override { return 1; }
-	virtual int debug_get_stack_level_line(int p_level) const override { return 1; }
-	virtual String debug_get_stack_level_function(int p_level) const override { return ""; }
-	virtual String debug_get_stack_level_source(int p_level) const override { return ""; }
-	virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
-	virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
-	virtual void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
-	virtual String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) override { return ""; }
-	virtual Vector<StackInfo> debug_get_current_stack_info() override { return Vector<StackInfo>(); }
-
-	void reload_script(const Ref<Script> &p_script, bool p_soft_reload);
-
-	virtual void reload_all_scripts() override;
-	virtual void reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) override { reload_script(p_script, p_soft_reload); }
-
-	/* LOADER FUNCTIONS */
-	virtual void get_recognized_extensions(List<String> *p_extensions) const override;
-	virtual void get_public_functions(List<MethodInfo> *p_functions) const override {}
-	virtual void get_public_constants(List<Pair<String, Variant>> *p_constants) const override {}
-	virtual void get_public_annotations(List<MethodInfo> *p_annotations) const override{};
-
-	virtual void profiling_start() override {}
-	virtual void profiling_stop() override {}
-
-	virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) override { return -1; }
-	virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) override { return -1; }
+	/* Instance Binding Callbacks*/
+	/**
+	 * Allocates space for a new object created in binders
+	 * @param p_token Not required for js
+	 * @param p_instance Pointer to the js object
+	 * @return Pointer to the bound obj
+	 */
+	static void *create_callback(void *p_token, void *p_instance);
 
-	virtual void frame() override;
+	/**
+	 * Frees space for an object created by binders
+	 * @param p_token Not required for js
+	 * @param p_instance Not required for js
+	 * @param p_binding Pointer returned by create_callback
+	 */
+	static void free_callback(void *p_token, void *p_instance, void *p_binding);
 
-	virtual bool handles_global_class_type(const String &p_type) const override { return false; }
-	virtual String get_global_class_name(const String &p_path, String *r_base_type = NULL, String *r_icon_path = NULL) const override { return String(); }
+	/**
+	 *
+	 * @param p_token Not required for js
+	 * @param p_binding Pointer returned by create_callback
+	 * @param p_reference A boolean to increase/decrease the ref_count for godot
+	 * @return Successful increase or decrease
+	 */
+	static GDExtensionBool reference_callback(void *p_token, void *p_binding, GDExtensionBool p_reference);
 
-	static String globalize_relative_path(const String &p_relative, const String &p_base_dir);
+#ifdef TOOLS_ENABLED
+	_FORCE_INLINE_ HashSet<Ref<JavaScript>> &get_scripts() { return scripts; }
+#endif
 
 	JavaScriptLanguage();
 	virtual ~JavaScriptLanguage();
diff --git a/src/language/javascript_language_definitions.cpp b/src/language/javascript_language_definitions.cpp
new file mode 100644
index 00000000..270f38d6
--- /dev/null
+++ b/src/language/javascript_language_definitions.cpp
@@ -0,0 +1,166 @@
+/* Instantiates definition functions for javascript language */
+
+#include "javascript_language.h"
+
+String JavaScriptLanguage::get_name() const { return EXT_NAME; }
+String JavaScriptLanguage::get_type() const { return EXT_NAME; }
+String JavaScriptLanguage::get_extension() const { return EXT_JSCLASS; }
+bool JavaScriptLanguage::has_named_classes() const { return true; }
+bool JavaScriptLanguage::supports_builtin_mode() const { return false; }
+
+void JavaScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
+	p_extensions->push_back(EXT_JSMODULE);
+	p_extensions->push_back(EXT_JSCLASS);
+	p_extensions->push_back(EXT_JSON);
+}
+
+bool JavaScriptLanguage::is_control_flow_keyword(String p_keyword) const {
+	return p_keyword == "if" ||
+			p_keyword == "else" ||
+			p_keyword == "return" ||
+			p_keyword == "do" ||
+			p_keyword == "while" ||
+			p_keyword == "for" ||
+			p_keyword == "break" ||
+			p_keyword == "continue" ||
+			p_keyword == "switch" ||
+			p_keyword == "case" ||
+			p_keyword == "throw" ||
+			p_keyword == "try" ||
+			p_keyword == "catch" ||
+			p_keyword == "finally";
+}
+
+void JavaScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
+	p_delimiters->push_back("//"); // single-line comment
+	p_delimiters->push_back("/* */"); // delimited comment
+}
+
+void JavaScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
+	p_delimiters->push_back("' '");
+	p_delimiters->push_back("\" \"");
+	p_delimiters->push_back("` `");
+}
+
+void JavaScriptLanguage::get_reserved_words(List<String> *p_words) const {
+	static const char *_reserved_words[] = {
+		"null",
+		"false",
+		"true",
+		"if",
+		"else",
+		"return",
+		"var",
+		"this",
+		"delete",
+		"void",
+		"typeof",
+		"new",
+		"in",
+		"instanceof",
+		"do",
+		"while",
+		"for",
+		"break",
+		"continue",
+		"switch",
+		"case",
+		"default",
+		"throw",
+		"try",
+		"catch",
+		"finally",
+		"function",
+		"debugger",
+		"with",
+		"class",
+		"const",
+		"enum",
+		"export",
+		"default",
+		"extends",
+		"import",
+		"super",
+		"implements",
+		"interface",
+		"let",
+		"package",
+		"private",
+		"protected",
+		"public",
+		"static",
+		"yield",
+		"await",
+		"prototype",
+		"constructor",
+		"get",
+		"set",
+		"of",
+		"__proto__",
+		"undefined",
+		"number",
+		"boolean",
+		"string",
+		"object",
+		"symbol",
+		"arguments",
+		"join",
+		"global",
+		"as",
+		"from",
+		"default",
+		"*",
+		"then",
+		"resolve",
+		"reject",
+		"promise",
+		"proxy",
+		"revoke",
+		"async",
+		"globalThis",
+		"Object",
+		"Array",
+		"Error",
+		"Number",
+		"String",
+		"Boolean",
+		"Symbol",
+		"Arguments",
+		"Math",
+		"JSON",
+		"Date",
+		"Function",
+		"GeneratorFunction",
+		"ForInIterator",
+		"RegExp",
+		"ArrayBuffer",
+		"SharedArrayBuffer",
+		"Uint8ClampedArray",
+		"Int8Array",
+		"Uint8Array",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"BigInt64Array",
+		"BigUint64Array",
+		"Float32Array",
+		"Float64Array",
+		"DataView",
+		"Map",
+		"Set",
+		"WeakMap",
+		"WeakSet",
+		"Generator",
+		"Proxy",
+		"Promise",
+		0
+	};
+
+	const char **w = _reserved_words;
+
+	while (*w) {
+		p_words->push_back(*w);
+		w++;
+	}
+}
diff --git a/src/language/javascript_templates.cpp b/src/language/javascript_templates.cpp
new file mode 100644
index 00000000..5c362aa8
--- /dev/null
+++ b/src/language/javascript_templates.cpp
@@ -0,0 +1,29 @@
+/* Instantiates template functions for godot editor */
+
+#include "javascript_language.h"
+#include "templates/javascript_template_manager.h"
+
+Ref<Script> JavaScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
+	Ref<JavaScript> javaScript;
+	javaScript.instantiate();
+	const String src = p_template.replace("BASE", p_base_class_name).replace("CLASS", p_class_name);
+	javaScript->set_source_code(src);
+	return javaScript;
+}
+
+Vector<ScriptLanguage::ScriptTemplate> JavaScriptLanguage::get_built_in_templates(const StringName p_object) {
+	Vector<ScriptTemplate> templates;
+#ifdef TOOLS_ENABLED
+	const Vector<ScriptTemplate> all_templates = JavaScriptLanguageManager::get_templates();
+
+	for (int i = 0; i < all_templates.size(); i++) {
+		if (all_templates[i].inherit == p_object) {
+			templates.append(all_templates[i]);
+		}
+	}
+#endif
+
+	return templates;
+}
+
+bool JavaScriptLanguage::is_using_templates() { return true; }
diff --git a/src/language/javascript_todo_debugger.cpp b/src/language/javascript_todo_debugger.cpp
new file mode 100644
index 00000000..0965b44a
--- /dev/null
+++ b/src/language/javascript_todo_debugger.cpp
@@ -0,0 +1,14 @@
+/* Instantiates debugger functions for godot editor */
+
+#include "javascript_language.h"
+
+String JavaScriptLanguage::debug_get_error() const { return ""; }
+int JavaScriptLanguage::debug_get_stack_level_count() const { return 1; }
+int JavaScriptLanguage::debug_get_stack_level_line(int p_level) const { return 1; }
+String JavaScriptLanguage::debug_get_stack_level_function(int p_level) const { return ""; }
+String JavaScriptLanguage::debug_get_stack_level_source(int p_level) const { return ""; }
+void JavaScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {}
+void JavaScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {}
+void JavaScriptLanguage::debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {}
+String JavaScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) { return ""; }
+Vector<ScriptLanguage::StackInfo> JavaScriptLanguage::debug_get_current_stack_info() { return Vector<StackInfo>(); }
diff --git a/src/language/javascript_todo_doctools.cpp b/src/language/javascript_todo_doctools.cpp
new file mode 100644
index 00000000..75902767
--- /dev/null
+++ b/src/language/javascript_todo_doctools.cpp
@@ -0,0 +1,7 @@
+/* Instantiates profiling functions for godot editor */
+
+#include "javascript_language.h"
+
+void JavaScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const {}
+void JavaScriptLanguage::get_public_constants(List<Pair<String, Variant>> *p_constants) const {}
+void JavaScriptLanguage::get_public_annotations(List<MethodInfo> *p_annotations) const {};
\ No newline at end of file
diff --git a/src/language/javascript_todo_multithread.cpp b/src/language/javascript_todo_multithread.cpp
new file mode 100644
index 00000000..95b8bd10
--- /dev/null
+++ b/src/language/javascript_todo_multithread.cpp
@@ -0,0 +1,6 @@
+/* Instantiates multi-thread functions for godot editor */
+
+#include "javascript_language.h"
+
+void JavaScriptLanguage::thread_enter() {}
+void JavaScriptLanguage::thread_exit() {}
\ No newline at end of file
diff --git a/src/language/javascript_todo_profiling.cpp b/src/language/javascript_todo_profiling.cpp
new file mode 100644
index 00000000..09876d35
--- /dev/null
+++ b/src/language/javascript_todo_profiling.cpp
@@ -0,0 +1,8 @@
+/* Instantiates profiling functions for godot editor */
+#include "javascript_language.h"
+
+void JavaScriptLanguage::profiling_start() {}
+void JavaScriptLanguage::profiling_stop() {}
+
+int JavaScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) { return -1; }
+int JavaScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) { return -1; }
diff --git a/src/language/javascript_todo_texteditor.cpp b/src/language/javascript_todo_texteditor.cpp
new file mode 100644
index 00000000..c8d2dec1
--- /dev/null
+++ b/src/language/javascript_todo_texteditor.cpp
@@ -0,0 +1,14 @@
+/* Instantiates debugger functions for godot editor */
+
+#include "javascript_language.h"
+
+int JavaScriptLanguage::find_function(const String &p_function, const String &p_code) const { return -1; }
+String JavaScriptLanguage::make_function(const String &p_class, const String &p_name, const PackedStringArray &p_args) const { return ""; }
+void JavaScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_to_line) const {}
+
+bool JavaScriptLanguage::supports_documentation() const { return false; }
+bool JavaScriptLanguage::can_inherit_from_file() const { return false; }
+Error JavaScriptLanguage::open_in_external_editor(const Ref<Script> &p_script, int p_line, int p_col) { return ERR_UNAVAILABLE; }
+bool JavaScriptLanguage::overrides_external_editor() { return false; }
+Error JavaScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_force, String &r_call_hint) { return ERR_UNAVAILABLE; }
+Error JavaScriptLanguage::lookup_code(const String &p_code, const String &p_symbol, const String &p_path, Object *p_owner, ScriptLanguage::LookupResult &r_result) { return ERR_UNAVAILABLE; }
diff --git a/src/language/templates/javascript_template_manager.cpp b/src/language/templates/javascript_template_manager.cpp
new file mode 100644
index 00000000..6f9cea89
--- /dev/null
+++ b/src/language/templates/javascript_template_manager.cpp
@@ -0,0 +1,8 @@
+#include "javascript_template_manager.h"
+
+Vector<ScriptLanguage::ScriptTemplate> JavaScriptLanguageManager::get_templates() {
+	Vector<ScriptLanguage::ScriptTemplate> templates;
+	templates.append(JavaScriptLanguageManager::DEFAULT_TEMPLATE);
+	templates.append(JavaScriptLanguageManager::EMPTY_TEMPLATE);
+	return templates;
+};
\ No newline at end of file
diff --git a/src/language/templates/javascript_template_manager.h b/src/language/templates/javascript_template_manager.h
new file mode 100644
index 00000000..debc9de4
--- /dev/null
+++ b/src/language/templates/javascript_template_manager.h
@@ -0,0 +1,15 @@
+
+#ifndef JAVASCRIPT_TEMPLATE_MANAGER_H
+#define JAVASCRIPT_TEMPLATE_MANAGER_H
+
+#include "../javascript_language.h"
+
+class JavaScriptLanguageManager {
+public:
+	static ScriptLanguage::ScriptTemplate DEFAULT_TEMPLATE;
+	static ScriptLanguage::ScriptTemplate EMPTY_TEMPLATE;
+
+	static Vector<ScriptLanguage::ScriptTemplate> get_templates();
+};
+
+#endif //JAVASCRIPT_TEMPLATE_MANAGER_H
diff --git a/tests/test_javascript.h b/tests/test_javascript.h
index ebb43674..75e0a57e 100644
--- a/tests/test_javascript.h
+++ b/tests/test_javascript.h
@@ -2,7 +2,7 @@
 #ifndef TEST_JAVASCRIPT_H
 #define TEST_JAVASCRIPT_H
 
-#include "../javascript_language.h"
+#include "../src/language/javascript_language.h"
 #include "../src/tests/test_manager.h"
 
 #include "tests/test_macros.h"
@@ -11,7 +11,7 @@ namespace JavaScriptTests {
 
 TEST_CASE("[JavaScript] Test all") {
 	JavaScriptLanguage::get_singleton()->init();
-	String code = TestManager::UNIT_TEST;
+	const String code = TestManager::UNIT_TEST;
 	Error err = JavaScriptLanguage::get_singleton()->execute_file(code);
 	CHECK(err == OK);
 }
diff --git a/thirdparty/quickjs/quickjs_binder.cpp b/thirdparty/quickjs/quickjs_binder.cpp
index 7126ea81..37675525 100644
--- a/thirdparty/quickjs/quickjs_binder.cpp
+++ b/thirdparty/quickjs/quickjs_binder.cpp
@@ -12,7 +12,7 @@
 #endif
 
 #include "../../javascript_instance.h"
-#include "../../javascript_language.h"
+#include "../../src/language/javascript_language.h"
 #include "quickjs_binder.h"
 #include "quickjs_callable.h"
 #include "quickjs_worker.h"
diff --git a/thirdparty/quickjs/quickjs_callable.cpp b/thirdparty/quickjs/quickjs_callable.cpp
index ea34638e..03142bab 100644
--- a/thirdparty/quickjs/quickjs_callable.cpp
+++ b/thirdparty/quickjs/quickjs_callable.cpp
@@ -1,6 +1,6 @@
 #include "quickjs_callable.h"
 #include "quickjs_binder.h"
-#include "../../javascript_language.h"
+#include "../../src/language/javascript_language.h"
 #include "quickjs/quickjs.h"
 
 bool QuickJSCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {