diff --git a/editor/create_dialog.cpp b/editor/create_dialog.cpp
index 8a8d52c6f13b..651e931c73dc 100644
--- a/editor/create_dialog.cpp
+++ b/editor/create_dialog.cpp
@@ -40,11 +40,6 @@
 
 void CreateDialog::popup_create(bool p_dont_clear, bool p_replace_mode, const String &p_select_type) {
 
-	type_list.clear();
-	ClassDB::get_class_list(&type_list);
-	ScriptServer::get_global_class_list(&type_list);
-	type_list.sort_custom<StringName::AlphCompare>();
-
 	recent->clear();
 
 	FileAccess *f = FileAccess::open(EditorSettings::get_singleton()->get_project_settings_dir().plus_file("create_recent." + base_type), FileAccess::READ);
@@ -60,7 +55,7 @@ void CreateDialog::popup_create(bool p_dont_clear, bool p_replace_mode, const St
 			if (ClassDB::class_exists(name) || ScriptServer::is_global_class(name)) {
 				TreeItem *ti = recent->create_item(root);
 				ti->set_text(0, l);
-				ti->set_icon(0, EditorNode::get_singleton()->get_class_icon(l, base_type));
+				ti->set_icon(0, EditorNode::get_singleton()->get_class_icon(name, base_type));
 			}
 		}
 
@@ -141,31 +136,25 @@ void CreateDialog::add_type(const String &p_type, HashMap<String, TreeItem *> &p
 	if (p_types.has(p_type))
 		return;
 
-	bool cpp_type = ClassDB::class_exists(p_type);
-	EditorData &ed = EditorNode::get_editor_data();
+	const TypeDB &tdb = EditorNode::get_editor_data().get_type_db();
 
 	if (p_type == base_type)
 		return;
 
-	if (cpp_type) {
-		if (!ClassDB::is_parent_class(p_type, base_type))
-			return;
-	} else {
-		if (!ScriptServer::is_global_class(p_type) || !ed.script_class_is_parent(p_type, base_type))
-			return;
+	if (!tdb.is_parent_class(p_type, base_type))
+		return;
 
-		String script_path = ScriptServer::get_global_class_path(p_type);
-		if (script_path.find("res://addons/", 0) != -1) {
-			if (!EditorNode::get_singleton()->is_addon_plugin_enabled(script_path.get_slicec('/', 3)))
-				return;
-		}
+	String path = tdb.get_path_by_class(p_type);
+	if (path.length() && path.find("res://addons/", 0) != -1 && !EditorNode::get_singleton()->is_addon_plugin_enabled(path.get_slicec('/', 3))) {
+		return;
 	}
 
-	String inherits = cpp_type ? ClassDB::get_parent_class(p_type) : ed.script_class_get_base(p_type);
+	StringName inherits = tdb.get_parent_class(p_type);
+	StringName empty;
 
 	TreeItem *parent = p_root;
 
-	if (inherits.length()) {
+	if (inherits != empty) {
 
 		if (!p_types.has(inherits)) {
 
@@ -174,18 +163,20 @@ void CreateDialog::add_type(const String &p_type, HashMap<String, TreeItem *> &p
 
 		if (p_types.has(inherits))
 			parent = p_types[inherits];
-		else if (ScriptServer::is_global_class(inherits))
+		else {
 			return;
+		}
 	}
 
-	bool can_instance = (cpp_type && ClassDB::can_instance(p_type)) || ScriptServer::is_global_class(p_type);
+	bool can_instance = tdb.can_instance(p_type);
 
 	TreeItem *item = search_options->create_item(parent);
-	if (cpp_type) {
+	String to_select_type = *to_select ? (*to_select)->get_text(0).split(" ")[0] : "";
+	if (ClassDB::class_exists(p_type)) {
 		item->set_text(0, p_type);
 	} else {
 		item->set_metadata(0, p_type);
-		item->set_text(0, p_type + " (" + ScriptServer::get_global_class_path(p_type).get_file() + ")");
+		item->set_text(0, p_type + " (" + tdb.get_path_by_class(p_type).get_file() + ")");
 	}
 	if (!can_instance) {
 		item->set_custom_color(0, get_color("disabled_font_color", "Editor"));
@@ -236,7 +227,7 @@ void CreateDialog::add_type(const String &p_type, HashMap<String, TreeItem *> &p
 		item->set_collapsed(collapse);
 	}
 
-	const String &description = EditorHelp::get_doc_data()->class_list[p_type].brief_description;
+	const String &description = (EditorHelp::get_doc_data()->class_list.has(p_type)) ? EditorHelp::get_doc_data()->class_list[p_type].brief_description : "";
 	item->set_tooltip(0, description);
 
 	item->set_icon(0, EditorNode::get_singleton()->get_class_icon(p_type, base_type));
@@ -305,92 +296,36 @@ void CreateDialog::_update_search() {
 	search_options_types.clear();
 
 	TreeItem *root = search_options->create_item();
-	EditorData &ed = EditorNode::get_editor_data();
+	const TypeDB &tdb = EditorNode::get_editor_data().get_type_db();
 
 	root->set_text(0, base_type);
-	if (has_icon(base_type, "EditorIcons")) {
-		root->set_icon(0, get_icon(base_type, "EditorIcons"));
-	}
+	root->set_icon(0, EditorNode::get_singleton()->get_class_icon(base_type));
+	search_options_types[base_type] = root;
 
 	TreeItem *to_select = search_box->get_text() == base_type ? root : NULL;
 
-	for (List<StringName>::Element *I = type_list.front(); I; I = I->next()) {
-
-		String type = I->get();
-
-		if (_is_class_disabled_by_feature_profile(type)) {
-			continue;
-		}
-		bool cpp_type = ClassDB::class_exists(type);
-
-		if (base_type == "Node" && type.begins_with("Editor"))
-			continue; // do not show editor nodes
-
-		if (cpp_type && !ClassDB::can_instance(type))
-			continue; // can't create what can't be instanced
-
-		if (cpp_type) {
-			bool skip = false;
-
-			for (Set<StringName>::Element *E = type_blacklist.front(); E && !skip; E = E->next()) {
-				if (ClassDB::is_parent_class(type, E->get()))
-					skip = true;
-			}
-			if (skip)
-				continue;
-		}
+	for (int i = 0; i < type_listv.size(); ++i) {
+		StringName type = type_listv[i];
 
 		if (search_box->get_text() == "") {
 			add_type(type, search_options_types, root, &to_select);
 		} else {
 
 			bool found = false;
-			String type2 = I->get();
-			while (type2 != "" && (cpp_type ? ClassDB::is_parent_class(type2, base_type) : ed.script_class_is_parent(type2, base_type)) && type2 != base_type) {
-				if (search_box->get_text().is_subsequence_ofi(type2)) {
+			StringName current_type = type; // will move up through inherited types. One of them must be a subsequence.
+			StringName empty;
+			while (current_type != empty && tdb.is_parent_class(current_type, base_type) && current_type != base_type) {
+				if (search_box->get_text().is_subsequence_ofi(current_type)) {
 
 					found = true;
 					break;
 				}
 
-				type2 = cpp_type ? ClassDB::get_parent_class(type2) : ed.script_class_get_base(type2);
+				current_type = tdb.get_parent_class(current_type);
 			}
 
 			if (found)
-				add_type(I->get(), search_options_types, root, &to_select);
-		}
-
-		if (EditorNode::get_editor_data().get_custom_types().has(type) && ClassDB::is_parent_class(type, base_type)) {
-			//there are custom types based on this... cool.
-
-			const Vector<EditorData::CustomType> &ct = EditorNode::get_editor_data().get_custom_types()[type];
-			for (int i = 0; i < ct.size(); i++) {
-
-				bool show = search_box->get_text().is_subsequence_ofi(ct[i].name);
-
-				if (!show)
-					continue;
-
-				if (!search_options_types.has(type))
-					add_type(type, search_options_types, root, &to_select);
-
-				TreeItem *ti;
-				if (search_options_types.has(type))
-					ti = search_options_types[type];
-				else
-					ti = search_options->get_root();
-
-				TreeItem *item = search_options->create_item(ti);
-				item->set_metadata(0, type);
-				item->set_text(0, ct[i].name);
-				if (ct[i].icon.is_valid()) {
-					item->set_icon(0, ct[i].icon);
-				}
-
-				if (!to_select || ct[i].name == search_box->get_text()) {
-					to_select = item;
-				}
-			}
+				add_type(type, search_options_types, root, &to_select);
 		}
 	}
 
@@ -451,6 +386,7 @@ void CreateDialog::_notification(int p_what) {
 			search_box->set_right_icon(get_icon("Search", "EditorIcons"));
 			search_box->set_clear_button_enabled(true);
 			favorite->set_icon(get_icon("Favorites", "EditorIcons"));
+			add_to_group("create_dialogs");
 		} break;
 		case NOTIFICATION_EXIT_TREE: {
 			disconnect("confirmed", this, "_confirmed");
@@ -520,7 +456,7 @@ Object *CreateDialog::instance_selected() {
 					n->set_name(custom);
 				return obj;
 			}
-			return EditorNode::get_editor_data().instance_custom_type(selected->get_text(0), custom);
+			return EditorNode::get_editor_data().instance_custom_type(selected->get_text(0));
 		} else {
 			return ClassDB::instance(selected->get_text(0));
 		}
@@ -567,6 +503,34 @@ void CreateDialog::_favorite_toggled() {
 	_save_and_update_favorite_list();
 }
 
+void CreateDialog::fs_changed() {
+	type_list.clear();
+	const TypeDB &tdb = EditorNode::get_editor_data().get_type_db();
+	tdb.get_class_list(&type_list);
+	type_list.sort_custom<StringName::AlphCompare>();
+	type_listv.clear();
+	for (List<StringName>::Element *E = type_list.front(); E; E = E->next()) {
+		StringName type = E->get();
+		if (base_type == "Node" && String(type).begins_with("Editor"))
+			continue; // do not show editor nodes
+		if (!tdb.can_instance(type))
+			continue; // can't create what can't be instanced
+		if (_is_class_disabled_by_feature_profile(type)) {
+			continue;
+		}
+		type_listv.push_back(type);
+	}
+	for (int i = 0; i < type_listv.size(); ++i) {
+		for (int j = 0; j < type_blacklist.size(); ++j) {
+			if (tdb.is_parent_class(type_listv[i], type_blacklist[j])) {
+				type_listv.remove(i);
+				--i;
+				break;
+			}
+		}
+	}
+}
+
 void CreateDialog::_save_favorite_list() {
 
 	FileAccess *f = FileAccess::open(EditorSettings::get_singleton()->get_project_settings_dir().plus_file("favorites." + base_type), FileAccess::WRITE);
@@ -802,8 +766,8 @@ CreateDialog::CreateDialog() {
 	vbc->add_margin_child(TTR("Description:"), help_bit);
 	help_bit->connect("request_hide", this, "_closed");
 
-	type_blacklist.insert("PluginScript"); // PluginScript must be initialized before use, which is not possible here
-	type_blacklist.insert("ScriptCreateDialog"); // This is an exposed editor Node that doesn't have an Editor prefix.
+	type_blacklist.push_back("PluginScript"); // PluginScript must be initialized before use, which is not possible here
+	type_blacklist.push_back("ScriptCreateDialog"); // This is an exposed editor Node that doesn't have an Editor prefix.
 
 	EDITOR_DEF("interface/editors/derive_script_globals_by_name", true);
 }
diff --git a/editor/create_dialog.h b/editor/create_dialog.h
index f6c3b5758942..799ca72eb548 100644
--- a/editor/create_dialog.h
+++ b/editor/create_dialog.h
@@ -59,7 +59,8 @@ class CreateDialog : public ConfirmationDialog {
 	String preferred_search_result_type;
 	EditorHelpBit *help_bit;
 	List<StringName> type_list;
-	Set<StringName> type_blacklist;
+	Vector<StringName> type_listv;
+	Vector<StringName> type_blacklist;
 
 	void _item_selected();
 
@@ -110,7 +111,9 @@ class CreateDialog : public ConfirmationDialog {
 
 	void popup_create(bool p_dont_clear, bool p_replace_mode = false, const String &p_select_type = "Node");
 
+	void fs_changed();
+
 	CreateDialog();
 };
 
-#endif
+#endif
\ No newline at end of file
diff --git a/editor/editor_data.cpp b/editor/editor_data.cpp
index f5846c10f644..a2368307295d 100644
--- a/editor/editor_data.cpp
+++ b/editor/editor_data.cpp
@@ -479,56 +479,81 @@ EditorPlugin *EditorData::get_editor_plugin(int p_idx) {
 	return editor_plugins[p_idx];
 }
 
+void EditorData::get_custom_type_class_list(List<StringName> *p_classes) const {
+	ERR_FAIL_COND(!p_classes);
+	custom_types.get_key_list(p_classes);
+}
+
+StringName EditorData::get_custom_type_name(const String &p_path) const {
+	List<StringName> names;
+	get_custom_type_class_list(&names);
+	for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
+		Ref<Script> script = custom_types[E->get()].script;
+		if (script.is_null())
+			continue;
+		if (script->get_path() == p_path)
+			return E->get();
+	}
+	return StringName();
+}
+
+Ref<Script> EditorData::get_custom_type_script(const StringName &p_type) const {
+	ERR_FAIL_COND_V(!custom_types.has(p_type), NULL);
+	return custom_types[p_type].script;
+}
+
+String EditorData::get_custom_type_path(const StringName &p_type) const {
+	ERR_FAIL_COND_V(!custom_types.has(p_type), String());
+	Ref<Script> script = custom_types[p_type].script;
+	ERR_FAIL_COND_V(script.is_null(), String());
+	return script->get_path();
+}
+
+StringName EditorData::get_custom_type_base(const StringName &p_type) const {
+	ERR_FAIL_COND_V(!custom_types.has(p_type), StringName());
+	return custom_types[p_type].base;
+}
+
+Ref<Texture> EditorData::get_custom_type_icon(const String &p_type) const {
+	ERR_FAIL_COND_V(!custom_types.has(p_type), NULL);
+	return custom_types[p_type].icon;
+}
+
 void EditorData::add_custom_type(const String &p_type, const String &p_inherits, const Ref<Script> &p_script, const Ref<Texture> &p_icon) {
 
+	ERR_FAIL_COND(custom_types.has(p_type));
+	ERR_FAIL_COND(ScriptServer::is_global_class(p_type));
 	ERR_FAIL_COND(p_script.is_null());
 	CustomType ct;
 	ct.name = p_type;
 	ct.icon = p_icon;
 	ct.script = p_script;
-	if (!custom_types.has(p_inherits)) {
-		custom_types[p_inherits] = Vector<CustomType>();
-	}
 
-	custom_types[p_inherits].push_back(ct);
+	custom_types[p_type] = ct;
 }
 
-Object *EditorData::instance_custom_type(const String &p_type, const String &p_inherits) {
+Object *EditorData::instance_custom_type(const String &p_type) {
 
-	if (get_custom_types().has(p_inherits)) {
+	ERR_FAIL_COND_V(!custom_types.has(p_type), NULL);
 
-		for (int i = 0; i < get_custom_types()[p_inherits].size(); i++) {
-			if (get_custom_types()[p_inherits][i].name == p_type) {
-				Ref<Script> script = get_custom_types()[p_inherits][i].script;
+	const CustomType &ct = custom_types[p_type];
+	Ref<Script> script = ct.script;
+	ERR_FAIL_COND_V(script.is_null(), NULL);
 
-				Object *ob = ClassDB::instance(p_inherits);
-				ERR_FAIL_COND_V(!ob, NULL);
-				if (ob->is_class("Node")) {
-					ob->call("set_name", p_type);
-				}
-				ob->set_script(script.get_ref_ptr());
-				return ob;
-			}
-		}
+	Object *ob = ClassDB::instance(script->get_instance_base_type());
+	ERR_FAIL_COND_V(!ob, NULL);
+
+	if (ob->is_class("Node")) {
+		ob->call("set_name", p_type);
 	}
+	ob->set_script(script.get_ref_ptr());
 
-	return NULL;
+	return ob;
 }
 
 void EditorData::remove_custom_type(const String &p_type) {
 
-	for (Map<String, Vector<CustomType> >::Element *E = custom_types.front(); E; E = E->next()) {
-
-		for (int i = 0; i < E->get().size(); i++) {
-			if (E->get()[i].name == p_type) {
-				E->get().remove(i);
-				if (E->get().empty()) {
-					custom_types.erase(E->key());
-				}
-				return;
-			}
-		}
-	}
+	custom_types.erase(p_type);
 }
 
 int EditorData::add_edited_scene(int p_at_pos) {
diff --git a/editor/editor_data.h b/editor/editor_data.h
index 845878e07004..39e9873a0e8a 100644
--- a/editor/editor_data.h
+++ b/editor/editor_data.h
@@ -36,6 +36,7 @@
 #include "core/undo_redo.h"
 #include "editor/editor_plugin.h"
 #include "editor/plugins/script_editor_plugin.h"
+#include "editor/type_db.h"
 #include "scene/resources/texture.h"
 
 class EditorHistory {
@@ -110,7 +111,8 @@ class EditorData {
 public:
 	struct CustomType {
 
-		String name;
+		StringName name;
+		StringName base;
 		Ref<Script> script;
 		Ref<Texture> icon;
 	};
@@ -129,12 +131,15 @@ class EditorData {
 private:
 	Vector<EditorPlugin *> editor_plugins;
 
+	TypeDB type_db;
+
 	struct PropertyData {
 
 		String name;
 		Variant value;
 	};
-	Map<String, Vector<CustomType> > custom_types;
+	//Map<String, Vector<CustomType> > custom_types;
+	HashMap<StringName, CustomType> custom_types;
 
 	List<PropertyData> clipboard;
 	UndoRedo undo_redo;
@@ -149,11 +154,16 @@ class EditorData {
 	HashMap<StringName, String> _script_class_icon_paths;
 	HashMap<String, StringName> _script_class_file_to_path;
 
+	HashMap<StringName, List<StringName> > _inheritors_cache;
+	bool _inheritors_dirty;
+
 public:
 	EditorPlugin *get_editor(Object *p_object);
 	EditorPlugin *get_subeditor(Object *p_object);
 	Vector<EditorPlugin *> get_subeditors(Object *p_object);
 	EditorPlugin *get_editor(String p_name);
+	const TypeDB &get_type_db() { return type_db; }
+	void refresh_type_db() { type_db.refresh(); }
 
 	void copy_object_params(Object *p_object);
 	void paste_object_params(Object *p_object);
@@ -178,9 +188,15 @@ class EditorData {
 	void restore_editor_global_states();
 
 	void add_custom_type(const String &p_type, const String &p_inherits, const Ref<Script> &p_script, const Ref<Texture> &p_icon);
-	Object *instance_custom_type(const String &p_type, const String &p_inherits);
+	Object *instance_custom_type(const String &p_type);
 	void remove_custom_type(const String &p_type);
-	const Map<String, Vector<CustomType> > &get_custom_types() const { return custom_types; }
+	void get_custom_type_class_list(List<StringName> *p_classes) const;
+	StringName get_custom_type_name(const String &p_path) const;
+	Ref<Script> get_custom_type_script(const StringName &p_type) const;
+	String get_custom_type_path(const StringName &p_type) const;
+	StringName get_custom_type_base(const StringName &p_type) const;
+	Ref<Texture> get_custom_type_icon(const String &p_type) const;
+	bool is_custom_type(const StringName &p_type) const { return custom_types.has(p_type); }
 
 	int add_edited_scene(int p_at_pos);
 	void move_edited_scene_index(int p_idx, int p_to_idx);
diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp
index ae2a6d28020f..b3f1d8d3c680 100644
--- a/editor/editor_node.cpp
+++ b/editor/editor_node.cpp
@@ -535,6 +535,16 @@ void EditorNode::_fs_changed() {
 
 		_exit_editor();
 	}
+
+	get_editor_data().refresh_type_db();
+
+	List<Node *> nodes;
+	get_tree()->get_nodes_in_group("create_dialogs", &nodes);
+	for (List<Node *>::Element *E = nodes.front(); E; E = E->next()) {
+		CreateDialog *c = Object::cast_to<CreateDialog>(E->get());
+		if (c)
+			c->fs_changed();
+	}
 }
 
 void EditorNode::_resources_reimported(const Vector<String> &p_resources) {
@@ -3609,26 +3619,12 @@ Ref<Texture> EditorNode::get_object_icon(const Object *p_object, const String &p
 		script = p_object;
 	}
 
-	if (script.is_valid()) {
-		Ref<Script> base_script = script;
-		while (base_script.is_valid()) {
-			StringName name = EditorNode::get_editor_data().script_class_get_name(base_script->get_path());
-			String icon_path = EditorNode::get_editor_data().script_class_get_icon_path(name);
-			if (icon_path.length())
-				return ResourceLoader::load(icon_path);
-
-			// should probably be deprecated in 4.x
-			StringName base = base_script->get_instance_base_type();
-			if (base != StringName() && EditorNode::get_editor_data().get_custom_types().has(base)) {
-				const Vector<EditorData::CustomType> &types = EditorNode::get_editor_data().get_custom_types()[base];
-				for (int i = 0; i < types.size(); ++i) {
-					if (types[i].script == base_script && types[i].icon.is_valid()) {
-						return types[i].icon;
-					}
-				}
-			}
-			base_script = base_script->get_base_script();
-		}
+	const TypeDB &tdb = get_editor_data().get_type_db();
+	while (script.is_valid()) {
+		const String &path = script->get_path();
+		if (tdb.path_exists(path))
+			return tdb.get_icon(tdb.get_class_by_path(path));
+		script = script->get_base_script();
 	}
 
 	// should probably be deprecated in 4.x
@@ -3651,47 +3647,20 @@ Ref<Texture> EditorNode::get_class_icon(const String &p_class, const String &p_f
 		return gui_base->get_icon(p_class, "EditorIcons");
 	}
 
-	if (ScriptServer::is_global_class(p_class)) {
-		String icon_path = EditorNode::get_editor_data().script_class_get_icon_path(p_class);
-		RES icon;
-
-		if (FileAccess::exists(icon_path)) {
-			icon = ResourceLoader::load(icon_path);
-			if (icon.is_valid())
-				return icon;
-		}
-
-		Ref<Script> script = ResourceLoader::load(ScriptServer::get_global_class_path(p_class), "Script");
-
-		while (script.is_valid()) {
-			String current_icon_path;
-			script->get_language()->get_global_class_name(script->get_path(), NULL, &current_icon_path);
-			if (FileAccess::exists(current_icon_path)) {
-				RES texture = ResourceLoader::load(current_icon_path);
-				if (texture.is_valid())
-					return texture;
-			}
-			script = script->get_base_script();
-		}
-
-		if (icon.is_null()) {
-			icon = gui_base->get_icon(ScriptServer::get_global_class_base(p_class), "EditorIcons");
-		}
-
-		return icon;
+	const TypeDB &tdb = get_editor_data().get_type_db();
+	StringName type = p_class;
+	RES icon;
+	while (tdb.class_exists(type) && icon.is_null()) {
+		icon = tdb.get_icon(type);
+		type = tdb.get_parent_class(type);
 	}
-
-	const Map<String, Vector<EditorData::CustomType> > &p_map = EditorNode::get_editor_data().get_custom_types();
-	for (const Map<String, Vector<EditorData::CustomType> >::Element *E = p_map.front(); E; E = E->next()) {
-		const Vector<EditorData::CustomType> &ct = E->value();
-		for (int i = 0; i < ct.size(); ++i) {
-			if (ct[i].name == p_class) {
-				if (ct[i].icon.is_valid()) {
-					return ct[i].icon;
-				}
-			}
-		}
+	if (icon.is_null()) {
+		StringName native = tdb.get_native(p_class);
+		if (gui_base->has_icon(native))
+			icon = gui_base->get_icon(native, "EditorIcons");
 	}
+	if (icon.is_valid())
+		return icon;
 
 	if (p_fallback.length() && gui_base->has_icon(p_fallback, "EditorIcons"))
 		return gui_base->get_icon(p_fallback, "EditorIcons");
@@ -5642,6 +5611,9 @@ EditorNode::EditorNode() {
 	gui_base->set_theme(theme);
 	gui_base->add_style_override("panel", gui_base->get_stylebox("Background", "EditorStyles"));
 
+	// Now that the theme exists (with class icons), initialize the type database
+	editor_data.refresh_type_db();
+
 	resource_preview = memnew(EditorResourcePreview);
 	add_child(resource_preview);
 	progress_dialog = memnew(ProgressDialog);
diff --git a/editor/editor_properties.cpp b/editor/editor_properties.cpp
index 20ba07c102e2..28c138b616a8 100644
--- a/editor/editor_properties.cpp
+++ b/editor/editor_properties.cpp
@@ -2262,7 +2262,7 @@ void EditorPropertyResource::_menu_option(int p_which) {
 			}
 
 			if (!obj) {
-				obj = EditorNode::get_editor_data().instance_custom_type(intype, "Resource");
+				obj = EditorNode::get_editor_data().instance_custom_type(intype);
 			}
 
 			ERR_BREAK(!obj);
@@ -2322,12 +2322,6 @@ void EditorPropertyResource::_update_menu_items() {
 	} else if (base_type != "") {
 		int idx = 0;
 
-		Vector<EditorData::CustomType> custom_resources;
-
-		if (EditorNode::get_editor_data().get_custom_types().has("Resource")) {
-			custom_resources = EditorNode::get_editor_data().get_custom_types()["Resource"];
-		}
-
 		for (int i = 0; i < base_type.get_slice_count(","); i++) {
 
 			String base = base_type.get_slice(",", i);
@@ -2335,57 +2329,22 @@ void EditorPropertyResource::_update_menu_items() {
 			Set<String> valid_inheritors;
 			valid_inheritors.insert(base);
 			List<StringName> inheritors;
-			ClassDB::get_inheriters_from_class(base.strip_edges(), &inheritors);
-
-			for (int j = 0; j < custom_resources.size(); j++) {
-				inheritors.push_back(custom_resources[j].name);
-			}
+			const TypeDB &tdb = EditorNode::get_editor_data().get_type_db();
+			tdb.get_inheritors_from_class(base.strip_edges(), &inheritors);
 
-			List<StringName>::Element *E = inheritors.front();
-			while (E) {
-				valid_inheritors.insert(E->get());
-				E = E->next();
-			}
-
-			List<StringName> global_classes;
-			ScriptServer::get_global_class_list(&global_classes);
-			E = global_classes.front();
-			while (E) {
-				if (EditorNode::get_editor_data().script_class_is_parent(E->get(), base_type)) {
-					valid_inheritors.insert(E->get());
-				}
-				E = E->next();
-			}
+			for (List<StringName>::Element *F = inheritors.front(); F; F = F->next()) {
+				String t = F->get();
 
-			for (Set<String>::Element *F = valid_inheritors.front(); F; F = F->next()) {
-				const String &t = F->get();
-
-				bool is_custom_resource = false;
-				Ref<Texture> icon;
-				if (!custom_resources.empty()) {
-					for (int j = 0; j < custom_resources.size(); j++) {
-						if (custom_resources[j].name == t) {
-							is_custom_resource = true;
-							if (custom_resources[j].icon.is_valid())
-								icon = custom_resources[j].icon;
-							break;
-						}
-					}
-				}
-
-				if (!is_custom_resource && !(ScriptServer::is_global_class(t) || ClassDB::can_instance(t)))
+				if (!tdb.can_instance(t))
 					continue;
 
+				Ref<Texture> icon = EditorNode::get_singleton()->get_class_icon(t, base_type);
+
 				inheritors_array.push_back(t);
 
 				int id = TYPE_BASE_ID + idx;
 
-				if (!icon.is_valid() && has_icon(t, "EditorIcons")) {
-					icon = get_icon(t, "EditorIcons");
-				}
-
 				if (icon.is_valid()) {
-
 					menu->add_icon_item(icon, vformat(TTR("New %s"), t), id);
 				} else {
 
diff --git a/editor/property_editor.cpp b/editor/property_editor.cpp
index 899343c0f8dc..064721a3e5da 100644
--- a/editor/property_editor.cpp
+++ b/editor/property_editor.cpp
@@ -291,7 +291,7 @@ void CustomPropertyEditor::_menu_option(int p_which) {
 						if (ScriptServer::is_global_class(intype)) {
 							obj = EditorNode::get_editor_data().script_class_instance(intype);
 						} else {
-							obj = EditorNode::get_editor_data().instance_custom_type(intype, "Resource");
+							obj = EditorNode::get_editor_data().instance_custom_type(intype);
 						}
 					}
 
@@ -891,12 +891,6 @@ bool CustomPropertyEditor::edit(Object *p_owner, const String &p_name, Variant::
 			} else if (hint_text != "") {
 				int idx = 0;
 
-				Vector<EditorData::CustomType> custom_resources;
-
-				if (EditorNode::get_editor_data().get_custom_types().has("Resource")) {
-					custom_resources = EditorNode::get_editor_data().get_custom_types()["Resource"];
-				}
-
 				for (int i = 0; i < hint_text.get_slice_count(","); i++) {
 
 					String base = hint_text.get_slice(",", i);
@@ -904,47 +898,22 @@ bool CustomPropertyEditor::edit(Object *p_owner, const String &p_name, Variant::
 					Set<String> valid_inheritors;
 					valid_inheritors.insert(base);
 					List<StringName> inheritors;
-					ClassDB::get_inheriters_from_class(base.strip_edges(), &inheritors);
-
-					for (int j = 0; j < custom_resources.size(); j++) {
-						inheritors.push_back(custom_resources[j].name);
-					}
-
-					List<StringName>::Element *E = inheritors.front();
-					while (E) {
-						valid_inheritors.insert(E->get());
-						E = E->next();
-					}
+					const TypeDB &tdb = EditorNode::get_editor_data().get_type_db();
+					tdb.get_inheritors_from_class(base.strip_edges(), &inheritors);
 
-					for (Set<String>::Element *j = valid_inheritors.front(); j; j = j->next()) {
-						const String &t = j->get();
-
-						bool is_custom_resource = false;
-						Ref<Texture> icon;
-						if (!custom_resources.empty()) {
-							for (int k = 0; k < custom_resources.size(); k++) {
-								if (custom_resources[k].name == t) {
-									is_custom_resource = true;
-									if (custom_resources[k].icon.is_valid())
-										icon = custom_resources[k].icon;
-									break;
-								}
-							}
-						}
+					for (List<StringName>::Element *j = inheritors.front(); j; j = j->next()) {
+						String t = j->get();
 
-						if (!is_custom_resource && !ClassDB::can_instance(t))
+						if (!tdb.can_instance(t))
 							continue;
 
+						Ref<Texture> icon = EditorNode::get_singleton()->get_class_icon(t, base);
+
 						inheritors_array.push_back(t);
 
 						int id = TYPE_BASE_ID + idx;
 
-						if (!icon.is_valid() && has_icon(t, "EditorIcons")) {
-							icon = get_icon(t, "EditorIcons");
-						}
-
 						if (icon.is_valid()) {
-
 							menu->add_icon_item(icon, vformat(TTR("New %s"), t), id);
 						} else {
 
@@ -1144,7 +1113,7 @@ void CustomPropertyEditor::_type_create_selected(int p_idx) {
 			if (ScriptServer::is_global_class(intype)) {
 				obj = EditorNode::get_editor_data().script_class_instance(intype);
 			} else {
-				obj = EditorNode::get_editor_data().instance_custom_type(intype, "Resource");
+				obj = EditorNode::get_editor_data().instance_custom_type(intype);
 			}
 		}
 
@@ -1350,7 +1319,7 @@ void CustomPropertyEditor::_action_pressed(int p_which) {
 						if (ScriptServer::is_global_class(intype)) {
 							obj = EditorNode::get_editor_data().script_class_instance(intype);
 						} else {
-							obj = EditorNode::get_editor_data().instance_custom_type(intype, "Resource");
+							obj = EditorNode::get_editor_data().instance_custom_type(intype);
 						}
 					}
 
diff --git a/editor/type_db.cpp b/editor/type_db.cpp
new file mode 100644
index 000000000000..578d4cfe711e
--- /dev/null
+++ b/editor/type_db.cpp
@@ -0,0 +1,217 @@
+/*************************************************************************/
+/*  type_db.cpp                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "editor/type_db.h"
+#include "editor/editor_node.h"
+
+void TypeDB::refresh() {
+	type_map.clear();
+	path_map.clear();
+	const EditorData &ed = EditorNode::get_editor_data();
+
+	List<StringName> types;
+	ClassDB::get_class_list(&types);
+	for (List<StringName>::Element *E = types.front(); E; E = E->next()) {
+		TypeInfo ti;
+		StringName n = E->get();
+
+		ti.name = n;
+		ti.base = ClassDB::get_parent_class(n);
+		ti.native = n;
+		ti.source = SOURCE_ENGINE;
+
+		type_map[ti.name] = ti;
+	}
+	for (List<StringName>::Element *E = types.front(); E; E = E->next()) {
+		StringName n = E->get();
+		type_map[n].icon = EditorNode::get_singleton()->get_class_icon(n);
+	}
+	types.clear();
+	ScriptServer::get_global_class_list(&types);
+	for (List<StringName>::Element *E = types.front(); E; E = E->next()) {
+		TypeInfo ti;
+		StringName n = E->get();
+
+		ti.name = n;
+		ti.script = ResourceLoader::load(ScriptServer::get_global_class_path(n));
+		if (ti.script.is_null())
+			continue;
+		String icon_path = ed.script_class_get_icon_path(n);
+		if (icon_path.length())
+			ti.icon = ResourceLoader::load(ScriptServer::get_global_class_path(n));
+		ti.native = ti.script->get_instance_base_type();
+		ti.base = ScriptServer::get_global_class_base(n);
+		ti.source = SOURCE_SCRIPT_CLASS;
+
+		type_map[ti.name] = ti;
+		path_map[ti.script->get_path()] = ti.name;
+	}
+	types.clear();
+	ed.get_custom_type_class_list(&types);
+	for (List<StringName>::Element *E = types.front(); E; E = E->next()) {
+		TypeInfo ti;
+		StringName n = E->get();
+
+		ti.name = n;
+		ti.script = ResourceLoader::load(ScriptServer::get_global_class_path(n));
+		if (ti.script.is_null())
+			continue;
+		RES icon = ed.get_custom_type_icon(n);
+		if (icon.is_valid())
+			ti.icon = icon;
+		ti.native = ti.script->get_instance_base_type();
+		ti.base = ed.get_custom_type_base(n);
+		ti.source = SOURCE_CUSTOM_TYPE;
+
+		type_map[ti.name] = ti;
+		path_map[ti.script->get_path()] = ti.name;
+	}
+	//types.clear();
+	//List<String> paths;
+	//path_map.get_key_list(&paths);
+	//for (List<String>::Element *E = paths.front(); E; E = E->next()) {
+	//	TypeInfo &ti = type_map[path_map[E->get()]];
+	//	if (ti.base == StringName())
+	//		continue;
+	//	Ref<Script> script = ti.script;
+	//	if (script.is_null())
+	//		continue;
+	//	script = script->get_base_script();
+	//	while (script.is_valid()) {
+	//		const String &p = script->get_path();
+	//		if (path_map.has(p)) {
+	//			ti.base = path_map[p];
+	//			break;
+	//		}
+	//	}
+	//	if (script.is_null())
+	//		ti.base = ti.native;
+	//}
+}
+
+bool TypeDB::class_exists(const StringName &p_type) const {
+	return type_map.has(p_type);
+}
+
+bool TypeDB::path_exists(const String &p_path) const {
+	return path_map.has(p_path);
+}
+
+StringName TypeDB::get_class_by_path(const String &p_path) const {
+	return path_exists(p_path) ? path_map[p_path] : StringName();
+}
+
+String TypeDB::get_path_by_class(const StringName &p_type) const {
+	if (!class_exists(p_type))
+		return String();
+	Ref<Script> script = type_map[p_type].script;
+	if (script.is_null())
+		return String();
+	return script->get_path();
+}
+
+StringName TypeDB::get_native(const StringName &p_type) const {
+	ERR_FAIL_COND_V(!type_map.has(p_type), StringName());
+	return type_map[p_type].native;
+}
+
+Object *TypeDB::instance(const StringName &p_type) const {
+	ERR_FAIL_COND_V(!type_map.has(p_type), NULL);
+
+	const TypeInfo &ti = type_map[p_type];
+
+	switch (ti.source) {
+		case SOURCE_ENGINE: {
+			return ClassDB::instance(ti.name);
+		} break;
+		case SOURCE_SCRIPT_CLASS:
+		case SOURCE_CUSTOM_TYPE: {
+			Object *obj = ClassDB::instance(ti.native);
+			if (!obj)
+				return NULL;
+			if (ti.script.is_null())
+				return NULL;
+			obj->set_script(ti.script.get_ref_ptr());
+			return obj;
+		} break;
+		case SOURCE_NONE: {
+			return NULL;
+		} break;
+	}
+	return NULL;
+}
+
+RES TypeDB::get_icon(const StringName &p_type) const {
+	ERR_FAIL_COND_V(!type_map.has(p_type), NULL);
+	return type_map[p_type].icon;
+}
+
+bool TypeDB::can_instance(const StringName &p_type) const {
+	ERR_FAIL_COND_V(!type_map.has(p_type), false);
+	return ClassDB::can_instance(type_map[p_type].native);
+}
+
+void TypeDB::get_class_list(List<StringName> *p_class_list) const {
+	type_map.get_key_list(p_class_list);
+}
+
+bool TypeDB::is_parent_class(const String &p_type, const String &p_inherits) const {
+	ERR_FAIL_COND_V(!type_map.has(p_type), false);
+	const TypeInfo *ti = &type_map[p_type];
+	while (ti) {
+		if (ti->name == p_inherits)
+			return true;
+		ti = type_map.has(ti->base) ? &type_map[ti->base] : NULL;
+	}
+	return false;
+}
+
+String TypeDB::get_parent_class(const String &p_type) const {
+	ERR_FAIL_COND_V(!type_map.has(p_type), String());
+	return type_map[p_type].base;
+}
+
+void TypeDB::get_inheritors_from_class(const String &p_type, List<StringName> *p_classes) const {
+	ERR_FAIL_COND(!type_map.has(p_type));
+	ERR_FAIL_COND(!p_classes);
+
+	const TypeInfo &ti = type_map[p_type];
+	List<StringName> types;
+	type_map.get_key_list(&types);
+	for (List<StringName>::Element *E = types.front(); E; E = E->next()) {
+		const TypeInfo &a_ti = type_map[E->get()];
+		if (is_parent_class(a_ti.name, ti.name))
+			p_classes->push_back(a_ti.name);
+	}
+}
+
+void TypeDB::_bind_methods() {}
+
+TypeDB::TypeDB() {}
\ No newline at end of file
diff --git a/editor/type_db.h b/editor/type_db.h
new file mode 100644
index 000000000000..b789687a3709
--- /dev/null
+++ b/editor/type_db.h
@@ -0,0 +1,87 @@
+/*************************************************************************/
+/*  type_db.h                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef TYPE_DB_H
+#define TYPE_DB_H
+
+#include "core/script_language.h"
+#include "core/ustring.h"
+
+class TypeDB : public Reference {
+	GDCLASS(TypeDB, Reference);
+
+	enum {
+		SOURCE_NONE,
+		SOURCE_ENGINE,
+		SOURCE_SCRIPT_CLASS,
+		SOURCE_CUSTOM_TYPE
+	};
+
+	struct TypeInfo {
+		StringName name;
+		StringName base;
+		StringName native;
+		Ref<Script> script;
+		RES icon;
+		int source = SOURCE_NONE;
+	};
+
+	typedef HashMap<StringName, TypeInfo> TypeMap;
+	typedef HashMap<String, StringName> PathMap;
+
+	TypeMap type_map;
+	PathMap path_map;
+
+protected:
+	static void _bind_methods();
+
+public:
+	void refresh();
+
+	bool path_exists(const String &p_path) const;
+	StringName get_class_by_path(const String &p_path) const;
+	String get_path_by_class(const StringName &p_type) const;
+	StringName get_native(const StringName &p_type) const;
+
+	RES get_icon(const StringName &p_type) const;
+
+	Object *instance(const StringName &p_type) const;
+	bool can_instance(const StringName &p_type) const;
+
+	bool class_exists(const StringName &p_type) const;
+	void get_class_list(List<StringName> *p_class_list) const;
+	bool is_parent_class(const String &p_type, const String &p_inherits) const;
+	String get_parent_class(const String &p_type) const;
+	void get_inheritors_from_class(const String &p_type, List<StringName> *p_classes) const;
+
+	TypeDB();
+};
+
+#endif // TYPE_DB_H
\ No newline at end of file