diff --git a/.gitignore b/.gitignore
index 0ced08ee..574cea29 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,6 +21,7 @@ __MACOSX
 # auto-generated sources
 /jsb.gen.h
 /jsb_project_preset.gen.cpp
-/weaver-editor/templates/templates.gen.h
+/weaver-editor/templates/templates.ts.gen.h
+/weaver-editor/templates/templates.js.gen.h
 
 .vscode
diff --git a/bridge/jsb_class_info.cpp b/bridge/jsb_class_info.cpp
index 4a67de16..ae39805e 100644
--- a/bridge/jsb_class_info.cpp
+++ b/bridge/jsb_class_info.cpp
@@ -238,7 +238,7 @@ namespace jsb
     void ScriptClassInfo::instantiate(const StringName& p_module_id, const v8::Local<v8::Object>& p_self)
     {
         const String source_path = internal::PathUtil::convert_javascript_path(p_module_id);
-        const Ref<GodotJSScript> script = ResourceLoader::load(source_path);
+        const Ref<GodotJSScriptBase> script = ResourceLoader::load(source_path);
         if (script.is_valid())
         {
             jsb_unused(script->can_instantiate()); // make it loaded immediately
diff --git a/internal/jsb_string_names.h b/internal/jsb_string_names.h
index bb0bf703..ec3c03ec 100644
--- a/internal/jsb_string_names.h
+++ b/internal/jsb_string_names.h
@@ -6,22 +6,24 @@
 #define jsb_string_name(name) ::jsb::internal::StringNames::get_singleton().sn_##name
 #define jsb_literal(name) (sizeof(::jsb::internal::StringNames::sn_##name) == sizeof(StringName), #name)
 
-class GodotJSScriptLanguage;
+class GodotJSScriptLanguageBase;
 
 namespace jsb::internal
 {
     class StringNames
     {
     private:
-        friend class ::GodotJSScriptLanguage;
+        friend class ::GodotJSScriptLanguageBase;
 
         static StringNames* singleton_;
 
         static void create() { singleton_ = memnew(StringNames); }
         static void free()
         {
-            memdelete(singleton_);
-            singleton_ = nullptr;
+            if (singleton_) {
+                memdelete(singleton_);
+                singleton_ = nullptr;
+            }
         }
 
         // we need to ignore some names used in godot (such as XXX.name) to avoid conflicts in javascript.
diff --git a/register_types.cpp b/register_types.cpp
index 17b55ad4..2b6069a9 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -1,6 +1,8 @@
 #include "register_types.h"
 
 #include "weaver/jsb_script_language.h"
+#include "weaver/jsb_script_language_ts.h"
+#include "weaver/jsb_script_language_js.h"
 #include "weaver/jsb_script.h"
 #include "weaver/jsb_resource_loader.h"
 #include "weaver/jsb_resource_saver.h"
@@ -12,35 +14,39 @@
 #include "weaver-editor/jsb_export_plugin.h"
 #endif
 
-static Ref<ResourceFormatLoaderGodotJSScript> resource_loader_js;
-static Ref<ResourceFormatSaverGodotJSScript> resource_saver_js;
+static Ref<ResourceFormatLoaderGodotJSScript> resource_loader;
+static Ref<ResourceFormatSaverGodotJSScript> resource_saver;
 
 void jsb_initialize_module(ModuleInitializationLevel p_level)
 {
     if (p_level == MODULE_INITIALIZATION_LEVEL_SERVERS)
     {
         GDREGISTER_CLASS(GodotJSScript);
+        GDREGISTER_CLASS(GodotJavaScript);
 
         jsb::impl::GlobalInitialize::init();
 
         // register javascript language
-        GodotJSScriptLanguage* script_language_js = memnew(GodotJSScriptLanguage());
-        ScriptServer::register_language(script_language_js);
+        ScriptServer::register_language(GodotJSScriptLanguage::create_singleton());
+        ScriptServer::register_language(GodotJavascriptLanguage::create_singleton());
 
-        resource_loader_js.instantiate();
-        ResourceLoader::add_resource_format_loader(resource_loader_js);
+        resource_loader.instantiate();
+        resource_loader->register_resource_extension(JSB_TYPESCRIPT_EXT, GodotJSScriptLanguage::get_singleton());
+        resource_loader->register_resource_extension(JSB_JAVASCRIPT_EXT, GodotJavascriptLanguage::get_singleton());
+        ResourceLoader::add_resource_format_loader(resource_loader);
+
+        resource_saver.instantiate();
+        ResourceSaver::add_resource_format_saver(resource_saver);
 
-        resource_saver_js.instantiate();
-        ResourceSaver::add_resource_format_saver(resource_saver_js);
 
 #ifdef TOOLS_ENABLED
         EditorNode::add_init_callback([]
         {
-            GodotJSEditorPlugin* plugin = memnew(GodotJSEditorPlugin);
+            GodotJSEditorPlugin* plugin = memnew(GodotJSEditorPlugin(GodotJSScriptLanguage::get_singleton()));
             EditorNode::add_editor_plugin(plugin);
 
             Ref<GodotJSExportPlugin> exporter;
-            exporter.instantiate();
+            exporter.instantiate(GodotJSScriptLanguage::get_singleton()->get_environment());
             EditorExport::get_singleton()->add_export_plugin(exporter);
 
             plugin->set_name(jsb_typename(GodotJSEditorPlugin));
@@ -53,15 +59,17 @@ void jsb_uninitialize_module(ModuleInitializationLevel p_level)
 {
     if (p_level == MODULE_INITIALIZATION_LEVEL_CORE)
     {
-        ResourceLoader::remove_resource_format_loader(resource_loader_js);
-        resource_loader_js.unref();
+        ResourceLoader::remove_resource_format_loader(resource_loader);
+        resource_loader.unref();
+
+        ResourceSaver::remove_resource_format_saver(resource_saver);
+        resource_saver.unref();
+
+        ScriptServer::unregister_language(GodotJSScriptLanguage::get_singleton());
+        GodotJSScriptLanguage::destroy_singleton();
 
-        ResourceSaver::remove_resource_format_saver(resource_saver_js);
-        resource_saver_js.unref();
+        ScriptServer::unregister_language(GodotJavascriptLanguage::get_singleton());
+        GodotJavascriptLanguage::destroy_singleton();
 
-        GodotJSScriptLanguage *script_language_js = GodotJSScriptLanguage::get_singleton();
-        jsb_check(script_language_js);
-        ScriptServer::unregister_language(script_language_js);
-        memdelete(script_language_js);
     }
 }
diff --git a/weaver-editor/icons/GodotJavaScript.svg b/weaver-editor/icons/GodotJavaScript.svg
new file mode 100644
index 00000000..a00f06f6
--- /dev/null
+++ b/weaver-editor/icons/GodotJavaScript.svg
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo
+Mixer Tools -->
+
+<svg
+   width="16px"
+   height="16px"
+   viewBox="0 0 32 32"
+   version="1.1"
+   id="svg1"
+   sodipodi:docname="JavaScript.svg"
+   inkscape:version="1.4 (e7c3feb100, 2024-10-09)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs1" />
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:zoom="9.1923881"
+     inkscape:cx="4.786569"
+     inkscape:cy="10.062673"
+     inkscape:window-width="1920"
+     inkscape:window-height="1214"
+     inkscape:window-x="0"
+     inkscape:window-y="29"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg1" />
+  <title
+     id="title1">file_type_typescript_official</title>
+  <rect
+     x="2"
+     y="2"
+     width="28"
+     height="28"
+     rx="1.312"
+     style="fill:#3178c6"
+     id="rect1" />
+  <path
+     style="font-weight:bold;font-size:18.6667px;font-family:'Liberation Sans';-inkscape-font-specification:'Liberation Sans Bold';fill:#ffffff;stroke-width:2"
+     d="m 11.303191,28.24899 q -1.996097,0 -3.0716197,-0.865887 -1.0664082,-0.865887 -1.4218776,-2.798182 l 2.6705777,-0.391928 q 0.1640628,0.993492 0.6106786,1.476565 0.446615,0.47396 1.230471,0.47396 0.802084,0 1.212241,-0.537762 0.419272,-0.537761 0.419272,-1.540367 V 17.3297 h -2.561203 v -2.105473 h 5.240895 v 8.77736 q 0,2.005212 -1.139325,3.126307 -1.139325,1.121096 -3.19011,1.121096 z m 17.326854,-3.882819 q 0,1.886722 -1.403648,2.889328 -1.394534,0.993491 -4.10157,0.993491 -2.470057,0 -3.873705,-0.875002 -1.403648,-0.875001 -1.804691,-2.652348 l 2.597661,-0.428386 q 0.264324,1.020835 1.02995,1.48568 0.765626,0.45573 2.123702,0.45573 2.816411,0 2.816411,-1.713545 0,-0.546876 -0.328125,-0.902346 -0.319011,-0.355469 -0.91146,-0.592449 -0.583335,-0.236979 -2.251307,-0.574219 -1.440106,-0.337241 -2.005212,-0.537762 -0.565105,-0.209636 -1.020835,-0.483074 -0.45573,-0.282552 -0.774741,-0.67448 -0.319011,-0.391928 -0.501303,-0.920575 -0.173177,-0.528646 -0.173177,-1.212241 0,-1.740889 1.303388,-2.661463 1.312502,-0.92969 3.809902,-0.92969 2.388026,0 3.582038,0.747398 1.203127,0.747397 1.549482,2.470056 l -2.606775,0.355469 q -0.200522,-0.829428 -0.820314,-1.2487 -0.610679,-0.419271 -1.759118,-0.419271 -2.442713,0 -2.442713,1.531252 0,0.501303 0.255209,0.820314 0.264323,0.319011 0.774741,0.546876 0.510417,0.218751 2.069014,0.555991 1.850264,0.391928 2.643234,0.729168 0.802085,0.328126 1.266929,0.774741 0.464845,0.437501 0.710939,1.057294 0.246094,0.610678 0.246094,1.412763 z"
+     id="text1"
+     aria-label="JS" />
+</svg>
diff --git a/weaver-editor/jsb_editor_pch.h b/weaver-editor/jsb_editor_pch.h
index 3298b73b..7e0f9a32 100644
--- a/weaver-editor/jsb_editor_pch.h
+++ b/weaver-editor/jsb_editor_pch.h
@@ -14,6 +14,7 @@
 #include "../internal/jsb_settings.h"
 
 #include "../weaver/jsb_script_language.h"
+#include "../weaver/jsb_script_language_ts.h"
 
 #if GODOT_4_3_OR_NEWER
 #   include "editor/plugins/editor_plugin.h"
diff --git a/weaver-editor/jsb_editor_plugin.cpp b/weaver-editor/jsb_editor_plugin.cpp
index bf1ccde8..cf693800 100644
--- a/weaver-editor/jsb_editor_plugin.cpp
+++ b/weaver-editor/jsb_editor_plugin.cpp
@@ -41,7 +41,7 @@ void GodotJSEditorPlugin::_notification(int p_what)
     switch (p_what)
     {
     case NOTIFICATION_APPLICATION_FOCUS_IN:
-        if (GodotJSScriptLanguage* lang = GodotJSScriptLanguage::get_singleton())
+        if (GodotJSScriptLanguage* lang = lang_)
         {
             lang->scan_external_changes();
         }
@@ -61,7 +61,7 @@ void GodotJSEditorPlugin::_on_menu_pressed(int p_what)
     }
 }
 
-GodotJSEditorPlugin::GodotJSEditorPlugin()
+GodotJSEditorPlugin::GodotJSEditorPlugin(GodotJSScriptLanguage * lang) : lang_(lang)
 {
     // jsb::internal::Settings::on_editor_init();
     PopupMenu *menu = memnew(PopupMenu);
@@ -369,7 +369,7 @@ void GodotJSEditorPlugin::generate_godot_dts()
         install_files(filter_files(editor_plugin->install_files_, jsb::weaver::CH_D_TS));
     }
 
-    GodotJSScriptLanguage* lang = GodotJSScriptLanguage::get_singleton();
+    GodotJSScriptLanguage * lang = get_singleton()->lang_;
     jsb_check(lang);
     Error err;
     const String code = jsb_format(R"--((function(){const mod = require("jsb.editor.codegen"); (new mod.default("%s")).emit();})())--", "./" JSB_TYPE_ROOT);
@@ -382,7 +382,7 @@ void GodotJSEditorPlugin::generate_godot_dts()
 
 void GodotJSEditorPlugin::load_editor_entry_module()
 {
-    GodotJSScriptLanguage* lang = GodotJSScriptLanguage::get_singleton();
+    GodotJSScriptLanguage * lang = get_singleton()->lang_;
     jsb_check(lang);
     const Error err = lang->get_environment()->load("jsb.editor.main");
     ERR_FAIL_COND_MSG(err != OK, "failed to evaluate jsb.editor.main");
@@ -458,7 +458,7 @@ GodotJSEditorPlugin* GodotJSEditorPlugin::get_singleton()
 
 void GodotJSEditorPlugin::ensure_tsc_installed()
 {
-    GodotJSScriptLanguage* lang = GodotJSScriptLanguage::get_singleton();
+    GodotJSScriptLanguage * lang = get_singleton()->lang_;
     jsb_check(lang);
 
     Error err;
diff --git a/weaver-editor/jsb_editor_plugin.h b/weaver-editor/jsb_editor_plugin.h
index 9d389f2e..4b92f930 100644
--- a/weaver-editor/jsb_editor_plugin.h
+++ b/weaver-editor/jsb_editor_plugin.h
@@ -53,6 +53,8 @@ class GodotJSEditorPlugin : public EditorPlugin
 
     std::shared_ptr<jsb::internal::Process> tsc_;
 
+    GodotJSScriptLanguage * lang_;
+
 protected:
     static void _bind_methods();
 
@@ -70,9 +72,11 @@ class GodotJSEditorPlugin : public EditorPlugin
     static bool delete_file(const String& p_file);
 
 public:
-    GodotJSEditorPlugin();
+    GodotJSEditorPlugin(GodotJSScriptLanguage * lang_);
     virtual ~GodotJSEditorPlugin() override;
 
+    GodotJSScriptLanguage * get_lang() const { return lang_; }
+
     void start_tsc_watch();
     bool is_tsc_watching();
     void kill_tsc();
diff --git a/weaver-editor/jsb_export_plugin.cpp b/weaver-editor/jsb_export_plugin.cpp
index b98cd479..1495e23a 100644
--- a/weaver-editor/jsb_export_plugin.cpp
+++ b/weaver-editor/jsb_export_plugin.cpp
@@ -2,14 +2,13 @@
 
 #define JSB_EXPORTER_LOG(Severity, Format, ...) JSB_LOG_IMPL(JSExporter, Severity, Format, ##__VA_ARGS__)
 
-GodotJSExportPlugin::GodotJSExportPlugin() : super()
+GodotJSExportPlugin::GodotJSExportPlugin(std::shared_ptr<jsb::Environment> & env) : super(), env_(env)
 {
     // explicitly ignored files (not used by runtime)
     ignored_paths_.insert("res://jsconfig.json");
     ignored_paths_.insert("res://tsconfig.json");
     ignored_paths_.insert("res://package.json");
     ignored_paths_.insert("res://package-lock.json");
-    env_ = GodotJSScriptLanguage::get_singleton()->get_environment();
     jsb_check(env_);
 }
 
diff --git a/weaver-editor/jsb_export_plugin.h b/weaver-editor/jsb_export_plugin.h
index c9c9f93c..e0baf787 100644
--- a/weaver-editor/jsb_export_plugin.h
+++ b/weaver-editor/jsb_export_plugin.h
@@ -15,7 +15,7 @@ class GodotJSExportPlugin: public EditorExportPlugin
     GDCLASS(GodotJSExportPlugin, EditorExportPlugin)
 
 public:
-    GodotJSExportPlugin();
+    GodotJSExportPlugin(std::shared_ptr<jsb::Environment> & env);
     virtual String get_name() const override;
     virtual bool supports_platform(const Ref<EditorExportPlatform>& p_export_platform) const override;
 
diff --git a/weaver-editor/jsb_repl.cpp b/weaver-editor/jsb_repl.cpp
index 47c464df..bbbaf089 100644
--- a/weaver-editor/jsb_repl.cpp
+++ b/weaver-editor/jsb_repl.cpp
@@ -174,7 +174,7 @@ void GodotJSREPL::check_install()
 
 void GodotJSREPL::_gc_pressed()
 {
-    GodotJSScriptLanguage* lang = GodotJSScriptLanguage::get_singleton();
+    GodotJSScriptLanguage* lang = GodotJSEditorPlugin::get_singleton()->get_lang();
     jsb_check(lang);
     lang->get_environment()->gc();
     add_line("Explicit GC requested");
@@ -301,7 +301,7 @@ void GodotJSREPL::_input_submitted(const String &p_text)
 
 jsb::JSValueMove GodotJSREPL::eval_source(const String& p_code)
 {
-    GodotJSScriptLanguage* lang = GodotJSScriptLanguage::get_singleton();
+    GodotJSScriptLanguage* lang = GodotJSEditorPlugin::get_singleton()->get_lang();
     jsb_check(lang);
     Error err;
     return lang->eval_source(p_code, err);
diff --git a/weaver-editor/jsb_statistics_viewer.cpp b/weaver-editor/jsb_statistics_viewer.cpp
index 501bdaec..211bbf41 100644
--- a/weaver-editor/jsb_statistics_viewer.cpp
+++ b/weaver-editor/jsb_statistics_viewer.cpp
@@ -1,5 +1,6 @@
 #include "jsb_statistics_viewer.h"
 #include "jsb_editor_pch.h"
+#include "jsb_editor_plugin.h"
 
 GodotJSStatisticsViewer::GodotJSStatisticsViewer()
 {
@@ -41,7 +42,7 @@ void GodotJSStatisticsViewer::activate(bool p_active)
 
 void GodotJSStatisticsViewer::on_timer()
 {
-    const GodotJSScriptLanguage* lang = GodotJSScriptLanguage::get_singleton();
+    const GodotJSScriptLanguage* lang = GodotJSEditorPlugin::get_singleton()->get_lang();
     if (!lang) return;
     const std::shared_ptr<jsb::Environment> env = lang->get_environment();
     if (!env) return;
diff --git a/weaver-editor/templates/SCsub b/weaver-editor/templates/SCsub
index 597b88f8..3ade3334 100644
--- a/weaver-editor/templates/SCsub
+++ b/weaver-editor/templates/SCsub
@@ -42,11 +42,10 @@ else:
         src_suffix = ".ts",
     )
 
-language = "ts" if env["use_typescript"] else "js"
-print("generate templates for", language)
-
 # Template files 
 # the suffix should be `.ts`, but `editor/template_builders.py` hardcoded the delimiter with `.cs`
-templates_sources = Glob(f"*/*.{language}.cs")
+templates_ts_sources = Glob(f"*/*.ts.cs")
+env.Alias("editor_template_ts", [env.MakeGodotJSTemplateBuilder("templates.ts.gen.h", templates_ts_sources)])
 
-env.Alias("editor_template_ts", [env.MakeGodotJSTemplateBuilder("templates.gen.h", templates_sources)])
+templates_js_sources = Glob(f"*/*.js.cs")
+env.Alias("editor_template_js", [env.MakeGodotJSTemplateBuilder("templates.js.gen.h", templates_js_sources)])
diff --git a/weaver/jsb_resource_loader.cpp b/weaver/jsb_resource_loader.cpp
index 56fd584d..a2fef4f1 100644
--- a/weaver/jsb_resource_loader.cpp
+++ b/weaver/jsb_resource_loader.cpp
@@ -3,14 +3,33 @@
 #include "jsb_script_language.h"
 #include "jsb_script.h"
 
+
+void ResourceFormatLoaderGodotJSScript::register_resource_extension(String ext, GodotJSScriptLanguageBase * lang)
+{
+    lang_map_.insert(ext, lang);
+}
+
 Ref<Resource> ResourceFormatLoaderGodotJSScript::load(const String& p_path, const String& p_original_path, Error* r_error, bool p_use_sub_threads, float* r_progress, CacheMode p_cache_mode)
 {
     JSB_BENCHMARK_SCOPE(ResourceFormatLoaderGodotJSScript, load);
 
+    GodotJSScriptLanguageBase * lang = nullptr;
+    for (auto const & i: lang_map_) {
+        if (p_path.ends_with(i.key)) {
+            lang = i.value;
+            break;
+        }
+    }
+
+    if (!lang) {
+        if (r_error) *r_error = ERR_FILE_UNRECOGNIZED;
+        return {};
+    }
+
     {
         //TODO a dirty but approaching solution for hot-reloading
-        MutexLock lock(GodotJSScriptLanguage::singleton_->mutex_);
-        SelfList<GodotJSScript> *elem = GodotJSScriptLanguage::singleton_->script_list_.first();
+        MutexLock lock(lang->mutex_);
+        SelfList<GodotJSScriptBase> *elem = lang->script_list_.first();
         while (elem)
         {
             if (elem->self()->get_path() == p_path)
@@ -33,7 +52,6 @@ Ref<Resource> ResourceFormatLoaderGodotJSScript::load(const String& p_path, cons
         return {};
     }
 #endif
-    jsb_check(p_path.ends_with(JSB_TYPESCRIPT_EXT) || p_path.ends_with(JSB_JAVASCRIPT_EXT));
 
     // in case `node_modules` is not ignored (which is not expected though), we do not want any GodotJSScript to be generated from it.
     if (p_path.begins_with("res://node_modules"))
@@ -41,6 +59,7 @@ Ref<Resource> ResourceFormatLoaderGodotJSScript::load(const String& p_path, cons
         if (r_error) *r_error = ERR_CANT_RESOLVE;
         return {};
     }
+    // exclude this extension
     if (p_path.ends_with("." JSB_DTS_EXT))
     {
         if (r_error) *r_error = ERR_FILE_UNRECOGNIZED;
@@ -49,8 +68,7 @@ Ref<Resource> ResourceFormatLoaderGodotJSScript::load(const String& p_path, cons
     JSB_LOG(VeryVerbose, "loading script resource %s on thread %s", p_path, uitos(Thread::get_caller_id()));
 
     // return a skeleton script which only contains path and source code without actually loaded in `realm` since `load` may called from background threads
-    Ref<GodotJSScript> spt;
-    spt.instantiate();
+    Ref<GodotJSScriptBase> spt = lang->create_godotjsscript();
     spt->attach_source(p_path);
     if (r_error) *r_error = OK;
     return spt;
@@ -58,19 +76,30 @@ Ref<Resource> ResourceFormatLoaderGodotJSScript::load(const String& p_path, cons
 
 void ResourceFormatLoaderGodotJSScript::get_recognized_extensions(List<String>* p_extensions) const
 {
-    p_extensions->push_back(JSB_TYPESCRIPT_EXT);
-    p_extensions->push_back(JSB_JAVASCRIPT_EXT);
+    for (auto const & i: lang_map_) {
+        p_extensions->push_back(i.key);
+    }
 }
 
 bool ResourceFormatLoaderGodotJSScript::handles_type(const String& p_type) const
 {
-    return (p_type == "Script" || p_type == jsb_typename(GodotJSScript));
+    if (p_type == "Script")
+        return true;
+    for (auto const & i: lang_map_) {
+        if (p_type == i.value->get_type())
+            return true;
+    }
+    return false;
 }
 
 String ResourceFormatLoaderGodotJSScript::get_resource_type(const String& p_path) const
 {
     const String el = p_path.get_extension().to_lower();
-    return (el == JSB_TYPESCRIPT_EXT || el == JSB_JAVASCRIPT_EXT) ? jsb_typename(GodotJSScript) : "";
+    for (auto const & i: lang_map_) {
+        if (el == i.key)
+            return i.value->get_type();
+    }
+    return "";
 }
 
 void ResourceFormatLoaderGodotJSScript::get_dependencies(const String& p_path, List<String>* p_dependencies, bool p_add_types)
diff --git a/weaver/jsb_resource_loader.h b/weaver/jsb_resource_loader.h
index b695900d..e43bbda6 100644
--- a/weaver/jsb_resource_loader.h
+++ b/weaver/jsb_resource_loader.h
@@ -3,9 +3,21 @@
 
 #include "core/io/resource_loader.h"
 
+#include "jsb_script_language.h"
+
 class ResourceFormatLoaderGodotJSScript : public ResourceFormatLoader
 {
+
+    ResourceFormatLoaderGodotJSScript(ResourceFormatLoaderGodotJSScript const &) = delete;
+    ResourceFormatLoaderGodotJSScript & operator=(ResourceFormatLoaderGodotJSScript const &) = delete;
+
+    HashMap<String, GodotJSScriptLanguageBase *> lang_map_;
+
 public:
+    ResourceFormatLoaderGodotJSScript() { }
+
+    void register_resource_extension(String ext, GodotJSScriptLanguageBase * lang);
+
     virtual Ref<Resource> load(const String& p_path, const String& p_original_path = "", Error* r_error = nullptr, bool p_use_sub_threads = false, float* r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE) override;
     virtual void get_recognized_extensions(List<String>* p_extensions) const override;
     virtual bool handles_type(const String& p_type) const override;
diff --git a/weaver/jsb_resource_saver.cpp b/weaver/jsb_resource_saver.cpp
index 54dc5666..48acab88 100644
--- a/weaver/jsb_resource_saver.cpp
+++ b/weaver/jsb_resource_saver.cpp
@@ -6,14 +6,14 @@
 // @seealso: gdscript.cpp ResourceFormatSaverGDScript::save
 Error ResourceFormatSaverGodotJSScript::save(const Ref<Resource>& p_resource, const String& p_path, uint32_t p_flags)
 {
-    const Ref<GodotJSScript> sqscr = p_resource;
+    const Ref<GodotJSScriptBase> sqscr = p_resource;
     ERR_FAIL_COND_V(sqscr.is_null(), ERR_INVALID_PARAMETER);
 
     Error err;
     const Ref<FileAccess> file = FileAccess::open(p_path, FileAccess::WRITE, &err);
     if (err)
     {
-        JSB_LOG(Error, "Cannot save %s file '%s'.", jsb_typename(GodotJSScript), p_path);
+        JSB_LOG(Error, "Cannot save %s file '%s'.", jsb_typename(GodotJSScriptBase), p_path);
         return err;
     }
     file->store_string(sqscr->get_source_code());
@@ -25,7 +25,7 @@ Error ResourceFormatSaverGodotJSScript::save(const Ref<Resource>& p_resource, co
     if (ScriptServer::is_reload_scripts_on_save_enabled())
     {
         // WTF??
-        GodotJSScriptLanguage::get_singleton()->reload_tool_script(p_resource, true);
+        sqscr->get_language()->reload_tool_script(p_resource, true);
     }
 
     return OK;
@@ -33,7 +33,7 @@ Error ResourceFormatSaverGodotJSScript::save(const Ref<Resource>& p_resource, co
 
 void ResourceFormatSaverGodotJSScript::get_recognized_extensions(const Ref<Resource>& p_resource, List<String>* p_extensions) const
 {
-    if (Object::cast_to<GodotJSScript>(*p_resource))
+    if (Object::cast_to<GodotJSScriptBase>(*p_resource))
     {
         p_extensions->push_back(JSB_TYPESCRIPT_EXT);
         p_extensions->push_back(JSB_JAVASCRIPT_EXT);
@@ -42,5 +42,5 @@ void ResourceFormatSaverGodotJSScript::get_recognized_extensions(const Ref<Resou
 
 bool ResourceFormatSaverGodotJSScript::recognize(const Ref<Resource>& p_resource) const
 {
-    return Object::cast_to<GodotJSScript>(*p_resource) != nullptr;
+    return Object::cast_to<GodotJSScriptBase>(*p_resource) != nullptr;
 }
diff --git a/weaver/jsb_script.cpp b/weaver/jsb_script.cpp
index 87affdef..9638298b 100644
--- a/weaver/jsb_script.cpp
+++ b/weaver/jsb_script.cpp
@@ -1,5 +1,7 @@
 #include "jsb_script.h"
 #include "jsb_script_language.h"
+#include "jsb_script_language_ts.h"
+#include "jsb_script_language_js.h"
 #include "jsb_script_instance.h"
 #include "../internal/jsb_path_util.h"
 
@@ -10,34 +12,32 @@
 #include "editor/editor_help.h"
 #endif
 
-GodotJSScript::GodotJSScript(): script_list_(this)
+GodotJSScriptBase::GodotJSScriptBase(GodotJSScriptLanguageBase * lang): script_list_(this), lang_(lang)
 {
-    {
-        JSB_BENCHMARK_SCOPE(GodotJSScript, Construct);
-        GodotJSScriptLanguage* lang = GodotJSScriptLanguage::get_singleton();
-        MutexLock lock(lang->mutex_);
+    if (lang_) {
+        JSB_BENCHMARK_SCOPE(GodotJSScriptBase, Construct);
+        MutexLock lock(lang_->mutex_);
 
         lang->script_list_.add(&script_list_);
     }
-    JSB_LOG(VeryVerbose, "new GodotJSScript addr:%d", (uintptr_t) this);
+    JSB_LOG(VeryVerbose, "new GodotJSScriptBase addr:%d", (uintptr_t) this);
 }
 
-GodotJSScript::~GodotJSScript()
+GodotJSScriptBase::~GodotJSScriptBase()
 {
-    JSB_LOG(VeryVerbose, "delete GodotJSScript addr:%d", (uintptr_t) this);
+    JSB_LOG(VeryVerbose, "delete GodotJSScriptBase addr:%d", (uintptr_t) this);
     release_cached_methods();
 
-    {
-        JSB_BENCHMARK_SCOPE(GodotJSScript, Destruct);
-        const GodotJSScriptLanguage* lang = GodotJSScriptLanguage::get_singleton();
-        MutexLock lock(lang->mutex_);
+    if (lang_) {
+        JSB_BENCHMARK_SCOPE(GodotJSScriptBase, Destruct);
+        MutexLock lock(lang_->mutex_);
 
         script_list_.remove_from_list();
     }
 }
 
 // GDScript::can_instantiate()
-bool GodotJSScript::can_instantiate() const
+bool GodotJSScriptBase::can_instantiate() const
 {
     ensure_module_loaded();
 #ifdef TOOLS_ENABLED
@@ -47,7 +47,7 @@ bool GodotJSScript::can_instantiate() const
 #endif
 }
 
-bool GodotJSScript::is_tool() const
+bool GodotJSScriptBase::is_tool() const
 {
     if (valid_)
     {
@@ -57,12 +57,12 @@ bool GodotJSScript::is_tool() const
     return false;
 }
 
-void GodotJSScript::set_source_code(const String& p_code)
+void GodotJSScriptBase::set_source_code(const String& p_code)
 {
     source_ = p_code;
 }
 
-Ref<Script> GodotJSScript::get_base_script() const
+Ref<Script> GodotJSScriptBase::get_base_script() const
 {
     ensure_module_loaded();
     //jsb_notice(loaded_, "script not loaded");
@@ -71,13 +71,13 @@ Ref<Script> GodotJSScript::get_base_script() const
     return base;
 }
 
-StringName GodotJSScript::get_global_name() const
+StringName GodotJSScriptBase::get_global_name() const
 {
     ensure_module_loaded();
     return valid_ ? get_script_class()->js_class_name : StringName();
 }
 
-bool GodotJSScript::inherits_script(const Ref<Script>& p_script) const
+bool GodotJSScriptBase::inherits_script(const Ref<Script>& p_script) const
 {
     jsb_check(loaded_);
 
@@ -89,13 +89,13 @@ bool GodotJSScript::inherits_script(const Ref<Script>& p_script) const
 }
 
 // this method is called in `EditorStandardSyntaxHighlighter::_update_cache()` without checking `script->is_valid()`
-StringName GodotJSScript::get_instance_base_type() const
+StringName GodotJSScriptBase::get_instance_base_type() const
 {
     ensure_module_loaded();
     return valid_ ? get_script_class()->native_class_name : StringName();
 }
 
-ScriptInstance* GodotJSScript::instance_create(const v8::Local<v8::Object>& p_this)
+ScriptInstance* GodotJSScriptBase::instance_create(const v8::Local<v8::Object>& p_this)
 {
     jsb_check(valid_);
     jsb_check(loaded_);
@@ -110,17 +110,17 @@ ScriptInstance* GodotJSScript::instance_create(const v8::Local<v8::Object>& p_th
 
     /* STEP 2, INITIALIZE AND CONSTRUCT */
     {
-        MutexLock lock(GodotJSScriptLanguage::singleton_->mutex_);
+        MutexLock lock(lang_->mutex_);
         instances_.insert(owner);
     }
     instance->object_id_ = get_environment()->bind_godot_object(get_script_class()->native_class_id, owner, p_this);
     if (!instance->object_id_)
     {
-        instance->script_ = Ref<GodotJSScript>();
+        instance->script_ = Ref<GodotJSScriptBase>();
         instance->owner_->set_script_instance(nullptr);
         //NOTE `instance` becomes an invalid pointer since it's deleted in `set_script_instance`
         {
-            MutexLock lock(GodotJSScriptLanguage::singleton_->mutex_);
+            MutexLock lock(lang_->mutex_);
             instances_.erase(owner);
         }
         memdelete(owner);
@@ -131,7 +131,7 @@ ScriptInstance* GodotJSScript::instance_create(const v8::Local<v8::Object>& p_th
     return instance;
 }
 
-ScriptInstance* GodotJSScript::instance_create(Object* p_this)
+ScriptInstance* GodotJSScriptBase::instance_create(Object* p_this)
 {
     //TODO multi-thread scripting not supported for now
     jsb_check(loaded_);
@@ -147,17 +147,17 @@ ScriptInstance* GodotJSScript::instance_create(Object* p_this)
 
     /* STEP 2, INITIALIZE AND CONSTRUCT */
     {
-        MutexLock lock(GodotJSScriptLanguage::singleton_->mutex_);
+        MutexLock lock(lang_->mutex_);
         instances_.insert(instance->owner_);
     }
     instance->object_id_ = get_environment()->crossbind(p_this, script_class_id_);
     if (!instance->object_id_)
     {
-        instance->script_ = Ref<GodotJSScript>();
+        instance->script_ = Ref<GodotJSScriptBase>();
         instance->owner_->set_script_instance(nullptr);
         //NOTE `instance` becomes an invalid pointer since it's deleted in `set_script_instance`
         {
-            MutexLock lock(GodotJSScriptLanguage::singleton_->mutex_);
+            MutexLock lock(lang_->mutex_);
             instances_.erase(p_this);
         }
         JSB_LOG(Error, "Error constructing a GodotJSScriptInstance");
@@ -167,14 +167,14 @@ ScriptInstance* GodotJSScript::instance_create(Object* p_this)
     return instance;
 }
 
-Error GodotJSScript::reload(bool p_keep_state)
+Error GodotJSScriptBase::reload(bool p_keep_state)
 {
     if (!loaded_) return OK;
     if (!valid_) return ERR_UNAVAILABLE;
 
     if (!p_keep_state)
     {
-        MutexLock lock(GodotJSScriptLanguage::singleton_->mutex_);
+        MutexLock lock(lang_->mutex_);
         if (instances_.size())
         {
             return ERR_ALREADY_IN_USE;
@@ -202,14 +202,14 @@ Error GodotJSScript::reload(bool p_keep_state)
 }
 
 #ifdef TOOLS_ENABLED
-Vector<DocData::ClassDoc> GodotJSScript::get_documentation() const
+Vector<DocData::ClassDoc> GodotJSScriptBase::get_documentation() const
 {
     ensure_module_loaded();
     if (!loaded_ || !script_class_id_) return {};
 
     const jsb::ScriptClassInfoPtr class_info = get_script_class();
     String base_type;
-    const String class_name = GodotJSScriptLanguage::get_singleton()->get_global_class_name(get_path(), &base_type);
+    const String class_name = lang_->get_global_class_name(get_path(), &base_type);
     DocData::ClassDoc class_doc_data;
 
     class_doc_data.name = class_name;
@@ -240,14 +240,14 @@ Vector<DocData::ClassDoc> GodotJSScript::get_documentation() const
     return { class_doc_data };
 }
 
-String GodotJSScript::get_class_icon_path() const
+String GodotJSScriptBase::get_class_icon_path() const
 {
     ensure_module_loaded();
     jsb_check(loaded_);
     return script_class_id_ ? get_script_class()->icon : String();
 }
 
-PropertyInfo GodotJSScript::get_class_category() const
+PropertyInfo GodotJSScriptBase::get_class_category() const
 {
     ensure_module_loaded();
     jsb_check(loaded_);
@@ -255,16 +255,16 @@ PropertyInfo GodotJSScript::get_class_category() const
 }
 #endif // TOOLS_ENABLED
 
-bool GodotJSScript::has_method(const StringName& p_method) const
+bool GodotJSScriptBase::has_method(const StringName& p_method) const
 {
     ensure_module_loaded();
     jsb_check(loaded_);
 
-    const GodotJSScript* current = this;
+    const GodotJSScriptBase* current = this;
     while (current)
     {
         //TODO temp fix
-        if (!current->loaded_) const_cast<GodotJSScript*>(current)->load_module_immediately();
+        if (!current->loaded_) const_cast<GodotJSScriptBase*>(current)->load_module_immediately();
         if (current->is_valid() && current->get_script_class()->methods.has(p_method)) return true;
         current = current->base.ptr();
     }
@@ -281,7 +281,7 @@ bool GodotJSScript::has_method(const StringName& p_method) const
     return false;
 }
 
-MethodInfo GodotJSScript::get_method_info(const StringName& p_method) const
+MethodInfo GodotJSScriptBase::get_method_info(const StringName& p_method) const
 {
     jsb_check(loaded_);
     jsb_check(has_method(p_method));
@@ -291,17 +291,17 @@ MethodInfo GodotJSScript::get_method_info(const StringName& p_method) const
     return item;
 }
 
-ScriptLanguage* GodotJSScript::get_language() const
+ScriptLanguage* GodotJSScriptBase::get_language() const
 {
-    return GodotJSScriptLanguage::get_singleton();
+    return lang_;
 }
 
-bool GodotJSScript::has_script_signal(const StringName& p_signal) const
+bool GodotJSScriptBase::has_script_signal(const StringName& p_signal) const
 {
     return is_valid() ? get_script_class()->signals.has(p_signal) : false;
 }
 
-void GodotJSScript::get_script_signal_list(List<MethodInfo>* r_signals) const
+void GodotJSScriptBase::get_script_signal_list(List<MethodInfo>* r_signals) const
 {
     ensure_module_loaded();
     jsb_check(loaded_);
@@ -318,7 +318,7 @@ void GodotJSScript::get_script_signal_list(List<MethodInfo>* r_signals) const
     }
 }
 
-void GodotJSScript::get_script_method_list(List<MethodInfo>* p_list) const
+void GodotJSScriptBase::get_script_method_list(List<MethodInfo>* p_list) const
 {
     ensure_module_loaded();
     jsb_check(loaded_);
@@ -337,7 +337,7 @@ void GodotJSScript::get_script_method_list(List<MethodInfo>* p_list) const
     }
 }
 
-void GodotJSScript::get_script_property_list(List<PropertyInfo>* p_list) const
+void GodotJSScriptBase::get_script_property_list(List<PropertyInfo>* p_list) const
 {
     ensure_module_loaded();
     jsb_check(loaded_);
@@ -357,7 +357,7 @@ void GodotJSScript::get_script_property_list(List<PropertyInfo>* p_list) const
     }
 }
 
-bool GodotJSScript::get_property_default_value(const StringName& p_property, Variant& r_value) const
+bool GodotJSScriptBase::get_property_default_value(const StringName& p_property, Variant& r_value) const
 {
     ensure_module_loaded();
     if (HashMap<StringName, Variant>::ConstIterator it = member_default_values_cache.find(p_property))
@@ -368,7 +368,7 @@ bool GodotJSScript::get_property_default_value(const StringName& p_property, Var
     return false;
 }
 
-const Variant GodotJSScript::get_rpc_config() const
+const Variant GodotJSScriptBase::get_rpc_config() const
 {
     ensure_module_loaded();
     jsb_check(loaded_);
@@ -376,7 +376,7 @@ const Variant GodotJSScript::get_rpc_config() const
     return get_script_class()->rpc_config;
 }
 
-bool GodotJSScript::has_static_method(const StringName& p_method) const
+bool GodotJSScriptBase::has_static_method(const StringName& p_method) const
 {
     ensure_module_loaded();
     jsb_check(loaded_);
@@ -384,14 +384,14 @@ bool GodotJSScript::has_static_method(const StringName& p_method) const
     return false;
 }
 
-bool GodotJSScript::instance_has(const Object* p_this) const
+bool GodotJSScriptBase::instance_has(const Object* p_this) const
 {
     jsb_check(loaded_);
-    MutexLock lock(GodotJSScriptLanguage::singleton_->mutex_);
+    MutexLock lock(lang_->mutex_);
     return instances_.has(const_cast<Object*>(p_this));
 }
 
-void GodotJSScript::load_source_code_from_path()
+void GodotJSScriptBase::load_source_code_from_path()
 {
     Error err;
     const String path = get_path();
@@ -406,7 +406,7 @@ void GodotJSScript::load_source_code_from_path()
     }
 }
 
-void GodotJSScript::attach_source(const String& p_path)
+void GodotJSScriptBase::attach_source(const String& p_path)
 {
     set_path(p_path);
 
@@ -416,7 +416,7 @@ void GodotJSScript::attach_source(const String& p_path)
     //TODO we can't immediately compile it here since it's loaded from resource loading threads, maybe we could do some string analysis/parsing thread independently
 }
 
-void GodotJSScript::load_module_if_missing()
+void GodotJSScriptBase::load_module_if_missing()
 {
     if (!loaded_ || !env_id_ || valid_) return;
 
@@ -425,14 +425,13 @@ void GodotJSScript::load_module_if_missing()
     load_module_immediately();
 }
 
-void GodotJSScript::load_module_immediately()
+void GodotJSScriptBase::load_module_immediately()
 {
     if (loaded_ && env_id_) return;
-    JSB_BENCHMARK_SCOPE(GodotJSScript, load_module);
+    JSB_BENCHMARK_SCOPE(GodotJSScriptBase, load_module);
 
     const String path = jsb::internal::PathUtil::convert_typescript_path(get_path());
-    const GodotJSScriptLanguage* lang = GodotJSScriptLanguage::get_singleton();
-    const std::shared_ptr<jsb::Environment> env = lang->get_environment();
+    const std::shared_ptr<jsb::Environment> env = lang_->get_environment();
 
     env_id_ = env->id();
     loaded_ = true;
@@ -461,10 +460,10 @@ void GodotJSScript::load_module_immediately()
     valid_ = !!script_class_id_;
     if (valid_)
     {
-        JSB_LOG(VeryVerbose, "GodotJSScript module loaded %s", path);
+        JSB_LOG(VeryVerbose, "GodotJSScriptBase module loaded %s", path);
         {
             //TODO a dirty but approaching solution for hot-reloading
-            MutexLock lock(GodotJSScriptLanguage::singleton_->mutex_); // necessary?
+            MutexLock lock(lang_->mutex_); // necessary?
             for (RBSet<Object *>::Element *E = instances_.front(); E;)
             {
                 RBSet<Object *>::Element *N = E->next();
@@ -486,7 +485,7 @@ void GodotJSScript::load_module_immediately()
                 const jsb::ScriptClassInfoPtr base_script_class_info = env->get_script_class(script_class_info->base_script_class_id);
                 const jsb::JavaScriptModule* base_module = env->get_module_cache().find(base_script_class_info->module_id);
                 const Ref<Resource> base_res = ResourceLoader::load(jsb::internal::PathUtil::convert_javascript_path(base_module->source_info.source_filepath));
-                jsb_check(base_res->get_class() == jsb_typename(GodotJSScript));
+                jsb_check(base_res->get_class() == jsb_typename(GodotJSScript) | base_res->get_class() == jsb_typename(GodotJavaScript));
                 base = base_res;
             }
         }
@@ -510,14 +509,14 @@ void GodotJSScript::load_module_immediately()
     JSB_LOG(Debug, "a stub script loaded which does not contain a GodotJS class %s", path);
 }
 
-jsb::ScriptClassInfoPtr GodotJSScript::get_script_class() const
+jsb::ScriptClassInfoPtr GodotJSScriptBase::get_script_class() const
 {
     jsb_check(loaded_);
     jsb_checkf(script_class_id_, "avoid calling this method if class_id is invalid, check prior with 'valid_'");
     return get_environment()->get_script_class(script_class_id_);
 }
 
-Variant GodotJSScript::call_script_method(jsb::NativeObjectID p_object_id, const StringName& p_method, const Variant** p_argv, int p_argc, Callable::CallError& r_error)
+Variant GodotJSScriptBase::call_script_method(jsb::NativeObjectID p_object_id, const StringName& p_method, const Variant** p_argv, int p_argc, Callable::CallError& r_error)
 {
     ensure_module_loaded();
     jsb_check(loaded_);
@@ -545,7 +544,7 @@ Variant GodotJSScript::call_script_method(jsb::NativeObjectID p_object_id, const
     return get_environment()->call_function(p_object_id, func_id, p_argv, p_argc, r_error);
 }
 
-void GodotJSScript::release_cached_methods()
+void GodotJSScriptBase::release_cached_methods()
 {
     if (const std::shared_ptr<jsb::Environment> env = get_environment())
     {
@@ -557,25 +556,25 @@ void GodotJSScript::release_cached_methods()
     cached_methods_.clear();
 }
 
-void GodotJSScript::call_prelude(jsb::NativeObjectID p_object_id)
+void GodotJSScriptBase::call_prelude(jsb::NativeObjectID p_object_id)
 {
     jsb_check(loaded_);
     get_environment()->call_prelude(script_class_id_, p_object_id);
 }
 
 //
-// bool GodotJSScript::get_script_property(jsb::NativeObjectID p_object_id, const StringName& p_name, Variant& r_ret) const
+// bool GodotJSScriptBase::get_script_property(jsb::NativeObjectID p_object_id, const StringName& p_name, Variant& r_ret) const
 // {
 //     // realm_->get_
 //     return true;
 // }
 //
-// bool GodotJSScript::set_script_property(jsb::NativeObjectID p_object_id, const StringName& p_name, const Variant& p_value)
+// bool GodotJSScriptBase::set_script_property(jsb::NativeObjectID p_object_id, const StringName& p_name, const Variant& p_value)
 // {
 //     return true;
 // }
 
-PlaceHolderScriptInstance* GodotJSScript::placeholder_instance_create(Object* p_this)
+PlaceHolderScriptInstance* GodotJSScriptBase::placeholder_instance_create(Object* p_this)
 {
     jsb_check(loaded_);
 #ifdef TOOLS_ENABLED
@@ -583,7 +582,7 @@ PlaceHolderScriptInstance* GodotJSScript::placeholder_instance_create(Object* p_
     {
         JSB_LOG(Warning, "creating placeholder instance on invalid script (%s)", get_path());
     }
-    PlaceHolderScriptInstance *si = memnew(PlaceHolderScriptInstance(GodotJSScriptLanguage::get_singleton(), Ref<Script>(this), p_this));
+    PlaceHolderScriptInstance *si = memnew(PlaceHolderScriptInstance(lang_, Ref<Script>(this), p_this));
     placeholders.insert(si);
     _update_exports(si);
     return si;
@@ -593,13 +592,13 @@ PlaceHolderScriptInstance* GodotJSScript::placeholder_instance_create(Object* p_
 }
 
 #ifdef TOOLS_ENABLED
-void GodotJSScript::_placeholder_erased(PlaceHolderScriptInstance* p_placeholder)
+void GodotJSScriptBase::_placeholder_erased(PlaceHolderScriptInstance* p_placeholder)
 {
     placeholders.erase(p_placeholder);
 }
 #endif
 
-void GodotJSScript::update_exports()
+void GodotJSScriptBase::update_exports()
 {
     ensure_module_loaded();
     jsb_check(loaded_);
@@ -609,7 +608,7 @@ void GodotJSScript::update_exports()
 #endif
 }
 
-void GodotJSScript::_update_exports_values(List<PropertyInfo>& r_props, HashMap<StringName, Variant>& r_values)
+void GodotJSScriptBase::_update_exports_values(List<PropertyInfo>& r_props, HashMap<StringName, Variant>& r_values)
 {
     for (const KeyValue<StringName, Variant> &E : member_default_values_cache)
     {
@@ -621,7 +620,7 @@ void GodotJSScript::_update_exports_values(List<PropertyInfo>& r_props, HashMap<
     }
 }
 
-void GodotJSScript::_update_exports(PlaceHolderScriptInstance* p_instance_to_update, bool p_base_exports_changed)
+void GodotJSScriptBase::_update_exports(PlaceHolderScriptInstance* p_instance_to_update, bool p_base_exports_changed)
 {
     // do not crash the engine if the script not loaded successfully
     if (!is_valid())
@@ -683,8 +682,23 @@ void GodotJSScript::_update_exports(PlaceHolderScriptInstance* p_instance_to_upd
     }
 }
 
-void GodotJSScript::reload_from_file()
+void GodotJSScriptBase::reload_from_file()
 {
     //TODO reload, maybe it's OK?
     reload(true);
 }
+
+// Implement GodotJSScript
+
+GodotJSScript::GodotJSScript() : GodotJSScriptBase(GodotJSScriptLanguage::get_singleton())
+{
+    jsb_check(get_language());
+}
+
+// Implement GodotJavaScript
+
+GodotJavaScript::GodotJavaScript() : GodotJSScriptBase(GodotJavascriptLanguage::get_singleton())
+{
+    jsb_check(get_language());
+}
+
diff --git a/weaver/jsb_script.h b/weaver/jsb_script.h
index bd538491..63c60958 100644
--- a/weaver/jsb_script.h
+++ b/weaver/jsb_script.h
@@ -6,19 +6,22 @@
 
 #include "../bridge/jsb_bridge.h"
 
-class GodotJSScript : public Script
+class GodotJSScriptLanguageBase;
+
+class GodotJSScriptBase : public Script
 {
     friend class GodotJSScriptInstance;
     typedef Script super;
 
-    GDCLASS(GodotJSScript, Script)
 
 private:
     // if the script invalid (or not actually loaded yet)
     bool valid_ = false;
     bool loaded_ = false;
     bool source_changed_cache = false;
-    Ref<GodotJSScript> base;
+    Ref<GodotJSScriptBase> base;
+
+    GodotJSScriptLanguageBase * lang_;
 
     HashSet<PlaceHolderScriptInstance*> placeholders;
 
@@ -26,7 +29,7 @@ class GodotJSScript : public Script
     HashMap<StringName, Variant> member_default_values_cache;
     List<PropertyInfo> members_cache;
 
-    SelfList<GodotJSScript> script_list_;
+    SelfList<GodotJSScriptBase> script_list_;
     RBSet<Object*> instances_;
 
     //TODO improvement needed
@@ -48,16 +51,18 @@ class GodotJSScript : public Script
     void call_prelude(jsb::NativeObjectID p_object_id);
 
     void load_module_immediately();
-    jsb_force_inline void ensure_module_loaded() const { if (jsb_unlikely(!loaded_)) const_cast<GodotJSScript*>(this)->load_module_immediately(); }
+    jsb_force_inline void ensure_module_loaded() const { if (jsb_unlikely(!loaded_)) const_cast<GodotJSScriptBase*>(this)->load_module_immediately(); }
 
     void _update_exports(PlaceHolderScriptInstance *p_instance_to_update, bool p_base_exports_changed = false);
     void _update_exports_values(List<PropertyInfo>& r_props, HashMap<StringName, Variant>& r_values);
 
     std::shared_ptr<jsb::Environment> get_environment() const { return jsb::Environment::_access(env_id_); }
 
+protected:
+    GodotJSScriptBase(GodotJSScriptLanguageBase * lang);
+
 public:
-    GodotJSScript();
-    virtual ~GodotJSScript() override;
+    virtual ~GodotJSScriptBase() override;
 
     void attach_source(const String& p_path);
     void load_source_code_from_path();
@@ -143,4 +148,16 @@ class GodotJSScript : public Script
 
 };
 
+class GodotJSScript : public GodotJSScriptBase {
+    GDCLASS(GodotJSScript, Script)
+public:
+    GodotJSScript();
+};
+
+class GodotJavaScript : public GodotJSScriptBase {
+    GDCLASS(GodotJavaScript, Script)
+public:
+    GodotJavaScript();
+};
+
 #endif
diff --git a/weaver/jsb_script_instance.cpp b/weaver/jsb_script_instance.cpp
index bccfc916..5a28476d 100644
--- a/weaver/jsb_script_instance.cpp
+++ b/weaver/jsb_script_instance.cpp
@@ -92,12 +92,12 @@ void GodotJSScriptInstance::notification(int p_notification, bool p_reversed)
     callp(jsb_string_name(_notification), argv, 1, error);
 }
 
-ScriptLanguage* GodotJSScriptInstance::get_language() { return GodotJSScriptLanguage::get_singleton(); }
+ScriptLanguage* GodotJSScriptInstance::get_language() { return script_->lang_; }
 
 GodotJSScriptInstance::~GodotJSScriptInstance()
 {
     JSB_BENCHMARK_SCOPE(GodotJSScriptInstance, Destruct);
-    MutexLock lock(GodotJSScriptLanguage::singleton_->mutex_);
+    MutexLock lock(script_->lang_->mutex_);
     jsb_check(script_.is_valid() && owner_);
     script_->instances_.erase(owner_);
 }
diff --git a/weaver/jsb_script_instance.h b/weaver/jsb_script_instance.h
index 2292b730..640117ac 100644
--- a/weaver/jsb_script_instance.h
+++ b/weaver/jsb_script_instance.h
@@ -7,10 +7,10 @@
 class GodotJSScriptInstance : public ScriptInstance
 {
 private:
-    friend class GodotJSScript;
+    friend class GodotJSScriptBase;
 
     Object* owner_ = nullptr;
-    Ref<GodotJSScript> script_;
+    Ref<GodotJSScriptBase> script_;
     // object handle id
     jsb::NativeObjectID object_id_;
 
diff --git a/weaver/jsb_script_language.cpp b/weaver/jsb_script_language.cpp
index 4e1684eb..baa46507 100644
--- a/weaver/jsb_script_language.cpp
+++ b/weaver/jsb_script_language.cpp
@@ -12,45 +12,35 @@
 
 #include "modules/regex/regex.h"
 
-#ifdef TOOLS_ENABLED
-#include "../weaver-editor/templates/templates.gen.h"
-#endif
-GodotJSScriptLanguage* GodotJSScriptLanguage::singleton_ = nullptr;
+int GodotJSScriptLanguageBase::prevent_environment_dispose_ = 0;
+std::shared_ptr<jsb::Environment> GodotJSScriptLanguageBase::environment_ = nullptr;
 
-GodotJSScriptLanguage::GodotJSScriptLanguage()
+GodotJSScriptLanguageBase::GodotJSScriptLanguageBase()
 {
-    JSB_BENCHMARK_SCOPE(GodotJSScriptLanguage, Construct);
-    jsb_check(!singleton_);
-    singleton_ = this;
+    JSB_BENCHMARK_SCOPE(GodotJSScriptLanguageBase, Construct);
     js_class_name_matcher1_ = RegEx::create_from_string(R"(\s*exports.default\s*=\s*class\s*(\w+)\s*extends\s*(\w+)\s*\{?)");
     js_class_name_matcher2_ = RegEx::create_from_string(R"(\s*exports.default\s*=\s*(\w+)\s*;?)");
     ts_class_name_matcher_ = RegEx::create_from_string(R"(\s*export\s+default\s+class\s+(\w+)\s+extends\s+(\w+))");
     jsb::internal::StringNames::create();
 }
 
-GodotJSScriptLanguage::~GodotJSScriptLanguage()
+GodotJSScriptLanguageBase::~GodotJSScriptLanguageBase()
 {
     jsb::internal::StringNames::free();
-    jsb_check(singleton_ == this);
-    singleton_ = nullptr;
 
     //TODO manage script list in a safer way (access and ref with script.id)
     MutexLock lock(mutex_);
-    while (SelfList<GodotJSScript>* script_el = script_list_.first())
+    while (SelfList<GodotJSScriptBase>* script_el = script_list_.first())
     {
         script_el->remove_from_list();
     }
 }
 
-void GodotJSScriptLanguage::init()
+void GodotJSScriptLanguageBase::create_environment()
 {
-    if (once_inited_) return;
-
-    JSB_BENCHMARK_SCOPE(GodotJSScriptLanguage, init);
-    once_inited_ = true;
-    JSB_LOG(Verbose, "Runtime: %s", JSB_IMPL_VERSION_STRING);
-    JSB_LOG(VeryVerbose, "jsb lang init");
-
+    ++prevent_environment_dispose_;
+    if (environment_)
+        return;
     jsb::Environment::CreateParams params;
     params.initial_class_slots = (int) ClassDB::classes.size() + JSB_MASTER_INITIAL_CLASS_EXTRA_SLOTS;
     params.initial_object_slots = JSB_MASTER_INITIAL_OBJECT_SLOTS;
@@ -75,19 +65,42 @@ void GodotJSScriptLanguage::init()
 #endif
 }
 
-void GodotJSScriptLanguage::finish()
+void GodotJSScriptLanguageBase::destroy_environment()
+{
+    if (!environment_)
+        return;
+    if (--prevent_environment_dispose_ == 1) {
+        environment_->dispose();
+        environment_.reset();
+    }
+}
+
+void GodotJSScriptLanguageBase::init()
+{
+    if (once_inited_) return;
+
+    JSB_BENCHMARK_SCOPE(GodotJSScriptLanguageBase, init);
+    once_inited_ = true;
+    JSB_LOG(Verbose, "Runtime: %s", JSB_IMPL_VERSION_STRING);
+    JSB_LOG(VeryVerbose, "jsb lang init");
+
+    create_environment();
+
+}
+
+void GodotJSScriptLanguageBase::finish()
 {
     jsb_check(once_inited_);
     once_inited_ = false;
-    environment_->dispose();
-    environment_.reset();
+
+    destroy_environment();
 #if !JSB_WITH_WEB
     jsb::Worker::finish();
 #endif
     JSB_LOG(VeryVerbose, "jsb lang finish");
 }
 
-void GodotJSScriptLanguage::frame()
+void GodotJSScriptLanguageBase::frame()
 {
     const uint64_t base_ticks = Engine::get_singleton()->get_frame_ticks();
     const uint64_t elapsed_milli = (base_ticks - last_ticks_) / 1000ULL; // milliseconds
@@ -97,7 +110,7 @@ void GodotJSScriptLanguage::frame()
     // environment_->gc();
 }
 
-void GodotJSScriptLanguage::get_reserved_words(List<String>* p_words) const
+void GodotJSScriptLanguageBase::get_reserved_words(List<String>* p_words) const
 {
     static const char* keywords[] = {
         "return", "function", "interface", "class", "let", "break", "as", "any", "switch", "case", "if", "enum",
@@ -130,36 +143,36 @@ struct JavaScriptControlFlowKeywords
     }
 };
 
-bool GodotJSScriptLanguage::is_control_flow_keyword(ConstStringRefCompat p_keyword) const
+bool GodotJSScriptLanguageBase::is_control_flow_keyword(ConstStringRefCompat p_keyword) const
 {
     static JavaScriptControlFlowKeywords collection;
     return collection.values.has(p_keyword);
 }
 
-void GodotJSScriptLanguage::get_doc_comment_delimiters(List<String>* p_delimiters) const
+void GodotJSScriptLanguageBase::get_doc_comment_delimiters(List<String>* p_delimiters) const
 {
     p_delimiters->push_back("///");
 }
 
-void GodotJSScriptLanguage::get_comment_delimiters(List<String>* p_delimiters) const
+void GodotJSScriptLanguageBase::get_comment_delimiters(List<String>* p_delimiters) const
 {
     p_delimiters->push_back("//");
     p_delimiters->push_back("/* */");
 }
 
-void GodotJSScriptLanguage::get_string_delimiters(List<String>* p_delimiters) const
+void GodotJSScriptLanguageBase::get_string_delimiters(List<String>* p_delimiters) const
 {
     p_delimiters->push_back("' '");
     p_delimiters->push_back("\" \"");
     p_delimiters->push_back("` `");
 }
 
-Script* GodotJSScriptLanguage::create_script() const
+Script* GodotJSScriptLanguageBase::create_script() const
 {
-    return memnew(GodotJSScript);
+    return create_godotjsscript();
 }
 
-bool GodotJSScriptLanguage::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
+bool GodotJSScriptLanguageBase::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
 {
     if (environment_->validate_script(p_path))
     {
@@ -175,10 +188,9 @@ bool GodotJSScriptLanguage::validate(const String& p_script, const String& p_pat
     return false;
 }
 
-Ref<Script> GodotJSScriptLanguage::make_template(const String& p_template, const String& p_class_name, const String& p_base_class_name) const
+Ref<Script> GodotJSScriptLanguageBase::make_template(const String& p_template, const String& p_class_name, const String& p_base_class_name) const
 {
-    Ref<GodotJSScript> spt;
-    spt.instantiate();
+    Ref<GodotJSScriptBase> spt = create_godotjsscript();
     String processed_template = p_template;
     processed_template = processed_template.replace("_BASE_", p_base_class_name)
                                  .replace("_CLASS_SNAKE_CASE_", jsb::internal::VariantUtil::to_snake_case_id(p_class_name))
@@ -188,50 +200,31 @@ Ref<Script> GodotJSScriptLanguage::make_template(const String& p_template, const
     return spt;
 }
 
-Vector<ScriptLanguage::ScriptTemplate> GodotJSScriptLanguage::get_built_in_templates(ConstStringNameRefCompat p_object)
-{
-    Vector<ScriptTemplate> templates;
-#ifdef TOOLS_ENABLED
-    for (int i = 0; i < TEMPLATES_ARRAY_SIZE; i++) {
-        if (TEMPLATES[i].inherit == p_object) {
-            templates.append(TEMPLATES[i]);
-        }
-    }
-#endif
-    return templates;
-}
-
 #if GODOT_4_3_OR_NEWER
-void GodotJSScriptLanguage::reload_scripts(const Array& p_scripts, bool p_soft_reload)
+void GodotJSScriptLanguageBase::reload_scripts(const Array& p_scripts, bool p_soft_reload)
 {
-    JSB_LOG(Verbose, "TODO [GodotJSScriptLanguage::reload_scripts] NOT IMPLEMENTED");
+    JSB_LOG(Verbose, "TODO [GodotJSScriptLanguageBase::reload_scripts] NOT IMPLEMENTED");
 }
 
-void GodotJSScriptLanguage::profiling_set_save_native_calls(bool p_enable)
+void GodotJSScriptLanguageBase::profiling_set_save_native_calls(bool p_enable)
 {
-    JSB_LOG(Verbose, "TODO [GodotJSScriptLanguage::profiling_set_save_native_calls] NOT IMPLEMENTED");
+    JSB_LOG(Verbose, "TODO [GodotJSScriptLanguageBase::profiling_set_save_native_calls] NOT IMPLEMENTED");
 }
 #endif
 
-void GodotJSScriptLanguage::reload_all_scripts()
+void GodotJSScriptLanguageBase::reload_all_scripts()
 {
     //TODO temporarily ignored because it's only called from `RemoteDebugger`
-    JSB_LOG(Verbose, "TODO [GodotJSScriptLanguage::reload_all_scripts] temporarily ignored because it's only called from `RemoteDebugger`");
+    JSB_LOG(Verbose, "TODO [GodotJSScriptLanguageBase::reload_all_scripts] temporarily ignored because it's only called from `RemoteDebugger`");
 }
 
-void GodotJSScriptLanguage::reload_tool_script(const Ref<Script>& p_script, bool p_soft_reload)
+void GodotJSScriptLanguageBase::reload_tool_script(const Ref<Script>& p_script, bool p_soft_reload)
 {
     //TODO temporarily ignored because it's only called from `ResourceSaver` (we usually write typescripts in vscode)
-    JSB_LOG(Verbose, "TODO [GodotJSScriptLanguage::reload_tool_script] temporarily ignored because it's only called from `ResourceSaver` (we usually write typescripts in vscode)");
-}
-
-void GodotJSScriptLanguage::get_recognized_extensions(List<String>* p_extensions) const
-{
-    p_extensions->push_back(JSB_TYPESCRIPT_EXT);
-    p_extensions->push_back(JSB_JAVASCRIPT_EXT);
+    JSB_LOG(Verbose, "TODO [GodotJSScriptLanguageBase::reload_tool_script] temporarily ignored because it's only called from `ResourceSaver` (we usually write typescripts in vscode)");
 }
 
-String GodotJSScriptLanguage::get_global_class_name(const String& p_path, String* r_base_type, String* r_icon_path) const
+String GodotJSScriptLanguageBase::get_global_class_name(const String& p_path, String* r_base_type, String* r_icon_path) const
 {
     // GodotJSScript implementation do not really support threaded access for now.
     // So, we can not load the script module in-place because `get_global_class_name` could be called from EditorFileSystem (background) scan.
@@ -290,22 +283,7 @@ String GodotJSScriptLanguage::get_global_class_name(const String& p_path, String
     return {};
 }
 
-bool GodotJSScriptLanguage::handles_global_class_type(const String& p_type) const
-{
-    return p_type == jsb_typename(GodotJSScript);
-}
-
-String GodotJSScriptLanguage::get_name() const
-{
-    return jsb_typename(GodotJSScript);
-}
-
-String GodotJSScriptLanguage::get_type() const
-{
-    return jsb_typename(GodotJSScript);
-}
-
-void GodotJSScriptLanguage::scan_external_changes()
+void GodotJSScriptLanguageBase::scan_external_changes()
 {
     environment_->scan_external_changes();
 
@@ -313,7 +291,7 @@ void GodotJSScriptLanguage::scan_external_changes()
     // fix scripts with no .js counterpart found (only missing scripts)
     {
         MutexLock lock(mutex_);
-        const SelfList<GodotJSScript>* elem = script_list_.first();
+        const SelfList<GodotJSScriptBase>* elem = script_list_.first();
         while (elem)
         {
             elem->self()->load_module_if_missing();
@@ -323,16 +301,17 @@ void GodotJSScriptLanguage::scan_external_changes()
 #endif
 }
 
-void GodotJSScriptLanguage::thread_enter()
+void GodotJSScriptLanguageBase::thread_enter()
 {
 #if !JSB_WITH_WEB
     jsb::Worker::on_thread_enter(Thread::get_caller_id());
 #endif
 }
 
-void GodotJSScriptLanguage::thread_exit()
+void GodotJSScriptLanguageBase::thread_exit()
 {
 #if !JSB_WITH_WEB
     jsb::Worker::on_thread_exit(Thread::get_caller_id());
 #endif
 }
+
diff --git a/weaver/jsb_script_language.h b/weaver/jsb_script_language.h
index 25fdc942..1b10649b 100644
--- a/weaver/jsb_script_language.h
+++ b/weaver/jsb_script_language.h
@@ -5,21 +5,20 @@
 
 #include "core/object/script_language.h"
 
-class GodotJSScriptLanguage : public ScriptLanguage
+class GodotJSScriptLanguageBase : public ScriptLanguage
 {
 private:
-    friend class GodotJSScript;
+    friend class GodotJSScriptBase;
     friend class GodotJSScriptInstance;
     friend class ResourceFormatLoaderGodotJSScript;
 
-    static GodotJSScriptLanguage* singleton_;
-
     Mutex mutex_;
-    SelfList<class GodotJSScript>::List script_list_;
+    SelfList<class GodotJSScriptBase>::List script_list_;
 
     bool once_inited_ = false;
     uint64_t last_ticks_ = 0;
-    std::shared_ptr<jsb::Environment> environment_;
+    static int prevent_environment_dispose_;
+    static std::shared_ptr<jsb::Environment> environment_;
 
     // [TS] matches 'export default class ClassName extends BaseName {'
     Ref<RegEx> ts_class_name_matcher_;
@@ -31,9 +30,13 @@ class GodotJSScriptLanguage : public ScriptLanguage
     Ref<RegEx> js_class_name_matcher1_;
 
 public:
-    jsb_force_inline static GodotJSScriptLanguage* get_singleton() { return singleton_; }
-
     // main context
+
+    static void create_environment();
+
+    static void destroy_environment();
+
+    // Get the environment singleton
     jsb_force_inline std::shared_ptr<jsb::Environment> get_environment() const
     {
         jsb_check(once_inited_ && environment_);
@@ -54,8 +57,10 @@ class GodotJSScriptLanguage : public ScriptLanguage
         return environment_->eval_source(str.get_data(), str.length(), "eval", r_err);
     }
 
-    GodotJSScriptLanguage();
-    virtual ~GodotJSScriptLanguage() override;
+    virtual GodotJSScriptBase* create_godotjsscript() const = 0;
+
+    GodotJSScriptLanguageBase();
+    virtual ~GodotJSScriptLanguageBase() override;
 
     virtual void init() override;
     virtual void finish() override;
@@ -65,7 +70,7 @@ class GodotJSScriptLanguage : public ScriptLanguage
     virtual void thread_exit() override;
 
     virtual bool is_control_flow_keyword(ConstStringRefCompat p_keyword) const override;
-    virtual Vector<ScriptTemplate> get_built_in_templates(ConstStringNameRefCompat p_object) override;
+    virtual Vector<ScriptTemplate> get_built_in_templates(ConstStringNameRefCompat p_object) = 0;
 
     virtual void get_reserved_words(List<String>* p_words) const override;
     virtual void get_doc_comment_delimiters(List<String>* p_delimiters) const override;
@@ -75,7 +80,7 @@ class GodotJSScriptLanguage : public ScriptLanguage
     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 Ref<Script> make_template(const String& p_template, const String& p_class_name, const String& p_base_class_name) const override;
     virtual void reload_all_scripts() override;
-    virtual void get_recognized_extensions(List<String>* p_extensions) const override;
+    virtual void get_recognized_extensions(List<String>* p_extensions) const = 0;
 
     virtual bool supports_documentation() const override { return true; }
 
@@ -85,14 +90,9 @@ class GodotJSScriptLanguage : public ScriptLanguage
 #endif
 
 #pragma region DEFAULTLY AND PARTIALLY SUPPORTED
-    virtual String get_name() const override;
-    virtual String get_type() const override;
-
-#if JSB_USE_TYPESCRIPT
-    virtual String get_extension() const override { return JSB_TYPESCRIPT_EXT; }
-#else
-    virtual String get_extension() const override { return JSB_JAVASCRIPT_EXT; }
-#endif
+    virtual String get_name() const = 0;
+    virtual String get_type() const = 0;
+    virtual String get_extension() const = 0;
 
     virtual bool is_using_templates() override { return true; }
 #ifndef DISABLE_DEPRECATED
@@ -148,7 +148,7 @@ class GodotJSScriptLanguage : public ScriptLanguage
     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; }
 
-    virtual bool handles_global_class_type(const String& p_type) const override;
+    virtual bool handles_global_class_type(const String& p_type) const = 0;
     virtual String get_global_class_name(const String& p_path, String* r_base_type = nullptr, String* r_icon_path = nullptr) const override;
 #pragma endregion
 
diff --git a/weaver/jsb_script_language_js.cpp b/weaver/jsb_script_language_js.cpp
new file mode 100644
index 00000000..c59b95d5
--- /dev/null
+++ b/weaver/jsb_script_language_js.cpp
@@ -0,0 +1,59 @@
+#include "jsb_script_language_js.h"
+
+#include <iterator>
+
+#include "../jsb_project_preset.h"
+#include "../internal/jsb_internal.h"
+#include "../bridge/jsb_worker.h"
+#include "../bridge/jsb_amd_module_loader.h"
+
+#include "jsb_script.h"
+#include "editor/editor_settings.h"
+
+#include "modules/regex/regex.h"
+
+#ifdef TOOLS_ENABLED
+#include "../weaver-editor/templates/templates.js.gen.h"
+#endif
+
+GodotJavascriptLanguage * GodotJavascriptLanguage::singleton_ = nullptr;
+
+void GodotJavascriptLanguage::get_recognized_extensions(List<String>* p_extensions) const
+{
+    p_extensions->push_back(JSB_JAVASCRIPT_EXT);
+}
+
+GodotJSScriptBase* GodotJavascriptLanguage::create_godotjsscript() const
+{
+    return memnew(GodotJavaScript);
+}
+
+
+bool GodotJavascriptLanguage::handles_global_class_type(const String& p_type) const
+{
+    return p_type == jsb_typename(GodotJavaScript);
+}
+
+String GodotJavascriptLanguage::get_name() const
+{
+    return jsb_typename(GodotJavaScript);
+}
+
+String GodotJavascriptLanguage::get_type() const
+{
+    return jsb_typename(GodotJavaScript);
+}
+
+Vector<ScriptLanguage::ScriptTemplate> GodotJavascriptLanguage::get_built_in_templates(ConstStringNameRefCompat p_object)
+{
+    Vector<ScriptTemplate> templates;
+#ifdef TOOLS_ENABLED
+    for (int i = 0; i < TEMPLATES_ARRAY_SIZE; i++) {
+        if (TEMPLATES[i].inherit == p_object) {
+            templates.append(TEMPLATES[i]);
+        }
+    }
+#endif
+    return templates;
+}
+
diff --git a/weaver/jsb_script_language_js.h b/weaver/jsb_script_language_js.h
new file mode 100644
index 00000000..68ab8ad5
--- /dev/null
+++ b/weaver/jsb_script_language_js.h
@@ -0,0 +1,22 @@
+#ifndef GODOTJS_SCRIPT_LANGUAGE_JS_H
+#define GODOTJS_SCRIPT_LANGUAGE_JS_H
+
+#include "jsb_script_language.h"
+
+class GodotJavascriptLanguage : public GodotJSScriptLanguageBase {
+    static GodotJavascriptLanguage * singleton_;
+public:
+    static GodotJavascriptLanguage * get_singleton() { return singleton_; }
+    static GodotJavascriptLanguage * create_singleton() { if (singleton_) return singleton_; return singleton_ = memnew(GodotJavascriptLanguage); }
+    static void destroy_singleton() { if (singleton_) memdelete(singleton_); singleton_ = nullptr; }
+    virtual String get_extension() const override { return JSB_JAVASCRIPT_EXT; }
+    virtual GodotJSScriptBase* create_godotjsscript() const override;
+    virtual void get_recognized_extensions(List<String>* p_extensions) const override;
+    virtual bool handles_global_class_type(const String& p_type) const override;
+    virtual String get_name() const override;
+    virtual String get_type() const override;
+    virtual Vector<ScriptTemplate> get_built_in_templates(ConstStringNameRefCompat p_object) override;
+
+};
+
+#endif
diff --git a/weaver/jsb_script_language_ts.cpp b/weaver/jsb_script_language_ts.cpp
new file mode 100644
index 00000000..e2329635
--- /dev/null
+++ b/weaver/jsb_script_language_ts.cpp
@@ -0,0 +1,58 @@
+#include "jsb_script_language_ts.h"
+
+#include <iterator>
+
+#include "../jsb_project_preset.h"
+#include "../internal/jsb_internal.h"
+#include "../bridge/jsb_worker.h"
+#include "../bridge/jsb_amd_module_loader.h"
+
+#include "jsb_script.h"
+#include "editor/editor_settings.h"
+
+#include "modules/regex/regex.h"
+
+#ifdef TOOLS_ENABLED
+#include "../weaver-editor/templates/templates.ts.gen.h"
+#endif
+
+GodotJSScriptLanguage * GodotJSScriptLanguage::singleton_ = nullptr;
+
+void GodotJSScriptLanguage::get_recognized_extensions(List<String>* p_extensions) const
+{
+    p_extensions->push_back(JSB_TYPESCRIPT_EXT);
+}
+
+GodotJSScriptBase* GodotJSScriptLanguage::create_godotjsscript() const
+{
+    return memnew(GodotJSScript);
+}
+
+bool GodotJSScriptLanguage::handles_global_class_type(const String& p_type) const
+{
+    return p_type == jsb_typename(GodotJSScript);
+}
+
+String GodotJSScriptLanguage::get_name() const
+{
+    return jsb_typename(GodotJSScript);
+}
+
+String GodotJSScriptLanguage::get_type() const
+{
+    return jsb_typename(GodotJSScript);
+}
+
+Vector<ScriptLanguage::ScriptTemplate> GodotJSScriptLanguage::get_built_in_templates(ConstStringNameRefCompat p_object)
+{
+    Vector<ScriptTemplate> templates;
+#ifdef TOOLS_ENABLED
+    for (int i = 0; i < TEMPLATES_ARRAY_SIZE; i++) {
+        if (TEMPLATES[i].inherit == p_object) {
+            templates.append(TEMPLATES[i]);
+        }
+    }
+#endif
+    return templates;
+}
+
diff --git a/weaver/jsb_script_language_ts.h b/weaver/jsb_script_language_ts.h
new file mode 100644
index 00000000..02051d64
--- /dev/null
+++ b/weaver/jsb_script_language_ts.h
@@ -0,0 +1,22 @@
+#ifndef GODOTJS_SCRIPT_LANGUAGE_TS_H
+#define GODOTJS_SCRIPT_LANGUAGE_TS_H
+
+#include "jsb_script_language.h"
+
+class GodotJSScriptLanguage : public GodotJSScriptLanguageBase {
+    static GodotJSScriptLanguage * singleton_;
+public:
+    static GodotJSScriptLanguage * get_singleton() { return singleton_; }
+    static GodotJSScriptLanguage * create_singleton() { if (singleton_) return singleton_; return singleton_ = memnew(GodotJSScriptLanguage); }
+    static void destroy_singleton() { if (singleton_) memdelete(singleton_); singleton_ = nullptr; }
+    virtual String get_extension() const override { return JSB_TYPESCRIPT_EXT; }
+    virtual GodotJSScriptBase* create_godotjsscript() const override;
+    virtual void get_recognized_extensions(List<String>* p_extensions) const override;
+    virtual bool handles_global_class_type(const String& p_type) const override;
+    virtual String get_name() const override;
+    virtual String get_type() const override;
+    virtual Vector<ScriptTemplate> get_built_in_templates(ConstStringNameRefCompat p_object) override;
+
+};
+
+#endif