diff --git a/core/script_language.cpp b/core/script_language.cpp
index 1dab58e29eb7..2128498697ee 100644
--- a/core/script_language.cpp
+++ b/core/script_language.cpp
@@ -37,6 +37,17 @@ bool ScriptServer::scripting_enabled = true;
 bool ScriptServer::reload_scripts_on_save = false;
 ScriptEditRequestFunction ScriptServer::edit_request_func = NULL;
 
+Dictionary Script::get_script_metadata() {
+	if (has_method("_get_script_metadata")) {
+		Variant::CallError ce;
+		Variant ret = call("_get_script_metadata", NULL, 0, ce);
+		if (ce.error = Variant::CallError::CALL_OK) {
+			return (Dictionary)ret;
+		}
+	}
+	return Dictionary();
+}
+
 void Script::_notification(int p_what) {
 
 	if (p_what == NOTIFICATION_POSTINITIALIZE) {
@@ -62,6 +73,8 @@ void Script::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("is_tool"), &Script::is_tool);
 
+	ClassDB::add_virtual_method(get_class_static(), MethodInfo("_get_script_metadata"));
+
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "source_code", PROPERTY_HINT_NONE, "", 0), "set_source_code", "get_source_code");
 }
 
diff --git a/core/script_language.h b/core/script_language.h
index ad66fc552835..36f1cb2376f0 100644
--- a/core/script_language.h
+++ b/core/script_language.h
@@ -118,13 +118,15 @@ class Script : public Resource {
 
 	virtual void update_exports() {} //editor tool
 	virtual void get_script_method_list(List<MethodInfo> *p_list) const = 0;
-	virtual void get_script_property_list(List<PropertyInfo> *p_list) const = 0;
+	virtual void get_script_property_list(List<PropertyInfo> *p_list, bool p_no_inherited = false) const = 0;
 
 	virtual int get_member_line(const StringName &p_member) const { return -1; }
 
 	virtual void get_constants(Map<StringName, Variant> *p_constants) {}
 	virtual void get_members(Set<StringName> *p_constants) {}
 
+	virtual Dictionary get_script_metadata();
+
 	Script() {}
 };
 
diff --git a/core/ustring.cpp b/core/ustring.cpp
index 51f05468e253..e1d087acee18 100644
--- a/core/ustring.cpp
+++ b/core/ustring.cpp
@@ -590,6 +590,23 @@ String String::camelcase_to_underscore(bool lowercase) const {
 	return lowercase ? new_string.to_lower() : new_string;
 }
 
+String String::typenamify() const {
+	String name = get_file().get_basename().strip_edges();
+	String result;
+
+	for (int i = 0; i < name.length() && name[i] == '_'; i++) {
+		result += '_';
+	}
+
+	result += name.capitalize().replace("_", "").replace(" ", "");
+
+	for (int i = name.length() - 1; i > 0 && name[i] == '_'; i++) {
+		result += '_';
+	}
+
+	return result;
+}
+
 int String::get_slice_count(String p_splitter) const {
 
 	if (empty())
diff --git a/core/ustring.h b/core/ustring.h
index b57e9629d947..98b55024043c 100644
--- a/core/ustring.h
+++ b/core/ustring.h
@@ -166,6 +166,7 @@ class String : public Vector<CharType> {
 	static int64_t to_int(const CharType *p_str, int p_len = -1);
 	String capitalize() const;
 	String camelcase_to_underscore(bool lowercase = true) const;
+	String typenamify() const;
 
 	int get_slice_count(String p_splitter) const;
 	String get_slice(String p_splitter, int p_slice) const;
diff --git a/editor/create_dialog.cpp b/editor/create_dialog.cpp
index 36978e37a581..2442f6d1c9f9 100644
--- a/editor/create_dialog.cpp
+++ b/editor/create_dialog.cpp
@@ -40,6 +40,8 @@
 
 void CreateDialog::popup_create(bool p_dont_clear, bool p_replace_mode) {
 
+	update_types();
+
 	recent->clear();
 
 	FileAccess *f = FileAccess::open(EditorSettings::get_singleton()->get_project_settings_dir().plus_file("create_recent." + base_type), FileAccess::READ);
@@ -53,6 +55,9 @@ void CreateDialog::popup_create(bool p_dont_clear, bool p_replace_mode) {
 
 			if (l != String()) {
 
+				if (!ClassDB::class_exists(l) && !EditorNode::get_singleton()->get_editor_data().get_type_db().class_exists(l)) {
+					continue;
+				}
 				TreeItem *ti = recent->create_item(root);
 				ti->set_text(0, l);
 				ti->set_icon(0, _get_editor_icon(l));
@@ -74,6 +79,9 @@ void CreateDialog::popup_create(bool p_dont_clear, bool p_replace_mode) {
 			String l = f->get_line().strip_edges();
 
 			if (l != String()) {
+				if (!ClassDB::class_exists(l) && !EditorNode::get_singleton()->get_editor_data().get_type_db().class_exists(l)) {
+					continue;
+				}
 				favorite_list.push_back(l);
 			}
 		}
@@ -133,6 +141,13 @@ void CreateDialog::_text_changed(const String &p_newtext) {
 	_update_search();
 }
 
+void CreateDialog::update_types() {
+	type_list.clear();
+	ClassDB::get_class_list(&type_list);
+	EditorNode::get_singleton()->get_editor_data().get_type_db().get_class_list(&type_list);
+	type_list.sort_custom<StringName::AlphCompare>();
+}
+
 void CreateDialog::_sbox_input(const Ref<InputEvent> &p_ie) {
 
 	Ref<InputEventKey> k = p_ie;
@@ -152,18 +167,14 @@ Ref<Texture> CreateDialog::_get_editor_icon(const String &p_type) const {
 		return get_icon(p_type, "EditorIcons");
 	}
 
-	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_type) {
-				if (ct[i].icon.is_valid()) {
-					return ct[i].icon;
-				} else {
-					return get_icon("Object", "EditorIcons");
-				}
-			}
-		}
+	EditorData::TypeDbTypes db_type = (EditorData::TypeDbTypes)(EditorData::TYPEDB_TYPE_SCRIPT | EditorData::TYPEDB_TYPE_SCENE);
+	if (EditorNode::get_editor_data().get_type_db().class_exists(p_type, db_type)) {
+		const EditorData::TypeInfo *ti = EditorNode::get_editor_data().get_type_db().get_type_info(p_type, db_type);
+		Ref<Texture> icon = ti->icon;
+		if (icon.is_valid())
+			return icon;
+		if (has_icon(ti->base, "EditorIcons"))
+			return get_icon(ti->base, "EditorIcons");
 	}
 
 	return get_icon("Object", "EditorIcons");
@@ -171,12 +182,17 @@ Ref<Texture> CreateDialog::_get_editor_icon(const String &p_type) const {
 
 void CreateDialog::add_type(const String &p_type, HashMap<String, TreeItem *> &p_types, TreeItem *p_root, TreeItem **to_select) {
 
+	EditorData::TypeDB &tdb = EditorNode::get_editor_data().get_type_db();
+
 	if (p_types.has(p_type))
 		return;
-	if (!ClassDB::is_parent_class(p_type, base_type) || p_type == base_type)
+	if (p_type == base_type)
 		return;
+	if (ClassDB::class_exists(p_type) ? !ClassDB::is_parent_class(p_type, base_type) : !tdb.is_parent_class(p_type, base_type)) {
+		return;
+	}
 
-	String inherits = ClassDB::get_parent_class(p_type);
+	String inherits = ClassDB::class_exists(p_type) ? ClassDB::get_parent_class(p_type) : tdb.get_parent_class(p_type);
 
 	TreeItem *parent = p_root;
 
@@ -191,20 +207,29 @@ void CreateDialog::add_type(const String &p_type, HashMap<String, TreeItem *> &p
 			parent = p_types[inherits];
 	}
 
+	String type_text = p_type;
+
 	TreeItem *item = search_options->create_item(parent);
-	item->set_text(0, p_type);
-	if (!ClassDB::can_instance(p_type)) {
+	item->set_text(0, type_text);
+	if (tdb.is_custom(p_type, EditorData::TYPEDB_TYPE_ALL))
+		item->set_metadata(0, p_type);
+	if ((ClassDB::class_exists(p_type) && !ClassDB::can_instance(p_type)) || (tdb.class_exists(p_type) && !tdb.can_instance(p_type))) {
 		item->set_custom_color(0, get_color("disabled_font_color", "Editor"));
 		item->set_selectable(0, false);
 	} else {
 		bool is_search_subsequence = search_box->get_text().is_subsequence_ofi(p_type);
 		String to_select_type = *to_select ? (*to_select)->get_text(0) : "";
-		bool current_item_is_preffered = ClassDB::is_parent_class(p_type, preferred_search_result_type) && !ClassDB::is_parent_class(to_select_type, preferred_search_result_type);
+		bool current_item_is_preferred;
+		if (tdb.class_exists(p_type)) {
+			current_item_is_preferred = tdb.is_parent_class(p_type, preferred_search_result_type) && !tdb.is_parent_class(to_select_type, preferred_search_result_type);
+		} else {
+			current_item_is_preferred = ClassDB::is_parent_class(p_type, preferred_search_result_type) && !ClassDB::is_parent_class(to_select_type, preferred_search_result_type);
+		}
 		if (*to_select && p_type.length() < (*to_select)->get_text(0).length()) {
-			current_item_is_preffered = true;
+			current_item_is_preferred = true;
 		}
 
-		if (((!*to_select || current_item_is_preffered) && is_search_subsequence) || search_box->get_text() == p_type) {
+		if (((!*to_select || current_item_is_preferred) && is_search_subsequence) || search_box->get_text() == p_type) {
 			*to_select = item;
 		}
 	}
@@ -217,18 +242,17 @@ void CreateDialog::add_type(const String &p_type, HashMap<String, TreeItem *> &p
 		// don't collapse the root node
 		collapse &= (item != p_root);
 		// don't collapse abstract nodes on the first tree level
-		collapse &= ((parent != p_root) || (ClassDB::can_instance(p_type)));
+		collapse &= ((parent != p_root) || (tdb.can_instance(p_type)));
 		item->set_collapsed(collapse);
 	}
 
-	const String &description = EditorHelp::get_doc_data()->class_list[p_type].brief_description;
-	item->set_tooltip(0, description);
-
-	if (has_icon(p_type, "EditorIcons")) {
-
-		item->set_icon(0, get_icon(p_type, "EditorIcons"));
+	if (EditorHelp::get_doc_data()->class_list.has(p_type)) {
+		const String &description = EditorHelp::get_doc_data()->class_list[p_type].brief_description;
+		item->set_tooltip(0, description);
 	}
 
+	item->set_icon(0, _get_editor_icon(p_type));
+
 	p_types[p_type] = item;
 }
 
@@ -244,6 +268,7 @@ void CreateDialog::_update_search() {
 */
 
 	HashMap<String, TreeItem *> types;
+	EditorData::TypeDB &tdb = EditorNode::get_singleton()->get_editor_data().get_type_db();
 
 	TreeItem *root = search_options->create_item();
 
@@ -259,14 +284,19 @@ void CreateDialog::_update_search() {
 
 		String type = I->get();
 
+		bool is_tdb_type = tdb.class_exists(type);
+
 		if (base_type == "Node" && type.begins_with("Editor"))
 			continue; // do not show editor nodes
 
-		if (base_type == "Resource" && ClassDB::is_parent_class(type, "PluginScript"))
+		if (base_type == "Resource" && ClassDB::class_exists(type) && ClassDB::is_parent_class(type, "PluginScript"))
 			// PluginScript must be initialized before use, which is not possible here
 			continue;
 
-		if (!ClassDB::can_instance(type))
+		if (is_tdb_type) {
+			if (!tdb.is_custom(type) || !tdb.can_instance(type))
+				continue;
+		} else if (!ClassDB::can_instance(type))
 			continue; // can't create what can't be instanced
 
 		if (search_box->get_text() == "") {
@@ -274,53 +304,60 @@ void CreateDialog::_update_search() {
 		} else {
 
 			bool found = false;
-			String type = I->get();
-			while (type != "" && ClassDB::is_parent_class(type, base_type) && type != base_type) {
+			while (type != "" && type != base_type && (is_tdb_type && tdb.is_parent_class(type, base_type)) || (!is_tdb_type && ClassDB::is_parent_class(type, base_type))) {
 				if (search_box->get_text().is_subsequence_ofi(type)) {
 
 					found = true;
 					break;
 				}
 
-				type = ClassDB::get_parent_class(type);
+				String new_type = tdb.get_parent_class(type);
+				if (new_type.empty())
+					new_type = ClassDB::class_exists(type) ? ClassDB::get_parent_class(type) : "";
+				type = new_type;
 			}
 
 			if (found)
 				add_type(I->get(), 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.
+		//if (EditorNode::get_editor_data().get_custom_type_db().class_exists(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++) {
+		//	const HashMap<StringName, EditorData::CustomType, StringNameHasher> *cts = &EditorNode::get_editor_data().get_custom_types();
+		//	const EditorData::CustomType &ct = (*cts)[type];
 
-				bool show = search_box->get_text().is_subsequence_ofi(ct[i].name);
+		//	for (int i = 0; i < ct.sub_types.size(); i++) {
 
-				if (!show)
-					continue;
+		//		StringName sn = ct.sub_types[i];
+		//		const EditorData::CustomType &sub = (*cts)[sn];
 
-				if (!types.has(type))
-					add_type(type, types, root, &to_select);
+		//		bool show = search_box->get_text().is_subsequence_ofi(sub.name);
 
-				TreeItem *ti;
-				if (types.has(type))
-					ti = types[type];
-				else
-					ti = search_options->get_root();
+		//		if (!show)
+		//			continue;
 
-				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 (!types.has(type))
+		//			add_type(type, types, root, &to_select);
 
-				if (!to_select || ct[i].name == search_box->get_text()) {
-					to_select = item;
-				}
-			}
-		}
+		//		TreeItem *ti;
+		//		if (types.has(type))
+		//			ti = types[type];
+		//		else
+		//			ti = search_options->get_root();
+
+		//		TreeItem *item = search_options->create_item(ti);
+		//		item->set_metadata(0, type);
+		//		item->set_text(0, sub.name);
+		//		if (sub.icon.is_valid()) {
+		//			item->set_icon(0, sub.icon);
+		//		}
+
+		//		if (!to_select || sub.name == search_box->get_text()) {
+		//			to_select = item;
+		//		}
+		//	}
+		//}
 	}
 
 	if (search_box->get_text() == "") {
@@ -440,7 +477,24 @@ Object *CreateDialog::instance_selected() {
 			custom = md;
 
 		if (custom != String()) {
-			return EditorNode::get_editor_data().instance_custom_type(selected->get_text(0), custom);
+			const EditorData::TypeDB &tdb = EditorNode::get_editor_data().get_type_db();
+			EditorData::TypeDbTypes db_type = EditorData::TYPEDB_TYPE_SCRIPT;
+			if (tdb.class_exists(custom, db_type)) {
+
+				const EditorData::TypeInfo *ti = tdb.get_type_info(custom, db_type);
+				Object *ob = ClassDB::instance(ti->base);
+				ERR_FAIL_COND_V(!ob, NULL);
+
+				RES r(ResourceLoader::load(ti->path));
+				ob->set_script(r.get_ref_ptr());
+
+				if (ob->is_class("Node"))
+					ob->call("set_name", String(ti->type_name).get_file());
+				if (ti->icon.is_valid())
+					ob->set_meta("_editor_icon", ti->icon);
+
+				return ob;
+			}
 		} else {
 			return ClassDB::instance(selected->get_text(0));
 		}
@@ -629,6 +683,7 @@ void CreateDialog::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("_favorite_selected"), &CreateDialog::_favorite_selected);
 	ClassDB::bind_method(D_METHOD("_history_activated"), &CreateDialog::_history_activated);
 	ClassDB::bind_method(D_METHOD("_favorite_activated"), &CreateDialog::_favorite_activated);
+	ClassDB::bind_method(D_METHOD("update_types"), &CreateDialog::update_types);
 
 	ClassDB::bind_method("get_drag_data_fw", &CreateDialog::get_drag_data_fw);
 	ClassDB::bind_method("can_drop_data_fw", &CreateDialog::can_drop_data_fw);
@@ -641,8 +696,7 @@ CreateDialog::CreateDialog() {
 
 	is_replace_mode = false;
 
-	ClassDB::get_class_list(&type_list);
-	type_list.sort_custom<StringName::AlphCompare>();
+	update_types();
 
 	set_resizable(true);
 
diff --git a/editor/create_dialog.h b/editor/create_dialog.h
index da17dcbe8931..9ac1c903b282 100644
--- a/editor/create_dialog.h
+++ b/editor/create_dialog.h
@@ -101,6 +101,8 @@ class CreateDialog : public ConfirmationDialog {
 
 	void popup_create(bool p_dont_clear, bool p_replace_mode = false);
 
+	void update_types();
+
 	CreateDialog();
 };
 
diff --git a/editor/doc/doc_data.cpp b/editor/doc/doc_data.cpp
index 542dca74e05e..859c545dbf8c 100644
--- a/editor/doc/doc_data.cpp
+++ b/editor/doc/doc_data.cpp
@@ -647,6 +647,138 @@ void DocData::generate(bool p_basic_types) {
 	}
 }
 
+String DocData::get_script_xml(Ref<Script> &p_script) {
+	String className = p_script->get_path().get_file().get_basename().typenamify();
+	Dictionary vi = Engine::get_singleton()->get_version_info();
+	String version = String(vi["major"]) + "." + String(vi["minor"]);
+	String category = p_script->get_path().find("res://addons/") != String::npos ? "Plugin" : "Project";
+
+	//unable to isolate only the current script's methods/signals/constants
+	List<PropertyInfo> plist;
+	p_script->get_script_property_list(&plist, true);
+	List<MethodInfo> mlist;
+	p_script->get_script_method_list(&mlist);
+	List<MethodInfo> slist;
+	p_script->get_script_signal_list(&slist);
+	Map<StringName, Variant> cmap;
+	p_script->get_constants(&cmap);
+
+	String header = "";
+	header += "< ? xml version = \"1.0\" encoding = \"UTF-8\" ? >\n";
+	header += "<class name = \"" + className + "\" category = \"" + category + "\" version = \"" + version + "\">\n";
+
+	String content;
+	content += "\t<brief_description>\n";
+	content += "\t</brief_description>\n";
+	content += "\t<description>\n";
+	content += "\t</description>\n";
+	content += "\t<tutorials>\n";
+	content += "\t</tutorials>\n";
+	content += "\t<demos>\n";
+	content += "\t</demos>\n";
+
+	content += "\t<methods>\n";
+	for (List<MethodInfo>::Element *M = mlist.front(); M; M = M->next()) {
+		MethodInfo &mi = M->get();
+		content += "\t\tmethod name=\"" + mi.name + "\"";
+		String qualifiers = "";
+		if (mi.flags & METHOD_FLAG_CONST) {
+			if (qualifiers.length())
+				qualifiers += " ";
+			qualifiers += "const";
+		}
+		if (mi.flags & METHOD_FLAG_VIRTUAL) {
+			if (qualifiers.length())
+				qualifiers += " ";
+			qualifiers += "virtual";
+		}
+		if (mi.flags & METHOD_FLAG_VARARG) {
+			if (qualifiers.length())
+				qualifiers += " ";
+			qualifiers += "vararg";
+		}
+		if (qualifiers.length())
+			content += " " + qualifiers;
+		content += ">\n";
+
+		String class_name = "";
+		String ret_type = Variant::get_type_name(mi.return_val.type);
+		if (mi.return_val.type == Variant::NIL) {
+			ret_type = mi.return_val.usage & PROPERTY_USAGE_NIL_IS_VARIANT ? "Variant" : "void";
+		} else if (mi.return_val.class_name != StringName()) {
+			ret_type = mi.return_val.class_name;
+		} else if (mi.return_val.hint == PROPERTY_HINT_RESOURCE_TYPE) {
+			ret_type = mi.return_val.hint_string;
+		}
+		content += "\t\t\t<return type=\"" + ret_type + "\"";
+		content += (mi.return_val.usage & PROPERTY_USAGE_CLASS_IS_ENUM ? " enum=\"" + mi.return_val.class_name + "\"" : "") + ">";
+		content += "\t\t\t</return>";
+
+		int idx = 0;
+		for (List<PropertyInfo>::Element *E = mi.arguments.front(); E; E = E->next()) {
+			PropertyInfo &pi = E->get();
+			content += "\t\t\t<argument index=\"" + itos(idx++) + "\" name=\"" + pi.name + "\" type=\"" + (pi.type == Variant::OBJECT ? String(pi.class_name) : Variant::get_type_name(pi.type));
+			//TODO: check for default, and insert it if it exists
+			content += "\">\n";
+			content += "\t\t\t</argument>\n";
+		}
+		content += "\t\t\t<description>\n";
+		content += "\t\t\t</description>\n";
+
+		content += "\t\t</method>\n";
+	}
+	content += "\t</methods>\n";
+
+	content += "\t<members>\n";
+	for (List<PropertyInfo>::Element *P = plist.front(); P; P = P->next()) {
+		PropertyInfo &pi = P->get();
+		String getter_prefix = pi.type == Variant::BOOL ? "is_" : "get_";
+		content += "\t\t<member name=\"" + pi.name + "\" type=\"" + Variant::get_type_name(pi.type) + "\"";
+		content += " setter=\"set_" + pi.name + "\" getter=\"" + getter_prefix + pi.name + "\"";
+		content += (pi.hint & PROPERTY_HINT_ENUM ? " enum=\"" + pi.hint_string + "\"" : "") + String(">\n");
+		content += "\t\t</member>";
+	}
+	content += "\t</members>\n";
+
+	content += "\t<signals>\n";
+	for (List<MethodInfo>::Element *S = slist.front(); S; S = S->next()) {
+		MethodInfo &mi = S->get();
+
+		content += "\t\t<signal name=\"" + mi.name + "\">\n";
+
+		int idx = 0;
+		for (List<PropertyInfo>::Element *E = mi.arguments.front(); E; E = E->next()) {
+			PropertyInfo &pi = E->get();
+			content += "\t\t\t<argument index=\"" + itos(idx++) + "\" name=\"" + pi.name + "\" type=\"" + Variant::get_type_name(pi.type);
+			//TODO: check for default, and insert it if it exists
+			content += "\">\n";
+			content += "\t\t\t</argument>\n";
+		}
+		content += "\t\t\t<description>\n";
+		content += "\t\t\t</description>\n";
+
+		content += "\t\t</signal>\n";
+	}
+	content += "\t</signals>\n";
+
+	String constants = "";
+	for (Map<StringName, Variant>::Element *C = cmap.front(); C; C = C->next()) {
+		String cname = C->get();
+		if (cmap[cname].get_type() == Variant::INT) {
+			constants += "\t\t<constant name=\"" + cname + "\" value=\"" + String(cmap[cname]) + "\">\n";
+		}
+	}
+	if (constants.length()) {
+		content += "\t<constants>\n" + constants + "\t</constants>\n";
+	}
+
+	String footer = "</class>\n";
+
+	content = header + content + footer;
+
+	return content;
+}
+
 static Error _parse_methods(Ref<XMLParser> &parser, Vector<DocData::MethodDoc> &methods) {
 
 	String section = parser->get_node_name();
diff --git a/editor/doc/doc_data.h b/editor/doc/doc_data.h
index c7b70b5fb953..d89f30cb9555 100644
--- a/editor/doc/doc_data.h
+++ b/editor/doc/doc_data.h
@@ -35,6 +35,8 @@
 #include "map.h"
 #include "variant.h"
 
+class Script;
+
 class DocData {
 public:
 	struct ArgumentDoc {
@@ -103,6 +105,7 @@ class DocData {
 	void merge_from(const DocData &p_data);
 	void remove_from(const DocData &p_data);
 	void generate(bool p_basic_types = false);
+	static String get_script_xml(Ref<Script> &p_script);
 	Error load_classes(const String &p_dir);
 	static Error erase_classes(const String &p_dir);
 	Error save_classes(const String &p_default_path, const Map<String, String> &p_class_path);
diff --git a/editor/editor_data.cpp b/editor/editor_data.cpp
index 4dde893c6df7..3ac334cb8f23 100644
--- a/editor/editor_data.cpp
+++ b/editor/editor_data.cpp
@@ -38,6 +38,9 @@
 #include "project_settings.h"
 #include "scene/resources/packed_scene.h"
 
+#include "../modules/gdscript/gdscript.h"
+#include "../modules/regex/regex.h"
+
 void EditorHistory::cleanup_history() {
 
 	for (int i = 0; i < history.size(); i++) {
@@ -473,67 +476,484 @@ void EditorData::add_editor_plugin(EditorPlugin *p_plugin) {
 int EditorData::get_editor_plugin_count() const {
 	return editor_plugins.size();
 }
+
 EditorPlugin *EditorData::get_editor_plugin(int p_idx) {
 
 	ERR_FAIL_INDEX_V(p_idx, editor_plugins.size(), NULL);
 	return editor_plugins[p_idx];
 }
 
-void EditorData::add_custom_type(const String &p_type, const String &p_inherits, const Ref<Script> &p_script, const Ref<Texture> &p_icon) {
+void EditorData::TypeDB::_add_type(const StringName &p_type, const StringName &p_inherits, const String &p_path, const Ref<Texture> &p_icon, bool p_is_abstract, bool p_is_custom, TypeDbTypes p_db_type) {
+
+	ERR_FAIL_COND(_scripts.has(p_type));
+	ERR_FAIL_COND(!FileAccess::exists(p_path));
 
-	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>();
+	TypeInfo ti;
+	ti.type_name = p_type;
+	ti.inherits = p_inherits;
+	ti.icon = p_icon;
+	ti.is_abstract = p_is_abstract;
+	ti.is_custom = p_is_custom;
+	ti.type = p_db_type;
+	ti.path = String(p_path);
+	ti.disabled = false;
+
+	TypeMap *tm;
+	DependencyMap *dm;
+	switch (p_db_type) {
+		case TYPEDB_TYPE_SCRIPT:
+			tm = &_scripts;
+			dm = &_script_deps;
+			break;
+		case TYPEDB_TYPE_SCENE:
+			tm = &_scenes;
+			dm = &_scene_deps;
+			break;
 	}
 
-	custom_types[p_inherits].push_back(ct);
+	if (!tm->has(p_inherits) && !ClassDB::class_exists(p_inherits)) {
+		if (!dm->has(p_inherits))
+			(*dm)[p_inherits] = Vector<TypeInfo>();
+		(*dm)[p_inherits].push_back(ti);
+		return;
+	}
+	if (tm->has(ti.inherits)) {
+		TypeInfo &bti = (*tm)[ti.inherits];
+		ti.base = bti.base;
+		bti.sub_types.push_back(ti.type_name);
+	} else {
+		ti.base = ti.inherits;
+	}
+
+	_register_type_info(ti, p_db_type);
+
+	_check_for_deps(ti.type_name, p_db_type);
 }
 
-Object *EditorData::instance_custom_type(const String &p_type, const String &p_inherits) {
+void EditorData::TypeDB::_register_type_info(TypeInfo &p_ti, TypeDbTypes p_db_type) {
 
-	if (get_custom_types().has(p_inherits)) {
+	TypeMap *tm;
+	switch (p_db_type) {
+		case TYPEDB_TYPE_SCRIPT:
+			tm = &_scripts;
+			break;
+		case TYPEDB_TYPE_SCENE:
+			tm = &_scenes;
+			break;
+	}
+	(*tm)[p_ti.type_name] = p_ti;
+	_paths[p_ti.path] = &(*tm)[p_ti.type_name];
 
-		for (int i = 0; i < get_custom_types()[p_inherits].size(); i++) {
-			if (get_custom_types()[p_inherits][i].name == p_type) {
-				Ref<Texture> icon = get_custom_types()[p_inherits][i].icon;
-				Ref<Script> script = get_custom_types()[p_inherits][i].script;
+	_globals_dirty = true;
+}
 
-				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());
-				if (icon.is_valid())
-					ob->set_meta("_editor_icon", icon);
-				return ob;
+void EditorData::TypeDB::_check_for_deps(const StringName &p_type, TypeDbTypes p_db_type) {
+
+	TypeMap *tm;
+	DependencyMap *dm;
+	switch (p_db_type) {
+		case TYPEDB_TYPE_SCRIPT:
+			tm = &_scripts;
+			dm = &_script_deps;
+			break;
+		case TYPEDB_TYPE_SCENE:
+			tm = &_scenes;
+			dm = &_scene_deps;
+			break;
+	}
+
+	if (!dm->has(p_type))
+		return;
+
+	TypeInfo &ti = (*tm)[p_type];
+	Vector<TypeInfo> &tis = (*dm)[p_type];
+
+	for (int i = 0; i < tis.size(); i++) {
+		TypeInfo &dep = tis[i];
+
+		dep.base = ti.base;
+		ti.sub_types.push_back(dep.type_name);
+		_register_type_info(dep);
+		_check_for_deps(dep.type_name);
+	}
+
+	dm->erase(p_type);
+}
+
+void EditorData::TypeDB::add_script(const StringName &p_type, const StringName &p_inherits, const Ref<Script> &p_script, const Ref<Texture> &p_icon, bool p_is_abstract, bool p_is_custom) {
+	ERR_FAIL_COND(!p_script.is_valid());
+	_add_type(p_type, p_inherits, p_script->get_path(), p_icon, p_is_abstract, p_is_custom, TYPEDB_TYPE_SCRIPT);
+}
+
+void EditorData::TypeDB::add_scene(const StringName &p_type, const StringName &p_inherits, const Ref<PackedScene> &p_scene, const Ref<Texture> &p_icon, bool p_is_abstract, bool p_is_custom) {
+	ERR_FAIL_COND(!p_scene.is_valid());
+	_add_type(p_type, p_inherits, p_scene->get_path(), p_icon, p_is_abstract, p_is_custom, TYPEDB_TYPE_SCENE);
+}
+
+void EditorData::TypeDB::remove_custom_type(const StringName &p_type, TypeDbTypes p_db_types) {
+	TypeMap *tm;
+	switch (p_db_types) {
+		case TYPEDB_TYPE_SCRIPT:
+			tm = &_scripts;
+			break;
+		case TYPEDB_TYPE_SCENE:
+			tm = &_scenes;
+			break;
+	}
+
+	TypeInfo &ti = (*tm)[p_type];
+	(*tm)[ti.inherits].sub_types.erase(ti.type_name);
+	tm->erase(p_type);
+}
+
+bool EditorData::TypeDB::class_exists(const StringName &p_type, TypeDbTypes p_db_types) const {
+	if (p_db_types & TYPEDB_TYPE_SCRIPT && _scripts.has(p_type))
+		return !_scripts[p_type].disabled;
+	if (p_db_types & TYPEDB_TYPE_SCENE && _scenes.has(p_type))
+		return !_scenes[p_type].disabled;
+	return false;
+}
+
+bool EditorData::TypeDB::can_instance(const StringName &p_type, TypeDbTypes p_db_types) const {
+
+	if (p_db_types & TYPEDB_TYPE_SCRIPT && _scripts.has(p_type)) {
+		const EditorData::TypeInfo &ti = _scripts[p_type];
+		if (ti.is_abstract || ti.disabled) {
+			return false;
+		}
+		RES res = ResourceLoader::load(_scripts[p_type].path);
+		if (res->has_method("can_instance")) {
+			bool script_can_instance = res->call("can_instance").operator bool();
+			if (!script_can_instance) {
+				return false;
 			}
 		}
+		return true;
+	}
+
+	if (p_db_types & TYPEDB_TYPE_SCENE && _scenes.has(p_type)) {
+		const EditorData::TypeInfo &ti = _scenes[p_type];
+		return !(ti.is_abstract || ti.disabled);
+	}
+
+	return false;
+}
+
+Object *EditorData::TypeDB::instance(const StringName &p_type, TypeDbTypes p_db_type) {
+	ERR_FAIL_COND_V(!class_exists(p_type, p_db_type), NULL);
+
+	const EditorData::TypeInfo *ti = get_type_info(p_type, p_db_type);
+	ERR_FAIL_COND_V(!ti, NULL);
+	ERR_FAIL_COND_V(ti->type != p_db_type, NULL);
+	ERR_FAIL_COND_V(ti->is_abstract, NULL);
+	ERR_FAIL_COND_V(ti->disabled, NULL);
+
+	if (ti->type == TYPEDB_TYPE_SCRIPT) {
+		Object *obj = ClassDB::instance(ti->base);
+		ERR_FAIL_COND_V(!obj, NULL);
+
+		Ref<Script> script = ResourceLoader::load(ti->path, "Script");
+		ERR_FAIL_COND_V(script.is_null(), NULL);
+
+		obj->set_script(script.get_ref_ptr());
+		return obj;
+	} else if (ti->type == TYPEDB_TYPE_SCENE) {
+		Ref<PackedScene> scene = ResourceLoader::load(ti->path, "PackedScene");
+		ERR_FAIL_COND_V(scene.is_null(), NULL);
+
+		Object *obj = scene->instance(PackedScene::GEN_EDIT_STATE_INSTANCE);
+		ERR_FAIL_COND_V(!obj, NULL);
+
+		return obj;
+	}
+	return NULL;
+}
+
+bool EditorData::TypeDB::is_custom(const StringName &p_type, TypeDbTypes p_db_types) const {
+
+	if (p_db_types & TYPEDB_TYPE_SCRIPT && _scripts.has(p_type)) {
+		const EditorData::TypeInfo &ti = _scripts[p_type];
+		return ti.is_custom && !ti.disabled;
+	}
+	if (p_db_types & TYPEDB_TYPE_SCENE && _scenes.has(p_type)) {
+		const EditorData::TypeInfo &ti = _scenes[p_type];
+		return ti.is_custom && !ti.disabled;
+	}
+	return false;
+}
+
+bool EditorData::TypeDB::is_custom_path(const String &p_path, TypeDbTypes p_db_types) const {
+	EditorData::TypeInfo *ti = _paths[p_path];
+	if (!ti)
+		return false;
+	return is_custom(ti->type_name, p_db_types);
+}
+
+StringName EditorData::TypeDB::get_type_name(const String &p_path, EditorData::TypeDbTypes p_db_types) const {
+
+	if (p_db_types == TYPEDB_TYPE_SCRIPT) {
+		Ref<Script> script = ResourceLoader::load(p_path, "Script");
+		Dictionary meta = script->get_script_metadata();
+		if (!meta.empty() && meta.has("type_name")) {
+			return meta["type_name"];
+		}
+	}
+	//TODO: scenes metadata extraction
+	return StringName();
+}
+
+bool EditorData::TypeDB::is_parent_class(const StringName &p_type, const StringName &p_inherits, TypeDbTypes p_db_types) const {
+
+	StringName inherits = p_type;
+
+	while (inherits.operator String().length()) {
+
+		if (inherits == p_inherits)
+			return true;
+		inherits = get_parent_class(inherits, p_db_types);
+	}
+
+	const EditorData::TypeInfo *ti = get_type_info(p_type, p_db_types);
+	if (ti) {
+		return ti->base == p_inherits || ClassDB::is_parent_class(ti->base, p_inherits);
+	}
+
+	return false;
+}
+
+StringName EditorData::TypeDB::get_parent_class(const StringName &p_type, TypeDbTypes p_db_types) const {
+	if (p_db_types & TYPEDB_TYPE_SCRIPT)
+		return _scripts.has(p_type) && !_scripts[p_type].disabled ? _scripts[p_type].inherits : StringName();
+	if (p_db_types & TYPEDB_TYPE_SCENE)
+		return _scenes.has(p_type) && !_scenes[p_type].disabled ? _scenes[p_type].inherits : StringName();
+	return StringName();
+}
+
+void EditorData::TypeDB::get_class_list(List<StringName> *p_types, TypeDbTypes p_db_types) const {
+
+	if (p_db_types & TYPEDB_TYPE_SCRIPT) {
+		const StringName *k = NULL;
+
+		while ((k = _scripts.next(k))) {
+			if (_scripts[*k].disabled)
+				continue;
+			p_types->push_back(*k);
+		}
 	}
 
+	if (p_db_types & TYPEDB_TYPE_SCENE) {
+		const StringName *k = NULL;
+
+		while ((k = _scenes.next(k))) {
+			if (_scenes[*k].disabled)
+				continue;
+			p_types->push_back(*k);
+		}
+	}
+
+	p_types->sort();
+}
+
+const EditorData::TypeInfo *EditorData::TypeDB::get_type_info(const StringName &p_type, TypeDbTypes p_db_types) const {
+	if (p_db_types & TYPEDB_TYPE_SCRIPT && _scripts.has(p_type) && !_scripts[p_type].disabled)
+		return &_scripts[p_type];
+	if (p_db_types & TYPEDB_TYPE_SCENE && _scenes.has(p_type) && !_scenes[p_type].disabled)
+		return &_scenes[p_type];
 	return NULL;
 }
 
-void EditorData::remove_custom_type(const String &p_type) {
+void EditorData::TypeDB::toggle_namespace(const String &p_namespace, bool p_active) {
+	List<StringName> keys;
+	_scripts.get_key_list(&keys);
+	for (List<StringName>::Element *E = keys.front(); E; E = E->next()) {
+		if (String(E->get()).find(p_namespace + ".", 0) == 0)
+			_scripts[E->get()].disabled = !p_active;
+	}
+	keys.clear();
+	_scenes.get_key_list(&keys);
+	for (List<StringName>::Element *E = keys.front(); E; E = E->next()) {
+		if (String(E->get()).find(p_namespace + ".", 0) == 0)
+			_scenes[E->get()].disabled = !p_active;
+	}
+	_globals_dirty = true;
+}
 
-	for (Map<String, Vector<CustomType> >::Element *E = custom_types.front(); E; E = E->next()) {
+void EditorData::TypeDB::toggle_directory(const String &p_directory, bool p_active) {
+	List<StringName> keys;
+	_paths.get_key_list(&keys);
+	for (List<StringName>::Element *E = keys.front(); E; E = E->next()) {
+		if (String(E->get()).find(p_directory, 0) == 0)
+			_paths[E->get()]->disabled = !p_active;
+	}
+	_globals_dirty = true;
+}
+
+void EditorData::TypeDB::update_res(const String &p_path) {
+
+	TypeDbTypes t = TYPEDB_TYPE_NONE;
+	String ext = p_path.get_extension();
+	if ("tscn" == ext || "scn" == ext) {
+		t = TYPEDB_TYPE_SCENE;
+	} else {
+		for (int i = 0; i < ScriptServer::get_language_count(); i++) {
+			ScriptLanguage *lang = ScriptServer::get_language(i);
+			if (ext == lang->get_extension()) {
+				t = TYPEDB_TYPE_SCRIPT;
+				break;
+			}
+		}
+	}
 
-		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());
+	if (_paths.has(p_path) && !FileAccess::exists(p_path)) {
+		_paths.erase(p_path); // will this situation even happen if it's already in the ResourceCache?
+	}
+
+	StringName type_name = get_type_name(p_path, t);
+	if (StringName() == type_name) {
+		if (_paths.has(p_path)) {
+			EditorData::TypeInfo *ti = _paths[p_path];
+			if (ti) {
+				if (ti->type == TYPEDB_TYPE_SCRIPT)
+					_scripts.erase(ti->type_name);
+				else if (ti->type == TYPEDB_TYPE_SCENE)
+					_scenes.erase(ti->type_name);
+			}
+			_paths.erase(p_path);
+		}
+		return;
+	}
+
+	if (_paths.has(p_path)) {
+
+		EditorData::TypeInfo *ti = _paths[p_path];
+		if (ti->type == TYPEDB_TYPE_SCRIPT) {
+			Ref<Script> script;
+			script = ResourceLoader::load(ti->path, "Script");
+
+			Dictionary meta = script->get_script_metadata();
+			if (!meta.empty()) {
+
+				StringName script_type_name = meta["type_name"];
+				StringName base_name = meta["base_name"].operator StringName();
+
+				String icon_path = meta["icon_path"];
+				Ref<Texture> icon = FileAccess::exists(String(meta["icon_path"])) ? ResourceLoader::load(icon_path, "Texture") : NULL;
+
+				bool is_abstract = meta.has("is_abstract") ? meta["is_abstract"].operator bool() : false;
+				bool is_custom = meta.has("is_custom") ? meta["is_custom"].operator bool() : false;
+
+				if (base_name == StringName()) {
+					Ref<Script> base_script = script->get_base_script();
+					if (base_script.is_valid() && _paths.has(base_script->get_path())) {
+						EditorData::TypeInfo *ti = _paths[base_script->get_path()];
+						if (ti)
+							base_name = ti->type_name;
+					}
 				}
-				return;
+
+				ti->type_name = script_type_name;
+				ti->inherits = base_name;
+				ti->icon = icon;
+				ti->is_abstract = is_abstract;
+				ti->is_custom = is_custom;
+			}
+			_globals_dirty = true;
+		}
+	} else {
+		const EditorData::TypeInfo *cti = get_type_info(type_name, t);
+		if (!cti) {
+
+			if (t == TYPEDB_TYPE_SCRIPT) {
+				Ref<Script> script = ResourceLoader::load(p_path, "Script");
+				if (script.is_valid()) {
+
+					Dictionary meta = script->get_script_metadata();
+					if (!meta.empty()) {
+
+						StringName script_type_name = meta["type_name"];
+						StringName base_name = meta["base_name"].get_type() == Variant::NIL ? StringName() : meta["base_name"].operator StringName();
+						if (String(base_name).find("Scripts.", 0) == 0) {
+							base_name = StringName(String(base_name).replace("Scripts.", ""));
+						}
+
+						String icon_path = meta["icon_path"];
+						Ref<Texture> icon = FileAccess::exists(String(meta["icon_path"])) ? ResourceLoader::load(icon_path, "Texture") : NULL;
+
+						bool is_abstract = meta.has("is_abstract") ? meta["is_abstract"].operator bool() : false;
+						bool is_custom = meta.has("is_custom") ? meta["is_custom"].operator bool() : false;
+
+						if (base_name == StringName()) {
+							String base_path = meta["base_path"];
+							Ref<Script> base_script = script->get_base_script();
+							if (base_script.is_valid() && _paths.has(base_script->get_path())) {
+								EditorData::TypeInfo *ti = _paths[base_script->get_path()];
+								if (ti)
+									base_name = ti->type_name;
+							}
+						}
+
+						_add_type(script_type_name, base_name, p_path, icon, is_abstract, is_custom, TYPEDB_TYPE_SCRIPT);
+					}
+				}
+			}
+		} else {
+			String original_path = cti->path;
+			if (_paths.has(original_path)) {
+				EditorData::TypeInfo *ti = _paths[original_path];
+				ti->path = p_path;
+				_paths.erase(original_path);
+				_paths[p_path] = ti;
+				_globals_dirty = true;
 			}
 		}
 	}
 }
 
+void EditorData::TypeDB::update_globals() {
+	if (!_globals_dirty)
+		return;
+
+	Dictionary scripts;
+	List<StringName> keys;
+	_scripts.get_key_list(&keys);
+	for (List<StringName>::Element *E = keys.front(); E; E = E->next()) {
+		EditorData::TypeInfo &ti = _scripts[E->get()];
+		if (ti.disabled)
+			continue;
+		scripts[E->get()] = ti.path;
+	}
+	ProjectSettings::get_singleton()->set_setting("typedb/scripts", scripts);
+
+	keys.clear();
+
+	Dictionary scenes;
+	_scenes.get_key_list(&keys);
+	for (List<StringName>::Element *E = keys.front(); E; E = E->next()) {
+		EditorData::TypeInfo &ti = _scenes[E->get()];
+		if (ti.disabled)
+			continue;
+		scenes[E->get()] = ti.path;
+	}
+	ProjectSettings::get_singleton()->set_setting("typedb/scenes", scenes);
+	keys.clear();
+
+	ProjectSettings::get_singleton()->save();
+	_globals_dirty = false;
+}
+
+String EditorData::TypeDB::get_script_create_dialog_inherits_field(const EditorData::TypeInfo &p_ti) const {
+	if (p_ti.path.get_extension() == "gd") {
+		return "Scripts." + String(p_ti.type_name);
+	}
+	return "";
+}
+
+EditorData::TypeDB::TypeDB() {
+}
+
+EditorData::TypeDB::~TypeDB() {
+}
+
 int EditorData::add_edited_scene(int p_at_pos) {
 
 	if (p_at_pos < 0)
diff --git a/editor/editor_data.h b/editor/editor_data.h
index 0ecef8ae31c5..6fa50aa6e1ff 100644
--- a/editor/editor_data.h
+++ b/editor/editor_data.h
@@ -35,6 +35,7 @@
 #include "editor/plugins/script_editor_plugin.h"
 #include "list.h"
 #include "pair.h"
+#include "scene/resources/packed_scene.h"
 #include "scene/resources/texture.h"
 #include "undo_redo.h"
 
@@ -108,11 +109,84 @@ class EditorSelection;
 class EditorData {
 
 public:
-	struct CustomType {
+	enum TypeDbTypes {
+		TYPEDB_TYPE_NONE = 0,
+		TYPEDB_TYPE_SCRIPT = 1,
+		TYPEDB_TYPE_SCENE = 2,
+		TYPEDB_TYPE_ALL = 3
+	};
+
+	struct TypeInfo {
+
+		StringName type_name;
+		StringName inherits;
+		StringName base;
+
+		String path;
+
+		bool is_abstract : 1;
+		bool is_custom : 1;
+		bool disabled : 1;
+		TypeDbTypes type : 2;
 
-		String name;
-		Ref<Script> script;
 		Ref<Texture> icon;
+		Vector<StringName> sub_types;
+
+		StringName get_name() const { return String(type_name).get_file(); }
+		StringName get_domain() const { return String(type_name).get_base_dir(); }
+		StringName get_inherits_name() const { return String(inherits).get_file(); }
+		StringName get_inherits_domain() const { return String(inherits).get_base_dir(); }
+		bool is_path_valid() const {
+			return FileAccess::open(path, FileAccess::READ);
+		}
+	};
+
+	class TypeDB {
+	private:
+		typedef HashMap<StringName, TypeInfo, StringNameHasher> TypeMap;
+		typedef HashMap<StringName, TypeInfo *, StringNameHasher> PtrTypeMap;
+		typedef HashMap<StringName, Vector<TypeInfo>, StringNameHasher> DependencyMap;
+
+		TypeMap _scripts;
+		TypeMap _scenes;
+		DependencyMap _script_deps;
+		DependencyMap _scene_deps;
+		PtrTypeMap _paths;
+		bool _globals_dirty = false;
+
+		void _add_type(const StringName &p_type, const StringName &p_inherits, const String &p_path, const Ref<Texture> &p_icon = NULL, bool p_is_abstract = false, bool p_is_custom = false, TypeDbTypes p_db_type = TYPEDB_TYPE_SCRIPT);
+		void _check_for_deps(const StringName &p_type, TypeDbTypes p_db_type = TYPEDB_TYPE_SCRIPT);
+		void _register_type_info(TypeInfo &p_ti, TypeDbTypes p_db_type = TYPEDB_TYPE_SCRIPT);
+
+	public:
+		//replicated ClassDB interface
+		bool class_exists(const StringName &p_type, TypeDbTypes p_db_types = TYPEDB_TYPE_ALL) const;
+		StringName get_parent_class(const StringName &p_type, TypeDbTypes p_db_types = TYPEDB_TYPE_ALL) const;
+		bool is_parent_class(const StringName &p_type, const StringName &p_inherits, TypeDbTypes p_db_types = TYPEDB_TYPE_ALL) const;
+		void get_class_list(List<StringName> *p_types, TypeDbTypes p_db_types = TYPEDB_TYPE_ALL) const;
+		bool can_instance(const StringName &p_type, TypeDbTypes p_db_types = TYPEDB_TYPE_ALL) const;
+		Object *instance(const StringName &p_type, TypeDbTypes p_db_types = TYPEDB_TYPE_SCRIPT);
+
+		bool is_custom(const StringName &p_type, TypeDbTypes p_db_types = TYPEDB_TYPE_SCRIPT) const;
+		bool is_custom_path(const String &p_path, TypeDbTypes p_db_types = TYPEDB_TYPE_SCRIPT) const;
+		StringName get_type_name(const String &p_path, TypeDbTypes p_db_types) const;
+
+		void add_script(const StringName &p_type, const StringName &p_inherits, const Ref<Script> &p_script, const Ref<Texture> &p_icon = NULL, bool p_is_abstract = false, bool p_is_custom = false);
+		void add_scene(const StringName &p_type, const StringName &p_inherits, const Ref<PackedScene> &p_scene, const Ref<Texture> &p_icon = NULL, bool p_is_abstract = false, bool p_is_custom = false);
+		void remove_custom_type(const StringName &p_type, TypeDbTypes p_db_types = TYPEDB_TYPE_SCRIPT);
+		const TypeInfo *get_type_info(const StringName &p_type, TypeDbTypes p_db_types) const;
+		void toggle_namespace(const String &p_namespace, bool p_active);
+		void toggle_directory(const String &p_directory, bool p_active);
+
+		bool has_path(const String &p_path) const { return _paths.has(p_path); }
+		TypeInfo &get_path(const String &p_path) { return *_paths[p_path]; }
+
+		void update_res(const String &p_path);
+		void update_globals();
+		String get_script_create_dialog_inherits_field(const EditorData::TypeInfo &p_ti) const;
+
+		TypeDB();
+		~TypeDB();
 	};
 
 	struct EditedScene {
@@ -129,12 +203,13 @@ class EditorData {
 private:
 	Vector<EditorPlugin *> editor_plugins;
 
+	TypeDB type_db;
+
 	struct PropertyData {
 
 		String name;
 		Variant value;
 	};
-	Map<String, Vector<CustomType> > custom_types;
 
 	List<PropertyData> clipboard;
 	UndoRedo undo_redo;
@@ -174,10 +249,7 @@ class EditorData {
 	void save_editor_global_states();
 	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);
-	void remove_custom_type(const String &p_type);
-	const Map<String, Vector<CustomType> > &get_custom_types() const { return custom_types; }
+	TypeDB &get_type_db() { return type_db; }
 
 	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 83f1cd40ba5b..d3200c15463d 100644
--- a/editor/editor_node.cpp
+++ b/editor/editor_node.cpp
@@ -402,6 +402,18 @@ void EditorNode::_notification(int p_what) {
 	}
 }
 
+void EditorNode::_on_plugin_ready(Object *p_script, const String &p_activate_name) {
+	Script *script = Object::cast_to<Script>(p_script);
+	if (!script)
+		return;
+	if (p_activate_name.length()) {
+		set_addon_plugin_enabled(p_activate_name, true);
+	}
+	project_settings->update_plugins();
+	project_settings->hide();
+	push_item(script);
+}
+
 void EditorNode::_fs_changed() {
 
 	for (Set<FileDialog *>::Element *E = file_dialogs.front(); E; E = E->next()) {
@@ -422,6 +434,7 @@ void EditorNode::_fs_changed() {
 		ResourceCache::get_cached_resources(&cached);
 		// FIXME: This should be done in a thread.
 		for (List<Ref<Resource> >::Element *E = cached.front(); E; E = E->next()) {
+			editor_data.get_type_db().update_res(String(E->get()->get_path()));
 
 			if (!E->get()->editor_can_reload_from_file())
 				continue;
@@ -441,6 +454,7 @@ void EditorNode::_fs_changed() {
 				changed.push_back(E->get());
 			}
 		}
+		editor_data.get_type_db().update_globals();
 
 		if (changed.size()) {
 			for (List<Ref<Resource> >::Element *E = changed.front(); E; E = E->next()) {
@@ -2257,6 +2271,13 @@ void EditorNode::_tool_menu_option(int p_idx) {
 		case TOOLS_ORPHAN_RESOURCES: {
 			orphan_resources->show();
 		} break;
+		case TOOLS_RELOAD_DOCS: {
+			OS *os = OS::get_singleton();
+			List<String> args;
+			args.push_back("--doctool");
+			args.push_back("\"" + os->get_executable_path().get_base_dir().get_base_dir() + "\"");
+			os->execute(os->get_executable_path(), args, false);
+		} break;
 		case TOOLS_CUSTOM: {
 			if (tool_menu->get_item_submenu(p_idx) == "") {
 				Array params = tool_menu->get_item_metadata(p_idx);
@@ -2434,6 +2455,13 @@ void EditorNode::add_editor_plugin(EditorPlugin *p_editor) {
 	}
 	singleton->editor_data.add_editor_plugin(p_editor);
 	singleton->add_child(p_editor);
+	if (!p_editor->get_script().is_null()) {
+		Ref<Script> script = p_editor->get_script();
+		if (script.is_valid()) {
+			String plugin_dir = "res://addons/" + script->get_path().get_slicec('/', 3);
+			singleton->editor_data.get_type_db().toggle_directory(plugin_dir, true);
+		}
+	}
 }
 
 void EditorNode::remove_editor_plugin(EditorPlugin *p_editor) {
@@ -2457,6 +2485,15 @@ void EditorNode::remove_editor_plugin(EditorPlugin *p_editor) {
 
 		singleton->editor_table.erase(p_editor);
 	}
+
+	if (!p_editor->get_script().is_null()) {
+		Ref<Script> script = p_editor->get_script();
+		if (script.is_valid()) {
+			String plugin_dir = "res://addons/" + script->get_path().get_slicec('/', 3);
+			singleton->editor_data.get_type_db().toggle_directory(plugin_dir, false);
+		}
+	}
+
 	p_editor->make_visible(false);
 	p_editor->clear();
 	singleton->editor_plugins_over->get_plugins_list().erase(p_editor);
@@ -2536,6 +2573,7 @@ void EditorNode::set_addon_plugin_enabled(const String &p_addon, bool p_enabled)
 
 	EditorPlugin *ep = memnew(EditorPlugin);
 	ep->set_script(script.get_ref_ptr());
+	ep->set_config(cf);
 	plugin_addons[p_addon] = ep;
 	add_editor_plugin(ep);
 
@@ -2547,6 +2585,11 @@ bool EditorNode::is_addon_plugin_enabled(const String &p_addon) const {
 	return plugin_addons.has(p_addon);
 }
 
+EditorPlugin *EditorNode::get_addon_plugin(const String &p_addon) {
+
+	return plugin_addons.has(p_addon) ? plugin_addons[p_addon] : NULL;
+}
+
 void EditorNode::_remove_edited_scene() {
 	int new_index = editor_data.get_edited_scene();
 	int old_index = new_index;
@@ -4473,6 +4516,8 @@ void EditorNode::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("_resources_reimported"), &EditorNode::_resources_reimported);
 
+	ClassDB::bind_method(D_METHOD("_on_plugin_ready"), &EditorNode::_on_plugin_ready);
+
 	ADD_SIGNAL(MethodInfo("play_pressed"));
 	ADD_SIGNAL(MethodInfo("pause_pressed"));
 	ADD_SIGNAL(MethodInfo("stop_pressed"));
@@ -5026,12 +5071,17 @@ EditorNode::EditorNode() {
 	p->connect("id_pressed", this, "_menu_option");
 	p->add_item(TTR("Export"), FILE_EXPORT_PROJECT);
 
+	plugin_create_dialog = memnew(PluginCreateDialog);
+	plugin_create_dialog->connect("plugin_ready", this, "_on_plugin_ready");
+	gui_base->add_child(plugin_create_dialog);
+
 	tool_menu = memnew(PopupMenu);
 	tool_menu->set_name("Tools");
 	tool_menu->connect("index_pressed", this, "_tool_menu_option");
 	p->add_child(tool_menu);
 	p->add_submenu_item(TTR("Tools"), "Tools");
 	tool_menu->add_item(TTR("Orphan Resource Explorer"), TOOLS_ORPHAN_RESOURCES);
+	tool_menu->add_item(TTR("Rebuild Documentation"), TOOLS_RELOAD_DOCS);
 	p->add_separator();
 
 #ifdef OSX_ENABLED
diff --git a/editor/editor_node.h b/editor/editor_node.h
index dedd947633d7..148bce87840e 100644
--- a/editor/editor_node.h
+++ b/editor/editor_node.h
@@ -56,6 +56,7 @@
 #include "editor/inspector_dock.h"
 #include "editor/node_dock.h"
 #include "editor/pane_drag.h"
+#include "editor/plugin_create_dialog.h"
 #include "editor/progress_dialog.h"
 #include "editor/project_export.h"
 #include "editor/project_settings_editor.h"
@@ -143,6 +144,7 @@ class EditorNode : public Node {
 		EDIT_REDO,
 		EDIT_REVERT,
 		TOOLS_ORPHAN_RESOURCES,
+		TOOLS_RELOAD_DOCS,
 		TOOLS_CUSTOM,
 		RESOURCE_SAVE,
 		RESOURCE_SAVE_AS,
@@ -245,6 +247,8 @@ class EditorNode : public Node {
 	ToolButton *search_button;
 	TextureProgress *audio_vu;
 
+	PluginCreateDialog *plugin_create_dialog;
+
 	RichTextLabel *load_errors;
 	AcceptDialog *load_error_dialog;
 
@@ -400,6 +404,8 @@ class EditorNode : public Node {
 	void _tool_menu_option(int p_idx);
 	void _update_debug_options();
 
+	void _on_plugin_ready(Object *p_script, const String &p_activate_name);
+
 	void _fs_changed();
 	void _resources_reimported(const Vector<String> &p_resources);
 	void _sources_changed(bool p_exist);
@@ -617,6 +623,7 @@ class EditorNode : public Node {
 
 	void set_addon_plugin_enabled(const String &p_addon, bool p_enabled);
 	bool is_addon_plugin_enabled(const String &p_addon) const;
+	EditorPlugin *get_addon_plugin(const String &p_addon);
 
 	void edit_node(Node *p_node);
 	void edit_resource(const Ref<Resource> &p_resource) { inspector_dock->edit_resource(p_resource); };
diff --git a/editor/editor_plugin.cpp b/editor/editor_plugin.cpp
index cc44938c25f7..79f836ead275 100644
--- a/editor/editor_plugin.cpp
+++ b/editor/editor_plugin.cpp
@@ -235,12 +235,12 @@ Control *EditorInterface::get_base_control() {
 	return EditorNode::get_singleton()->get_gui_base();
 }
 
-void EditorInterface::set_plugin_enabled(const String &p_plugin, bool p_enabled) {
-	EditorNode::get_singleton()->set_addon_plugin_enabled(p_plugin, p_enabled);
+void EditorInterface::set_plugin_enabled(const String &p_plugin_dir_name, bool p_enabled) {
+	EditorNode::get_singleton()->set_addon_plugin_enabled(p_plugin_dir_name, p_enabled);
 }
 
-bool EditorInterface::is_plugin_enabled(const String &p_plugin) const {
-	return EditorNode::get_singleton()->is_addon_plugin_enabled(p_plugin);
+bool EditorInterface::is_plugin_enabled(const String &p_plugin_dir_name) const {
+	return EditorNode::get_singleton()->is_addon_plugin_enabled(p_plugin_dir_name);
 }
 
 Error EditorInterface::save_scene() {
@@ -258,6 +258,27 @@ void EditorInterface::save_scene_as(const String &p_scene, bool p_with_preview)
 	EditorNode::get_singleton()->save_scene_to_path(p_scene, p_with_preview);
 }
 
+void EditorInterface::load_class_docs(const String &p_dir) {
+	String dir = p_dir;
+	if (!p_dir.length()) {
+		Ref<Script> s = get_script();
+		dir = s->get_path().get_base_dir();
+	}
+	EditorHelp::get_doc_data()->load_classes(dir);
+}
+
+void EditorInterface::generate_script_docs(const String &p_script_path, const String &p_output_path) {
+	ERR_FAIL_COND(!FileAccess::exists(p_script_path));
+
+	Ref<Script> script = ResourceLoader::load(p_script_path, "Script");
+	String output_path = p_output_path.empty() ? p_script_path.get_base_dir().plus_file(p_script_path.get_file().get_basename().typenamify() + ".xml") : p_output_path;
+	FileAccess *fa = FileAccess::open(p_output_path, FileAccess::WRITE);
+	if (!fa)
+		return;
+	fa->store_string(EditorHelp::get_doc_data()->get_script_xml(script));
+	fa->close();
+}
+
 EditorInterface *EditorInterface::singleton = NULL;
 
 void EditorInterface::_bind_methods() {
@@ -279,11 +300,17 @@ void EditorInterface::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("select_file", "p_file"), &EditorInterface::select_file);
 	ClassDB::bind_method(D_METHOD("get_selected_path"), &EditorInterface::get_selected_path);
 
-	ClassDB::bind_method(D_METHOD("set_plugin_enabled", "plugin", "enabled"), &EditorInterface::set_plugin_enabled);
-	ClassDB::bind_method(D_METHOD("is_plugin_enabled", "plugin"), &EditorInterface::is_plugin_enabled);
+	ClassDB::bind_method(D_METHOD("set_plugin_enabled", "plugin_dir_name", "enabled"), &EditorInterface::set_plugin_enabled);
+	ClassDB::bind_method(D_METHOD("is_plugin_enabled", "plugin_dir_name"), &EditorInterface::is_plugin_enabled);
 
 	ClassDB::bind_method(D_METHOD("save_scene"), &EditorInterface::save_scene);
 	ClassDB::bind_method(D_METHOD("save_scene_as", "path", "with_preview"), &EditorInterface::save_scene_as, DEFVAL(true));
+
+	ClassDB::bind_method(D_METHOD("toggle_custom_namespace", "p_namespace", "p_active"), &EditorPlugin::toggle_custom_namespace);
+	ClassDB::bind_method(D_METHOD("toggle_custom_directory", "p_directory", "p_active"), &EditorPlugin::toggle_custom_directory);
+
+	ClassDB::bind_method(D_METHOD("generate_script_docs", "p_script_path", "p_output_path"), &EditorInterface::generate_script_docs, DEFVAL(""));
+	ClassDB::bind_method(D_METHOD("load_class_docs", "xml_doc_path"), &EditorInterface::load_class_docs);
 }
 
 EditorInterface::EditorInterface() {
@@ -291,14 +318,65 @@ EditorInterface::EditorInterface() {
 }
 
 ///////////////////////////////////////////
-void EditorPlugin::add_custom_type(const String &p_type, const String &p_base, const Ref<Script> &p_script, const Ref<Texture> &p_icon) {
 
-	EditorNode::get_editor_data().add_custom_type(p_type, p_base, p_script, p_icon);
+String EditorPlugin::_get_type_name(const String &p_type, bool p_allow_class) {
+
+	int a = p_type.get_slice_count(".");
+	String b = get_domain();
+	String c = b.plus_file(p_type);
+	String ret = p_type.get_slice_count(".") > 1 || (p_allow_class && ClassDB::class_exists(p_type)) ? p_type : get_domain().plus_file(p_type);
+	return ret;
 }
 
-void EditorPlugin::remove_custom_type(const String &p_type) {
+void EditorPlugin::add_custom_type(const StringName &p_type, const StringName &p_inherits, const Ref<Script> &p_script, const Ref<Texture> &p_icon, bool p_is_abstract) {
+
+	ERR_FAIL_COND(!p_script.is_valid());
 
-	EditorNode::get_editor_data().remove_custom_type(p_type);
+	EditorData::TypeDB &tdb = EditorNode::get_singleton()->get_editor_data().get_type_db();
+	ERR_FAIL_COND(!ClassDB::class_exists(p_inherits) && !tdb.class_exists(p_inherits));
+
+	StringName type_name = tdb.get_type_name(p_script->get_path(), EditorData::TYPEDB_TYPE_SCRIPT);
+	if (type_name == StringName())
+		type_name = p_type;
+	if (String(type_name).get_slice_count(".") == 1)
+		type_name = "Custom." + String(p_type);
+
+	StringName inherits_name = ClassDB::class_exists(p_inherits) ? p_inherits : tdb.get_type_info(p_inherits, EditorData::TYPEDB_TYPE_SCRIPT)->type_name;
+
+	tdb.add_script(String(type_name), String(inherits_name), p_script, p_icon, p_is_abstract, true);
+}
+
+void EditorPlugin::add_custom_scene(const StringName &p_type, const StringName &p_inherits, const Ref<PackedScene> &p_scene, const Ref<Texture> &p_icon, bool p_is_abstract) {
+	EditorNode::get_editor_data().get_type_db().add_scene(_get_type_name(p_type), _get_type_name(p_inherits, true), p_scene, p_icon, p_is_abstract, true);
+}
+
+void EditorPlugin::remove_custom_type(const StringName &p_type) {
+	EditorNode::get_editor_data().get_type_db().remove_custom_type(_get_type_name(p_type), EditorData::TYPEDB_TYPE_SCRIPT);
+}
+
+void EditorPlugin::remove_custom_scene(const StringName &p_type) {
+	EditorNode::get_editor_data().get_type_db().remove_custom_type(_get_type_name(p_type), EditorData::TYPEDB_TYPE_SCENE);
+}
+
+void EditorPlugin::toggle_custom_namespace(const String &p_namespace, bool p_active) {
+	EditorNode::get_editor_data().get_type_db().toggle_namespace(p_namespace, p_active);
+}
+
+void EditorPlugin::toggle_custom_directory(const String &p_directory, bool p_active) {
+	EditorNode::get_editor_data().get_type_db().toggle_directory(p_directory, p_active);
+}
+
+String EditorPlugin::get_domain() {
+	Ref<ConfigFile> cf = get_config();
+	if (cf.is_valid() && cf->has_section_key("plugin", "domain")) {
+		return cf->get_value("plugin", "domain");
+	}
+
+	Ref<Script> s = get_script();
+	if (s.is_valid())
+		return s->get_path().get_slice(".", 3).typenamify();
+
+	return "";
 }
 
 void EditorPlugin::add_autoload_singleton(const String &p_name, const String &p_path) {
@@ -728,8 +806,12 @@ void EditorPlugin::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("add_tool_menu_item", "name", "handler", "callback", "ud"), &EditorPlugin::add_tool_menu_item, DEFVAL(Variant()));
 	ClassDB::bind_method(D_METHOD("add_tool_submenu_item", "name", "submenu"), &EditorPlugin::add_tool_submenu_item);
 	ClassDB::bind_method(D_METHOD("remove_tool_menu_item", "name"), &EditorPlugin::remove_tool_menu_item);
-	ClassDB::bind_method(D_METHOD("add_custom_type", "type", "base", "script", "icon"), &EditorPlugin::add_custom_type);
+	ClassDB::bind_method(D_METHOD("add_custom_type", "type", "base", "script", "icon", "is_abstract"), &EditorPlugin::add_custom_type, DEFVAL(Variant()), DEFVAL(false));
+	//ClassDB::bind_method(D_METHOD("add_custom_scene", "type", "base", "scene", "icon", "is_abstract"), &EditorPlugin::add_custom_scene, DEFVAL(NULL), DEFVAL(false));
 	ClassDB::bind_method(D_METHOD("remove_custom_type", "type"), &EditorPlugin::remove_custom_type);
+	//ClassDB::bind_method(D_METHOD("remove_custom_scene", "type"), &EditorPlugin::remove_custom_type);
+
+	ClassDB::bind_method(D_METHOD("get_config"), &EditorPlugin::get_config);
 
 	ClassDB::bind_method(D_METHOD("add_autoload_singleton", "name", "path"), &EditorPlugin::add_autoload_singleton);
 	ClassDB::bind_method(D_METHOD("remove_autoload_singleton", "name"), &EditorPlugin::remove_autoload_singleton);
diff --git a/editor/editor_plugin.h b/editor/editor_plugin.h
index fcc74cb1e975..8b1c179d168f 100644
--- a/editor/editor_plugin.h
+++ b/editor/editor_plugin.h
@@ -91,12 +91,15 @@ class EditorInterface : public Node {
 
 	Control *get_base_control();
 
-	void set_plugin_enabled(const String &p_plugin, bool p_enabled);
-	bool is_plugin_enabled(const String &p_plugin) const;
+	void set_plugin_enabled(const String &p_plugin_dir_name, bool p_enabled);
+	bool is_plugin_enabled(const String &p_plugin_dir_name) const;
 
 	Error save_scene();
 	void save_scene_as(const String &p_scene, bool p_with_preview = true);
 
+	void load_class_docs(const String &p_dir = "");
+	void generate_script_docs(const String &p_script_path, const String &p_output_path = "");
+
 	Vector<Ref<Texture> > make_mesh_previews(const Vector<Ref<Mesh> > &p_meshes, int p_preview_size);
 
 	EditorInterface();
@@ -110,18 +113,19 @@ class EditorPlugin : public Node {
 
 	UndoRedo *_get_undo_redo() { return undo_redo; }
 
+	Ref<ConfigFile> _config;
+
 	bool input_event_forwarding_always_enabled;
 	bool force_draw_over_forwarding_enabled;
 
 	String last_main_screen_name;
 
+	String _get_type_name(const String &p_type, bool p_allow_class = false);
+
 protected:
 	static void _bind_methods();
 	UndoRedo &get_undo_redo() { return *undo_redo; }
 
-	void add_custom_type(const String &p_type, const String &p_base, const Ref<Script> &p_script, const Ref<Texture> &p_icon);
-	void remove_custom_type(const String &p_type);
-
 public:
 	enum CustomControlContainer {
 		CONTAINER_TOOLBAR,
@@ -159,6 +163,18 @@ class EditorPlugin : public Node {
 	void add_tool_submenu_item(const String &p_name, Object *p_submenu);
 	void remove_tool_menu_item(const String &p_name);
 
+	void add_custom_type(const StringName &p_type, const StringName &p_inherits, const Ref<Script> &p_script, const Ref<Texture> &p_icon = NULL, bool p_is_abstract = false);
+	void add_custom_scene(const StringName &p_type, const StringName &p_inherits, const Ref<PackedScene> &p_scene, const Ref<Texture> &p_icon = NULL, bool p_is_abstract = false);
+	void remove_custom_type(const StringName &p_type);
+	void remove_custom_scene(const StringName &p_type);
+	void toggle_custom_namespace(const String &p_namespace, bool p_active);
+	void toggle_custom_directory(const String &p_directory, bool p_active);
+
+	String get_domain();
+
+	Ref<ConfigFile> get_config() const { return _config; }
+	void set_config(const Ref<ConfigFile> &p_config) { _config = p_config; }
+
 	void set_input_event_forwarding_always_enabled();
 	bool is_input_event_forwarding_always_enabled() { return input_event_forwarding_always_enabled; }
 
diff --git a/editor/editor_plugin_settings.cpp b/editor/editor_plugin_settings.cpp
index ea1e0fe99e30..ba2a57c2ed14 100644
--- a/editor/editor_plugin_settings.cpp
+++ b/editor/editor_plugin_settings.cpp
@@ -41,6 +41,9 @@ void EditorPluginSettings::_notification(int p_what) {
 
 	if (p_what == MainLoop::NOTIFICATION_WM_FOCUS_IN) {
 		update_plugins();
+	} else if (p_what == Node::NOTIFICATION_READY) {
+		plugin_create_dialog->connect("plugin_ready", EditorNode::get_singleton(), "_on_plugin_ready");
+		plugin_list->connect("button_pressed", this, "_cell_button_pressed");
 	}
 }
 
@@ -124,6 +127,7 @@ void EditorPluginSettings::update_plugins() {
 			item->set_range_config(3, 0, 1, 1);
 			item->set_text(3, "Inactive,Active");
 			item->set_editable(3, true);
+			item->add_button(4, get_icon("Edit", "EditorIcons"), BUTTON_PLUGIN_EDIT, false, TTR("Edit Plugin"));
 
 			if (EditorNode::get_singleton()->is_addon_plugin_enabled(d)) {
 				item->set_custom_color(3, get_color("success_color", "Editor"));
@@ -164,17 +168,44 @@ void EditorPluginSettings::_plugin_activity_changed() {
 		ti->set_custom_color(3, get_color("disabled_font_color", "Editor"));
 }
 
+void EditorPluginSettings::_create_clicked() {
+	plugin_create_dialog->config("");
+	plugin_create_dialog->popup_centered();
+}
+
+void EditorPluginSettings::_cell_button_pressed(Object *p_item, int p_column, int p_id) {
+	TreeItem *item = Object::cast_to<TreeItem>(p_item);
+	if (!item)
+		return;
+	if (p_id == BUTTON_PLUGIN_EDIT) {
+		if (p_column == 4) {
+			String dir = item->get_metadata(0);
+			plugin_create_dialog->config(dir);
+			plugin_create_dialog->popup_centered();
+		}
+	}
+}
+
 void EditorPluginSettings::_bind_methods() {
 
 	ClassDB::bind_method("update_plugins", &EditorPluginSettings::update_plugins);
+	ClassDB::bind_method("_create_clicked", &EditorPluginSettings::_create_clicked);
 	ClassDB::bind_method("_plugin_activity_changed", &EditorPluginSettings::_plugin_activity_changed);
+	ClassDB::bind_method("_cell_button_pressed", &EditorPluginSettings::_cell_button_pressed);
 }
 
 EditorPluginSettings::EditorPluginSettings() {
 
+	plugin_create_dialog = memnew(PluginCreateDialog);
+	plugin_create_dialog->config("");
+	add_child(plugin_create_dialog);
+
 	HBoxContainer *title_hb = memnew(HBoxContainer);
 	title_hb->add_child(memnew(Label(TTR("Installed Plugins:"))));
 	title_hb->add_spacer();
+	create_plugin = memnew(Button(TTR("Create")));
+	create_plugin->connect("pressed", this, "_create_clicked");
+	title_hb->add_child(create_plugin);
 	update_list = memnew(Button(TTR("Update")));
 	update_list->connect("pressed", this, "update_plugins");
 	title_hb->add_child(update_list);
@@ -182,19 +213,22 @@ EditorPluginSettings::EditorPluginSettings() {
 
 	plugin_list = memnew(Tree);
 	plugin_list->set_v_size_flags(SIZE_EXPAND_FILL);
-	plugin_list->set_columns(4);
+	plugin_list->set_columns(5);
 	plugin_list->set_column_titles_visible(true);
 	plugin_list->set_column_title(0, TTR("Name:"));
 	plugin_list->set_column_title(1, TTR("Version:"));
 	plugin_list->set_column_title(2, TTR("Author:"));
 	plugin_list->set_column_title(3, TTR("Status:"));
+	plugin_list->set_column_title(4, TTR("Edit:"));
 	plugin_list->set_column_expand(0, true);
 	plugin_list->set_column_expand(1, false);
 	plugin_list->set_column_expand(2, false);
 	plugin_list->set_column_expand(3, false);
+	plugin_list->set_column_expand(4, false);
 	plugin_list->set_column_min_width(1, 100 * EDSCALE);
 	plugin_list->set_column_min_width(2, 250 * EDSCALE);
 	plugin_list->set_column_min_width(3, 80 * EDSCALE);
+	plugin_list->set_column_min_width(4, 40 * EDSCALE);
 	plugin_list->set_hide_root(true);
 	plugin_list->connect("item_edited", this, "_plugin_activity_changed");
 
diff --git a/editor/editor_plugin_settings.h b/editor/editor_plugin_settings.h
index aacbd05dd448..582b4a9a4e0a 100644
--- a/editor/editor_plugin_settings.h
+++ b/editor/editor_plugin_settings.h
@@ -31,6 +31,7 @@
 #ifndef EDITORPLUGINSETTINGS_H
 #define EDITORPLUGINSETTINGS_H
 
+#include "editor/plugin_create_dialog.h";
 #include "editor_data.h"
 #include "property_editor.h"
 #include "scene/gui/dialogs.h"
@@ -40,11 +41,19 @@ class EditorPluginSettings : public VBoxContainer {
 
 	GDCLASS(EditorPluginSettings, VBoxContainer);
 
+	enum {
+		BUTTON_PLUGIN_EDIT
+	};
+
+	PluginCreateDialog *plugin_create_dialog;
+	Button *create_plugin;
 	Button *update_list;
 	Tree *plugin_list;
 	bool updating;
 
 	void _plugin_activity_changed();
+	void _create_clicked();
+	void _cell_button_pressed(Object *p_item, int p_column, int p_id);
 
 protected:
 	void _notification(int p_what);
diff --git a/editor/editor_properties.cpp b/editor/editor_properties.cpp
index 5abcae80e08b..030a7b0401f1 100644
--- a/editor/editor_properties.cpp
+++ b/editor/editor_properties.cpp
@@ -30,6 +30,7 @@
 
 #include "editor_properties.h"
 #include "editor/editor_resource_preview.h"
+#include "editor_data.h"
 #include "editor_node.h"
 #include "editor_properties_array_dict.h"
 #include "scene/main/viewport.h"
@@ -1791,7 +1792,7 @@ void EditorPropertyResource::_menu_option(int p_which) {
 			Object *obj = ClassDB::instance(intype);
 
 			if (!obj) {
-				obj = EditorNode::get_editor_data().instance_custom_type(intype, "Resource");
+				obj = EditorNode::get_editor_data().get_type_db().instance(intype, EditorData::TYPEDB_TYPE_SCRIPT);
 			}
 
 			ERR_BREAK(!obj);
@@ -1832,48 +1833,36 @@ void EditorPropertyResource::_update_menu() {
 	} 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"];
+		List<StringName> custom_resources;
+		EditorData::TypeDB &tdb = EditorNode::get_singleton()->get_editor_data().get_type_db();
+		tdb.get_class_list(&custom_resources, EditorData::TYPEDB_TYPE_SCRIPT);
+		for (List<StringName>::Element *E = custom_resources.front(); E; E = E->next()) {
+			if (!tdb.is_parent_class(E->get(), "Resource"))
+				custom_resources.erase(E->get());
 		}
 
 		for (int i = 0; i < base_type.get_slice_count(","); i++) {
 
 			String base = base_type.get_slice(",", i);
 
-			Set<String> valid_inheritors;
-			valid_inheritors.insert(base);
 			List<StringName> inheritors;
-			ClassDB::get_inheriters_from_class(base.strip_edges(), &inheritors);
-
-			for (int i = 0; i < custom_resources.size(); i++) {
-				inheritors.push_back(custom_resources[i].name);
-			}
+			inheritors.push_back(base);
+			ClassDB::get_inheriters_from_class(base, &inheritors);
 
-			List<StringName>::Element *E = inheritors.front();
-			while (E) {
-				valid_inheritors.insert(E->get());
-				E = E->next();
+			for (List<StringName>::Element *E = custom_resources.front(); E; E = E->next()) {
+				if (tdb.is_parent_class(E->get(), base))
+					inheritors.push_back(E->get());
 			}
 
-			for (Set<String>::Element *E = valid_inheritors.front(); E; E = E->next()) {
+			for (List<StringName>::Element *E = inheritors.front(); E; E = E->next()) {
 				String t = E->get();
 
-				bool is_custom_resource = false;
+				const EditorData::TypeInfo *res_ti = tdb.get_type_info(t, EditorData::TYPEDB_TYPE_SCRIPT);
 				Ref<Texture> icon;
-				if (!custom_resources.empty()) {
-					for (int i = 0; i < custom_resources.size(); i++) {
-						if (custom_resources[i].name == t) {
-							is_custom_resource = true;
-							if (custom_resources[i].icon.is_valid())
-								icon = custom_resources[i].icon;
-							break;
-						}
-					}
-				}
+				if (res_ti && res_ti->icon.is_valid())
+					icon = res_ti->icon;
 
-				if (!is_custom_resource && !ClassDB::can_instance(t))
+				if ((res_ti && res_ti->is_abstract) || (ClassDB::class_exists(t) && !ClassDB::can_instance(t)))
 					continue;
 
 				inheritors_array.push_back(t);
diff --git a/editor/plugin_create_dialog.cpp b/editor/plugin_create_dialog.cpp
new file mode 100644
index 000000000000..6a82eb8e0f9e
--- /dev/null
+++ b/editor/plugin_create_dialog.cpp
@@ -0,0 +1,198 @@
+#include "plugin_create_dialog.h"
+
+#include "../core/io/config_file.h"
+#include "../core/os/dir_access.h"
+#include "../editor/editor_node.h"
+#include "../editor/editor_plugin.h"
+#include "../modules/gdscript/gdscript.h"
+#include "../scene/gui/grid_container.h"
+
+void PluginCreateDialog::_clear_fields() {
+	name_edit->set_text("");
+	subfolder_edit->set_text("");
+	desc_edit->set_text("");
+	author_edit->set_text("");
+	version_edit->set_text("");
+	script_edit->set_text("");
+}
+
+void PluginCreateDialog::_on_confirmed() {
+
+	String path = "res://addons/" + subfolder_edit->get_text();
+
+	if (!_edit_mode) {
+		DirAccess *d = DirAccess::create(DirAccess::ACCESS_RESOURCES);
+		if (!d || d->make_dir_recursive(path) != OK)
+			return;
+	}
+
+	Ref<ConfigFile> cf = memnew(ConfigFile);
+	cf->set_value("plugin", "name", name_edit->get_text());
+	cf->set_value("plugin", "description", desc_edit->get_text());
+	cf->set_value("plugin", "author", author_edit->get_text());
+	cf->set_value("plugin", "version", version_edit->get_text());
+	cf->set_value("plugin", "script", script_edit->get_text());
+
+	cf->save(path.plus_file("plugin.cfg"));
+
+	if (!_edit_mode) {
+		String type = script_option_edit->get_item_text(script_option_edit->get_selected());
+
+		Ref<Script> script;
+
+		if (type == GDScriptLanguage::get_singleton()->get_name()) {
+			Ref<GDScript> gdscript = memnew(GDScript);
+			gdscript->set_source_code(
+					"tool\n"
+					"extends EditorPlugin\n"
+					"\n"
+					"func _enter_tree():\n"
+					"\tpass");
+			ResourceSaver::save(path.plus_file(script_edit->get_text()), gdscript);
+			script = gdscript;
+		}
+		//TODO: other languages
+
+		emit_signal("plugin_ready", script.operator->(), active_edit->is_pressed() ? name_edit->get_text() : "");
+	} else {
+		EditorNode::get_singleton()->get_project_settings()->update_plugins();
+	}
+	_clear_fields();
+}
+
+void PluginCreateDialog::_on_cancelled() {
+	_clear_fields();
+}
+
+void PluginCreateDialog::_on_required_text_changed(const String &p_text) {
+	String ext = script_option_edit->get_item_metadata(script_option_edit->get_selected());
+	get_ok()->set_disabled(script_edit->get_text().get_basename().empty() || script_edit->get_text().get_extension() != ext || name_edit->get_text().empty());
+}
+
+void PluginCreateDialog::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_READY: {
+			connect("confirmed", this, "_on_confirmed");
+			get_cancel()->connect("pressed", this, "_on_cancelled");
+		} break;
+	}
+}
+
+void PluginCreateDialog::config(const String &p_plugin_dir_name) {
+	if (p_plugin_dir_name.length()) {
+		EditorPlugin *plugin = EditorNode::get_singleton()->get_addon_plugin(p_plugin_dir_name);
+		Ref<ConfigFile> cf = plugin->get_config();
+
+		name_edit->set_text(cf->get_value("plugin", "name"));
+		subfolder_edit->set_text(p_plugin_dir_name); //make read-only
+		desc_edit->set_text(cf->get_value("plugin", "description"));
+		author_edit->set_text(cf->get_value("plugin", "author"));
+		version_edit->set_text(cf->get_value("plugin", "version"));
+		script_edit->set_text(cf->get_value("plugin", "script"));
+
+		_edit_mode = true;
+		active_edit->hide();
+		Object::cast_to<Label>(active_edit->get_parent()->get_child(active_edit->get_index() - 1))->hide();
+		subfolder_edit->hide();
+		Object::cast_to<Label>(subfolder_edit->get_parent()->get_child(subfolder_edit->get_index() - 1))->hide();
+		set_title(TTR("Edit a Plugin"));
+	} else {
+		_clear_fields();
+		_edit_mode = false;
+		active_edit->show();
+		Object::cast_to<Label>(active_edit->get_parent()->get_child(active_edit->get_index() - 1))->show();
+		subfolder_edit->show();
+		Object::cast_to<Label>(subfolder_edit->get_parent()->get_child(subfolder_edit->get_index() - 1))->show();
+		set_title(TTR("Create a Plugin"));
+	}
+	get_ok()->set_disabled(!_edit_mode);
+	get_ok()->set_text(_edit_mode ? TTR("Update") : TTR("Create"));
+}
+
+void PluginCreateDialog::_bind_methods() {
+	ClassDB::bind_method("_on_required_text_changed", &PluginCreateDialog::_on_required_text_changed);
+	ClassDB::bind_method("_on_confirmed", &PluginCreateDialog::_on_confirmed);
+	ClassDB::bind_method("_on_cancelled", &PluginCreateDialog::_on_cancelled);
+	ADD_SIGNAL(MethodInfo("plugin_ready", PropertyInfo(Variant::OBJECT, "script", PROPERTY_HINT_RESOURCE_TYPE, "Script"), PropertyInfo(Variant::STRING, "activate_name")));
+}
+
+PluginCreateDialog::PluginCreateDialog() {
+	get_ok()->set_disabled(true);
+	set_hide_on_ok(true);
+
+	GridContainer *grid = memnew(GridContainer);
+	grid->set_columns(2);
+	add_child(grid);
+
+	Label *name_lb = memnew(Label);
+	name_lb->set_text(TTR("Plugin Name:"));
+	grid->add_child(name_lb);
+
+	name_edit = memnew(LineEdit);
+	name_edit->connect("text_changed", this, "_on_required_text_changed");
+	name_edit->set_placeholder("MyPlugin");
+	grid->add_child(name_edit);
+
+	Label *subfolder_lb = memnew(Label);
+	subfolder_lb->set_text(TTR("Subfolder:"));
+	grid->add_child(subfolder_lb);
+
+	subfolder_edit = memnew(LineEdit);
+	subfolder_edit->set_placeholder("\"my_plugin\" -> res://addons/my_plugin");
+	grid->add_child(subfolder_edit);
+
+	Label *desc_lb = memnew(Label);
+	desc_lb->set_text(TTR("Description:"));
+	grid->add_child(desc_lb);
+
+	desc_edit = memnew(TextEdit);
+	desc_edit->set_custom_minimum_size(Size2(400.0f, 50.0f));
+	grid->add_child(desc_edit);
+
+	Label *author_lb = memnew(Label);
+	author_lb->set_text(TTR("Author:"));
+	grid->add_child(author_lb);
+
+	author_edit = memnew(LineEdit);
+	author_edit->set_placeholder("Godette");
+	grid->add_child(author_edit);
+
+	Label *version_lb = memnew(Label);
+	version_lb->set_text(TTR("Version:"));
+	grid->add_child(version_lb);
+
+	version_edit = memnew(LineEdit);
+	version_edit->set_placeholder("1.0");
+	grid->add_child(version_edit);
+
+	Label *script_option_lb = memnew(Label);
+	script_option_lb->set_text(TTR("Language:"));
+	grid->add_child(script_option_lb);
+
+	script_option_edit = memnew(OptionButton);
+	script_option_edit->add_item(GDScriptLanguage::get_singleton()->get_name());
+	script_option_edit->set_item_metadata(0, GDScriptLanguage::get_singleton()->get_extension());
+	script_option_edit->select(0);
+	//TODO: add other languages
+	grid->add_child(script_option_edit);
+
+	Label *script_lb = memnew(Label);
+	script_lb->set_text(TTR("Script Name:"));
+	grid->add_child(script_lb);
+
+	script_edit = memnew(LineEdit);
+	script_edit->connect("text_changed", this, "_on_required_text_changed");
+	script_edit->set_placeholder("\"plugin.gd\" -> res://addons/my_plugin/plugin.gd");
+	grid->add_child(script_edit);
+
+	Label *active_lb = memnew(Label);
+	active_lb->set_text(TTR("Activate now?"));
+	grid->add_child(active_lb);
+
+	active_edit = memnew(CheckBox);
+	active_edit->set_pressed(true);
+	grid->add_child(active_edit);
+}
+
+PluginCreateDialog::~PluginCreateDialog() {
+}
diff --git a/editor/plugin_create_dialog.h b/editor/plugin_create_dialog.h
new file mode 100644
index 000000000000..4c3c6dd08cc4
--- /dev/null
+++ b/editor/plugin_create_dialog.h
@@ -0,0 +1,71 @@
+/*************************************************************************/
+/*  plugin_create_dialog.h                                               */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2018 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 PLUGIN_CREATE_DIALOG_H
+#define PLUGIN_CREATE_DIALOG_H
+
+#include "../scene/gui/check_box.h"
+#include "../scene/gui/dialogs.h"
+#include "../scene/gui/line_edit.h"
+#include "../scene/gui/option_button.h"
+#include "../scene/gui/text_edit.h"
+
+class PluginCreateDialog : public ConfirmationDialog {
+
+	GDCLASS(PluginCreateDialog, ConfirmationDialog);
+
+	LineEdit *name_edit;
+	LineEdit *subfolder_edit;
+	TextEdit *desc_edit;
+	LineEdit *author_edit;
+	LineEdit *version_edit;
+	OptionButton *script_option_edit;
+	LineEdit *script_edit;
+	CheckBox *active_edit;
+
+	bool _edit_mode;
+
+	void _clear_fields();
+	void _on_confirmed();
+	void _on_cancelled();
+	void _on_required_text_changed(const String &p_text);
+
+protected:
+	virtual void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+	void config(const String &p_plugin_dir_name);
+
+	PluginCreateDialog();
+	~PluginCreateDialog();
+};
+
+#endif
diff --git a/editor/project_settings_editor.cpp b/editor/project_settings_editor.cpp
index 3e17385909bd..d450c8a433b2 100644
--- a/editor/project_settings_editor.cpp
+++ b/editor/project_settings_editor.cpp
@@ -783,6 +783,10 @@ void ProjectSettingsEditor::popup_project_settings() {
 	plugin_settings->update_plugins();
 }
 
+void ProjectSettingsEditor::update_plugins() {
+	plugin_settings->update_plugins();
+}
+
 void ProjectSettingsEditor::_item_selected() {
 
 	TreeItem *ti = globals_editor->get_property_editor()->get_property_tree()->get_selected();
diff --git a/editor/project_settings_editor.h b/editor/project_settings_editor.h
index b8bfdcd87615..52b0c890dc45 100644
--- a/editor/project_settings_editor.h
+++ b/editor/project_settings_editor.h
@@ -181,6 +181,7 @@ class ProjectSettingsEditor : public AcceptDialog {
 	static ProjectSettingsEditor *get_singleton() { return singleton; }
 	void popup_project_settings();
 	void set_plugins_page();
+	void update_plugins();
 
 	EditorAutoloadSettings *get_autoload_settings() { return autoload_settings; }
 
diff --git a/editor/property_editor.cpp b/editor/property_editor.cpp
index e912ebe03a41..096db8b23a84 100644
--- a/editor/property_editor.cpp
+++ b/editor/property_editor.cpp
@@ -284,11 +284,7 @@ void CustomPropertyEditor::_menu_option(int p_which) {
 						return;
 					}
 
-					Object *obj = ClassDB::instance(intype);
-
-					if (!obj) {
-						obj = EditorNode::get_editor_data().instance_custom_type(intype, "Resource");
-					}
+					Object *obj = _instance_type(intype);
 
 					ERR_BREAK(!obj);
 					Resource *res = Object::cast_to<Resource>(obj);
@@ -882,10 +878,13 @@ 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"];
+				EditorData::TypeDB &tdb = EditorNode::get_editor_data().get_type_db();
+				List<StringName> custom_resources;
+				EditorData::TypeDbTypes db_type = EditorData::TYPEDB_TYPE_SCRIPT;
+				tdb.get_class_list(&custom_resources, db_type);
+				for (List<StringName>::Element *E = custom_resources.front(); E; E = E->next()) {
+					if (!tdb.is_parent_class(E->get(), "Resource", db_type) || !tdb.is_custom(E->get()))
+						custom_resources.erase(E->get());
 				}
 
 				for (int i = 0; i < hint_text.get_slice_count(","); i++) {
@@ -897,8 +896,8 @@ bool CustomPropertyEditor::edit(Object *p_owner, const String &p_name, Variant::
 					List<StringName> inheritors;
 					ClassDB::get_inheriters_from_class(base.strip_edges(), &inheritors);
 
-					for (int i = 0; i < custom_resources.size(); i++) {
-						inheritors.push_back(custom_resources[i].name);
+					for (List<StringName>::Element *E = custom_resources.front(); E; E = E->next()) {
+						inheritors.push_back(E->get());
 					}
 
 					List<StringName>::Element *E = inheritors.front();
@@ -912,18 +911,11 @@ bool CustomPropertyEditor::edit(Object *p_owner, const String &p_name, Variant::
 
 						bool is_custom_resource = false;
 						Ref<Texture> icon;
-						if (!custom_resources.empty()) {
-							for (int i = 0; i < custom_resources.size(); i++) {
-								if (custom_resources[i].name == t) {
-									is_custom_resource = true;
-									if (custom_resources[i].icon.is_valid())
-										icon = custom_resources[i].icon;
-									break;
-								}
-							}
-						}
+						const EditorData::TypeInfo *res_ti = tdb.get_type_info(t, db_type);
+						if (res_ti && res_ti->icon.is_valid())
+							icon = res_ti->icon;
 
-						if (!is_custom_resource && !ClassDB::can_instance(t))
+						if ((res_ti && res_ti->is_custom && !tdb.can_instance(t, db_type)) || (ClassDB::class_exists(t) && !ClassDB::can_instance(t)))
 							continue;
 
 						inheritors_array.push_back(t);
@@ -1128,11 +1120,7 @@ void CustomPropertyEditor::_type_create_selected(int p_idx) {
 
 		String intype = inheritors_array[p_idx];
 
-		Object *obj = ClassDB::instance(intype);
-
-		if (!obj) {
-			obj = EditorNode::get_editor_data().instance_custom_type(intype, "Resource");
-		}
+		Object *obj = _instance_type(intype);
 
 		ERR_FAIL_COND(!obj);
 
@@ -1330,11 +1318,7 @@ void CustomPropertyEditor::_action_pressed(int p_which) {
 
 				if (hint == PROPERTY_HINT_RESOURCE_TYPE) {
 
-					Object *obj = ClassDB::instance(intype);
-
-					if (!obj) {
-						obj = EditorNode::get_editor_data().instance_custom_type(intype, "Resource");
-					}
+					Object *obj = _instance_type(intype);
 
 					ERR_BREAK(!obj);
 					Resource *res = Object::cast_to<Resource>(obj);
@@ -1455,6 +1439,10 @@ void CustomPropertyEditor::_drag_easing(const Ref<InputEvent> &p_ev) {
 	}
 }
 
+Object *CustomPropertyEditor::_instance_type(const String &p_type) {
+	return ClassDB::class_exists(p_type) ? ClassDB::instance(p_type) : EditorNode::get_editor_data().get_type_db().instance(p_type, EditorData::TYPEDB_TYPE_SCRIPT);
+}
+
 void CustomPropertyEditor::_draw_easing() {
 
 	RID ci = easing_draw->get_canvas_item();
diff --git a/editor/property_editor.h b/editor/property_editor.h
index 56743822d266..b8e3de447e7b 100644
--- a/editor/property_editor.h
+++ b/editor/property_editor.h
@@ -143,6 +143,8 @@ class CustomPropertyEditor : public Popup {
 	void _create_dialog_callback();
 	void _create_selected_property(const String &p_prop);
 
+	Object *_instance_type(const String &p_type);
+
 	void _color_changed(const Color &p_color);
 	void _draw_easing();
 	void _menu_option(int p_which);
diff --git a/editor/scene_tree_dock.cpp b/editor/scene_tree_dock.cpp
index 77ee65879b0d..69071513b888 100644
--- a/editor/scene_tree_dock.cpp
+++ b/editor/scene_tree_dock.cpp
@@ -315,6 +315,7 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
 					preferred = "Spatial";
 			}
 			create_dialog->set_preferred_search_result_type(preferred);
+			create_dialog->update_types();
 			create_dialog->popup_create(true);
 		} break;
 		case TOOL_INSTANCE: {
@@ -348,10 +349,15 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
 			if (!selected)
 				break;
 
+			EditorData::TypeDB &tdb = EditorNode::get_singleton()->get_editor_data().get_type_db();
 			Ref<Script> existing = selected->get_script();
-			if (existing.is_valid())
+			Dictionary script_meta = existing.is_valid() ? existing->get_script_metadata() : Dictionary();
+			String type_name = script_meta.has("type_name") ? script_meta["type_name"] : "";
+			const EditorData::TypeInfo *script_ti = tdb.get_type_info(type_name, EditorData::TYPEDB_TYPE_SCRIPT);
+
+			if (existing.is_valid() && !script_ti) {
 				editor->push_item(existing.ptr());
-			else {
+			} else {
 				String path = selected->get_filename();
 				if (path == "") {
 					String root_path = editor_data->get_edited_scene_root()->get_filename();
@@ -361,7 +367,13 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
 						path = root_path.get_base_dir() + "/" + selected->get_name();
 					}
 				}
-				script_create_dialog->config(selected->get_class(), path);
+				//Will need to update this when able to derive directly from Scripts.Typename
+				String name = selected->get_class();
+				if (script_ti && script_ti->is_custom) {
+					name = ProjectSettings::get_singleton()->get_setting("typedb/automation/inherit_by_typename_for_custom_types") ? tdb.get_script_create_dialog_inherits_field(*script_ti) : "\"" + script_ti->path + "\"";
+				}
+				String name = script_ti && script_ti->is_custom ? tdb.get_script_create_dialog_inherits_field(*script_ti) : selected->get_class();
+				script_create_dialog->config(name, path);
 				script_create_dialog->popup_centered();
 			}
 
@@ -376,13 +388,36 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
 			editor_data->get_undo_redo().create_action(TTR("Clear Script"));
 			editor_data->get_undo_redo().add_do_method(editor, "push_item", (Script *)NULL);
 
+			EditorData::TypeDB &tdb = EditorNode::get_singleton()->get_editor_data().get_type_db();
 			for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 				Ref<Script> existing = E->get()->get_script();
+
 				if (existing.is_valid()) {
-					const RefPtr empty;
-					editor_data->get_undo_redo().add_do_method(E->get(), "set_script", empty);
-					editor_data->get_undo_redo().add_undo_method(E->get(), "set_script", existing);
+					Ref<Script> current = existing;
+					bool match_found = false;
+					while (current.is_valid()) {
+						Dictionary script_meta = current->get_script_metadata();
+						String type_name = script_meta.has("type_name") ? script_meta["type_name"] : "";
+						const EditorData::TypeInfo *script_ti = tdb.get_type_info(type_name, EditorData::TYPEDB_TYPE_SCRIPT);
+
+						while (script_ti && !script_ti->is_custom) {
+							script_ti = tdb.get_type_info(script_ti->inherits, EditorData::TYPEDB_TYPE_SCRIPT);
+						}
+						if (script_ti) {
+							match_found = true;
+							editor_data->get_undo_redo().add_do_method(E->get(), "set_script", current.get_ref_ptr());
+							editor_data->get_undo_redo().add_undo_method(E->get(), "set_script", existing);
+							break;
+						} else {
+							current = current->get_base_script();
+						}
+					}
+					if (!match_found) {
+						const RefPtr empty;
+						editor_data->get_undo_redo().add_do_method(E->get(), "set_script", empty);
+						editor_data->get_undo_redo().add_undo_method(E->get(), "set_script", existing);
+					}
 				}
 			}
 
@@ -1329,6 +1364,9 @@ void SceneTreeDock::_script_created(Ref<Script> p_script) {
 	editor_data->get_undo_redo().add_do_method(this, "_update_script_button");
 	editor_data->get_undo_redo().add_undo_method(this, "_update_script_button");
 
+	editor_data->get_undo_redo().add_do_method(scene_tree, "update_tree");
+	editor_data->get_undo_redo().add_undo_method(scene_tree, "update_tree");
+
 	editor_data->get_undo_redo().commit_action();
 }
 
@@ -1418,7 +1456,15 @@ void SceneTreeDock::_delete_confirm() {
 
 void SceneTreeDock::_update_script_button() {
 	if (EditorNode::get_singleton()->get_editor_selection()->get_selection().size() == 1) {
-		if (EditorNode::get_singleton()->get_editor_selection()->get_selection().front()->key()->get_script().is_null()) {
+		EditorData::TypeDB &tdb = EditorNode::get_singleton()->get_editor_data().get_type_db();
+		Object *obj = EditorNode::get_singleton()->get_editor_selection()->get_selection().front()->key();
+		Ref<Script> s = obj->get_script();
+		bool script_is_custom = false;
+		if (s.is_valid() && tdb.has_path(s->get_path())) {
+			EditorData::TypeInfo &script_ti = tdb.get_path(s->get_path());
+			script_is_custom = script_ti.is_custom;
+		}
+		if (obj->get_script().is_null() || script_is_custom) {
 			button_create_script->show();
 			button_clear_script->hide();
 		} else {
@@ -1466,6 +1512,8 @@ void SceneTreeDock::_create() {
 		ERR_FAIL_COND(!child);
 
 		editor_data->get_undo_redo().create_action(TTR("Create Node"));
+		String node_name = create_dialog->get_selected_type().replacen(".", "/").get_file();
+		child->set_name(node_name);
 
 		if (edited_scene) {
 
diff --git a/editor/scene_tree_editor.cpp b/editor/scene_tree_editor.cpp
index 7d2127d4f8fe..00dfe34c0d22 100644
--- a/editor/scene_tree_editor.cpp
+++ b/editor/scene_tree_editor.cpp
@@ -252,7 +252,8 @@ bool SceneTreeEditor::_add_nodes(Node *p_node, TreeItem *p_parent) {
 
 		if (!p_node->get_script().is_null()) {
 
-			item->add_button(0, get_icon("Script", "EditorIcons"), BUTTON_SCRIPT, false, TTR("Open Script"));
+			item->add_button(0, get_icon("Script", "EditorIcons"), BUTTON_SCRIPT, false, TTR("Open script"));
+			_update_script_button_alpha(item, p_node);
 		}
 
 		if (p_node->is_class("CanvasItem")) {
@@ -331,6 +332,18 @@ bool SceneTreeEditor::_add_nodes(Node *p_node, TreeItem *p_parent) {
 	}
 }
 
+void SceneTreeEditor::_update_script_button_alpha(TreeItem *p_item, Node *p_node) {
+
+	Ref<Script> s = p_node->get_script();
+	bool script_is_custom = false;
+	EditorData::TypeDB &tdb = EditorNode::get_singleton()->get_editor_data().get_type_db();
+	if (s.is_valid() && tdb.has_path(s->get_path())) {
+		EditorData::TypeInfo &ti = tdb.get_path(s->get_path());
+		script_is_custom = ti.is_custom;
+	}
+	p_item->set_button_color(0, p_item->get_button_by_id(0, BUTTON_SCRIPT), Color(1, 1, 1, (script_is_custom ? 0.3 : 1)));
+}
+
 void SceneTreeEditor::_node_visibility_changed(Node *p_node) {
 
 	if (p_node != get_scene_node() && !p_node->get_owner()) {
diff --git a/editor/scene_tree_editor.h b/editor/scene_tree_editor.h
index b173d7d2150e..79aa82fae60b 100644
--- a/editor/scene_tree_editor.h
+++ b/editor/scene_tree_editor.h
@@ -110,6 +110,7 @@ class SceneTreeEditor : public Control {
 	void _node_script_changed(Node *p_node);
 	void _node_visibility_changed(Node *p_node);
 	void _update_visibility_color(Node *p_node, TreeItem *p_item);
+	void _update_script_button_alpha(TreeItem *p_item, Node *p_node);
 
 	void _node_replace_owner(Node *p_base, Node *p_node, Node *p_root);
 
diff --git a/editor/script_create_dialog.cpp b/editor/script_create_dialog.cpp
index 57a003060e1d..eeac2f6dcffb 100644
--- a/editor/script_create_dialog.cpp
+++ b/editor/script_create_dialog.cpp
@@ -77,6 +77,12 @@ bool ScriptCreateDialog::_validate(const String &p_string) {
 
 	String path_chars = "\"res://";
 	bool is_val_path = ScriptServer::get_language(language_menu->get_selected())->can_inherit_from_file();
+
+	EditorData::TypeDB &tdb = EditorNode::get_singleton()->get_editor_data().get_type_db();
+	int type_name_pos = p_string.find(".", 0);
+	String type_name = (type_name_pos != String::npos) ? p_string.substr(type_name_pos + 1, p_string.length() - type_name_pos) : p_string;
+	bool is_type = tdb.class_exists(type_name);
+
 	for (int i = 0; i < p_string.length(); i++) {
 
 		if (i == 0) {
@@ -84,17 +90,17 @@ bool ScriptCreateDialog::_validate(const String &p_string) {
 				return false; // no start with number plz
 		}
 
-		if (i == p_string.length() - 1 && is_val_path)
+		if (i == p_string.length() - 1 && is_val_path && !is_type)
 			return p_string[i] == '\"';
 
-		if (is_val_path && i < path_chars.length()) {
+		if (is_val_path && !is_type && i < path_chars.length()) {
 			if (p_string[i] != path_chars[i])
 				is_val_path = false;
 			else
 				continue;
 		}
 
-		bool valid_char = (p_string[i] >= '0' && p_string[i] <= '9') || (p_string[i] >= 'a' && p_string[i] <= 'z') || (p_string[i] >= 'A' && p_string[i] <= 'Z') || p_string[i] == '_' || p_string[i] == '-' || (is_val_path && (p_string[i] == '/' || p_string[i] == '.'));
+		bool valid_char = (p_string[i] >= '0' && p_string[i] <= '9') || (p_string[i] >= 'a' && p_string[i] <= 'z') || (p_string[i] >= 'A' && p_string[i] <= 'Z') || p_string[i] == '_' || p_string[i] == '-' || (is_val_path && p_string[i] == '.');
 
 		if (!valid_char)
 			return false;
@@ -160,6 +166,8 @@ void ScriptCreateDialog::_create_new() {
 	}
 
 	Ref<Script> scr;
+	bool is_type = EditorNode::get_singleton()->get_editor_data().get_type_db().class_exists(parent_name->get_text());
+	String parent_text = parent_name->get_text();
 	if (script_template != "") {
 		scr = ResourceLoader::load(script_template);
 		if (scr.is_null()) {
@@ -169,9 +177,9 @@ void ScriptCreateDialog::_create_new() {
 			return;
 		}
 		scr = scr->duplicate();
-		ScriptServer::get_language(language_menu->get_selected())->make_template(cname_param, parent_name->get_text(), scr);
+		ScriptServer::get_language(language_menu->get_selected())->make_template(cname_param, parent_text, scr);
 	} else {
-		scr = ScriptServer::get_language(language_menu->get_selected())->get_template(cname_param, parent_name->get_text());
+		scr = ScriptServer::get_language(language_menu->get_selected())->get_template(cname_param, parent_text);
 	}
 
 	if (has_named_classes) {
diff --git a/main/main.cpp b/main/main.cpp
index 2e3c2f41b915..2c858689daf1 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -1310,7 +1310,7 @@ bool Main::start() {
 		{
 			DirAccessRef da = DirAccess::open(doc_tool);
 			if (!da) {
-				ERR_EXPLAIN("Argument supplied to --doctool must be a base godot build directory");
+				ERR_EXPLAIN("Argument supplied to --doctool must be a base godot build directory. Given: " + doc_tool);
 				ERR_FAIL_V(false);
 			}
 		}
@@ -1333,6 +1333,53 @@ bool Main::start() {
 			}
 		}
 
+		{
+			String path = "res://doc_classes";
+			if (DirAccess::exists(ProjectSettings::get_singleton()->globalize_path(path))) {
+				checked_paths.insert(path);
+				docsrc.load_classes(path);
+				print_line("Loading docs from: " + path);
+			}
+		}
+		{
+			Error err;
+			DirAccessRef da = DirAccess::create(DirAccess::ACCESS_RESOURCES);
+			if (da) {
+				da->change_dir(ProjectSettings::get_singleton()->globalize_path("res://addons/"));
+				da->list_dir_begin();
+				String path;
+				bool isdir;
+				path = da->get_next(&isdir);
+				while (path != String()) {
+					if (isdir) {
+						DirAccessRef subda = DirAccess::open("res://addons/" + path, &err);
+						if (subda) {
+							subda->list_dir_begin();
+							String sub_path;
+							bool subisdir;
+							sub_path = subda->get_next(&subisdir);
+							while (sub_path != String()) {
+								if (sub_path == "." || sub_path == "..") {
+									sub_path = da->get_next(&subisdir);
+									continue;
+								}
+								String doc_path = "res://addons/" + sub_path.plus_file("doc_classes");
+								if (subisdir && DirAccess::exists(doc_path) && !checked_paths.has(doc_path)) {
+									checked_paths.insert(doc_path);
+									docsrc.load_classes(doc_path);
+									print_line("Loading docs from: " + doc_path);
+								}
+								sub_path = da->get_next(&subisdir);
+							}
+							subda->list_dir_end();
+						}
+					}
+					path = da->get_next(&isdir);
+				}
+				da->list_dir_end();
+			}
+		}
+
 		String index_path = doc_tool.plus_file("doc/classes");
 		docsrc.load_classes(index_path);
 		checked_paths.insert(index_path);
@@ -1353,6 +1400,9 @@ bool Main::start() {
 
 #endif
 
+	GLOBAL_DEF("typedb/automation/inherit_by_typename_for_custom_types", true);
+	GLOBAL_DEF("typedb/automation/auto_generate_custom_script_docs", false);
+
 	if (_export_preset != "") {
 		if (game_path == "") {
 			String err = "Command line param ";
diff --git a/modules/gdnative/nativescript/nativescript.cpp b/modules/gdnative/nativescript/nativescript.cpp
index d6abbc1bcf75..0c04ada6ef1c 100644
--- a/modules/gdnative/nativescript/nativescript.cpp
+++ b/modules/gdnative/nativescript/nativescript.cpp
@@ -353,7 +353,7 @@ void NativeScript::get_script_method_list(List<MethodInfo> *p_list) const {
 	}
 }
 
-void NativeScript::get_script_property_list(List<PropertyInfo> *p_list) const {
+void NativeScript::get_script_property_list(List<PropertyInfo> *p_list, bool p_no_inherited) const {
 	NativeScriptDesc *script_data = get_script_desc();
 
 	Set<StringName> existing_properties;
@@ -367,6 +367,10 @@ void NativeScript::get_script_property_list(List<PropertyInfo> *p_list) const {
 				existing_properties.insert(E.key());
 			}
 		}
+
+		if (p_no_inherited)
+			break;
+
 		script_data = script_data->base_data;
 	}
 }
diff --git a/modules/gdnative/nativescript/nativescript.h b/modules/gdnative/nativescript/nativescript.h
index b47962dc3703..1128d3e25529 100644
--- a/modules/gdnative/nativescript/nativescript.h
+++ b/modules/gdnative/nativescript/nativescript.h
@@ -162,7 +162,7 @@ class NativeScript : public Script {
 
 	virtual void update_exports(); //editor tool
 	virtual void get_script_method_list(List<MethodInfo> *p_list) const;
-	virtual void get_script_property_list(List<PropertyInfo> *p_list) const;
+	virtual void get_script_property_list(List<PropertyInfo> *p_list, bool p_no_inherited = false) const;
 
 	String get_class_documentation() const;
 	String get_method_documentation(const StringName &p_method) const;
diff --git a/modules/gdnative/pluginscript/pluginscript_script.cpp b/modules/gdnative/pluginscript/pluginscript_script.cpp
index c3a623e9a102..87da8fec4308 100644
--- a/modules/gdnative/pluginscript/pluginscript_script.cpp
+++ b/modules/gdnative/pluginscript/pluginscript_script.cpp
@@ -279,7 +279,7 @@ void PluginScript::get_script_method_list(List<MethodInfo> *r_methods) const {
 	}
 }
 
-void PluginScript::get_script_property_list(List<PropertyInfo> *r_properties) const {
+void PluginScript::get_script_property_list(List<PropertyInfo> *r_properties, bool p_no_inherited) const {
 	ASSERT_SCRIPT_VALID();
 	for (Map<StringName, PropertyInfo>::Element *e = _properties_info.front(); e != NULL; e = e->next()) {
 		r_properties->push_back(e->get());
diff --git a/modules/gdnative/pluginscript/pluginscript_script.h b/modules/gdnative/pluginscript/pluginscript_script.h
index 31c6c4d67ff0..798179fd2d88 100644
--- a/modules/gdnative/pluginscript/pluginscript_script.h
+++ b/modules/gdnative/pluginscript/pluginscript_script.h
@@ -112,7 +112,7 @@ class PluginScript : public Script {
 
 	virtual void update_exports();
 	virtual void get_script_method_list(List<MethodInfo> *r_methods) const;
-	virtual void get_script_property_list(List<PropertyInfo> *r_properties) const;
+	virtual void get_script_property_list(List<PropertyInfo> *r_properties, bool p_no_inherited = false) const;
 
 	virtual int get_member_line(const StringName &p_member) const;
 
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index f23e7854a59e..6282045877c5 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -30,6 +30,7 @@
 
 #include "gdscript.h"
 
+#include "../../core/script_language.h"
 #include "engine.h"
 #include "gdscript_compiler.h"
 #include "global_constants.h"
@@ -181,7 +182,7 @@ Variant GDScript::_new(const Variant **p_args, int p_argcount, Variant::CallErro
 
 bool GDScript::can_instance() const {
 
-	return valid || (!tool && !ScriptServer::is_scripting_enabled());
+	return (valid || (!tool && !ScriptServer::is_scripting_enabled())) && instanceable;
 }
 
 Ref<Script> GDScript::get_base_script() const {
@@ -234,7 +235,7 @@ void GDScript::get_script_method_list(List<MethodInfo> *p_list) const {
 	}
 }
 
-void GDScript::get_script_property_list(List<PropertyInfo> *p_list) const {
+void GDScript::get_script_property_list(List<PropertyInfo> *p_list, bool p_no_inherited) const {
 
 	const GDScript *sptr = this;
 	List<PropertyInfo> props;
@@ -258,6 +259,9 @@ void GDScript::get_script_property_list(List<PropertyInfo> *p_list) const {
 			props.push_front(sptr->member_info[msort[i].name]);
 		}
 
+		if (p_no_inherited)
+			break;
+
 		sptr = sptr->_base;
 	}
 
@@ -603,6 +607,24 @@ Error GDScript::reload(bool p_keep_state) {
 
 	valid = true;
 
+	GDScript *top = this;
+	while (top) {
+
+		Map<StringName, GDScriptFunction *>::Element *E = top->member_functions.find("can_instance");
+		if (E) {
+
+			if (!E->get()->is_static()) {
+				WARN_PRINT(String("Can't call non-static function: 'can_instance' in script.").utf8().get_data());
+			}
+
+			Variant::CallError err;
+			const Variant **args;
+			instanceable = E->get()->call(NULL, args, 0, err).operator bool();
+			break;
+		}
+		top = top->_base;
+	}
+
 	for (Map<StringName, Ref<GDScript> >::Element *E = subclasses.front(); E; E = E->next()) {
 
 		_set_subclass_path(E->get(), path);
@@ -633,6 +655,97 @@ void GDScript::get_members(Set<StringName> *p_members) {
 	}
 }
 
+Dictionary GDScript::get_script_metadata() {
+
+	if (has_method("_get_script_metadata")) {
+		Variant::CallError ce;
+		Variant ret = call("_get_script_metadata", NULL, 0, ce);
+		if (ce.error = Variant::CallError::CALL_OK) {
+			if (ret.get_type() == Variant::NIL) {
+				return Dictionary();
+			}
+			Dictionary dict = ret;
+			return dict;
+		}
+	}
+
+	FileAccess *fa = FileAccess::open(get_path(), FileAccess::READ);
+	if (!fa)
+		return Dictionary();
+
+	String line = fa->get_line();
+	String export_decl = "export(";
+
+	// skip lines which are probably just comments
+	while (!fa->eof_reached() && line.find("#", 0) != String::npos)
+		line = fa->get_line();
+
+	int exp_pos = line.find(export_decl, 0);
+	if (exp_pos != 0) {
+		fa->close();
+		return Dictionary();
+	}
+
+	int exp_end = line.rfind(")");
+	line = line.substr(export_decl.length(), exp_end - export_decl.length());
+
+	Vector<String> params = line.split(",");
+
+	String type_name = params[0].strip_edges();
+	type_name = type_name.substr(1, type_name.length() - 2);
+	if (!(type_name.get_slicec('.', 0).length() && type_name.get_slicec('.', 1).length())) {
+		fa->close();
+		return Dictionary();
+	}
+
+	Dictionary result;
+	result["type_name"] = type_name;
+
+	for (int i = 1; i < params.size(); i++) {
+		String param = params[i].strip_edges();
+		if (param == "CUSTOM") {
+			result["is_custom"] = true;
+			if (i < params.size() - 1) {
+				param = params[i + 1].strip_edges();
+				param = param.substr(1, param.length() - 2);
+				if (FileAccess::exists(param)) {
+					i++;
+					RES res = ResourceLoader::load(param);
+					if (res.is_valid() && res->is_class("Texture")) {
+						result["icon_path"] = param;
+					}
+				}
+			}
+		} else if (param == "ABSTRACT")
+			result["is_abstract"] = true;
+	}
+
+	while (!fa->eof_reached()) {
+		line = fa->get_line();
+		if (line.find("extends", 0) == 0) {
+			String extends_str = "extends ";
+			String extend = line.substr(extends_str.length(), line.length() - extends_str.length()).strip_edges();
+			String file_path = file_path.substr(1, file_path.length() - 2);
+			if (file_path.get_extension() == GDScriptLanguage::get_singleton()->get_extension()) {
+				break;
+			}
+			if (extend.get_slice_count(".") > 1)
+				extend = extend.substr(String("Scripts.").length(), extend.length() - String("Scripts.").length());
+			result["base_name"] = extend;
+			break;
+		}
+		String first_word = line.substr(0, line.find(" ", 0));
+		if (first_word == "var" || first_word == "func" || first_word == "class")
+			break;
+	}
+	if (!result.has("base_name"))
+		result["base_name"] = "Reference";
+
+	fa->close();
+
+	return result;
+}
+
 Variant GDScript::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
 
 	GDScript *top = this;
@@ -887,6 +1000,7 @@ GDScript::GDScript() :
 	_base = NULL;
 	_owner = NULL;
 	tool = false;
+	instanceable = true;
 #ifdef TOOLS_ENABLED
 	source_changed_cache = false;
 #endif
@@ -1381,6 +1495,14 @@ void GDScriptLanguage::init() {
 
 		_add_global(E->get().name, E->get().ptr);
 	}
+
+	ProjectSettings *ps = ProjectSettings::get_singleton();
+	if (ps->has_setting("typedb/scripts")) {
+		_add_global("Scripts", ps->get_setting("typedb/scripts"));
+	}
+	if (ps->has_setting("typedb/scenes")) {
+		_add_global("Scenes", ps->get_setting("typedb/scenes"));
+	}
 }
 
 String GDScriptLanguage::get_type() const {
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
index a35b0a10d59a..d807dfa63cc9 100644
--- a/modules/gdscript/gdscript.h
+++ b/modules/gdscript/gdscript.h
@@ -58,6 +58,7 @@ class GDScript : public Script {
 	GDCLASS(GDScript, Script);
 	bool tool;
 	bool valid;
+	bool instanceable;
 
 	struct MemberInfo {
 		int index;
@@ -186,7 +187,7 @@ class GDScript : public Script {
 	virtual bool has_method(const StringName &p_method) const;
 	virtual MethodInfo get_method_info(const StringName &p_method) const;
 
-	virtual void get_script_property_list(List<PropertyInfo> *p_list) const;
+	virtual void get_script_property_list(List<PropertyInfo> *p_list, bool p_no_inherited = false) const;
 
 	virtual ScriptLanguage *get_language() const;
 
@@ -202,6 +203,8 @@ class GDScript : public Script {
 	virtual void get_constants(Map<StringName, Variant> *p_constants);
 	virtual void get_members(Set<StringName> *p_members);
 
+	virtual Dictionary get_script_metadata();
+
 	GDScript();
 	~GDScript();
 };
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
index 5c834966c5e1..963f610d77e4 100644
--- a/modules/gdscript/gdscript_compiler.cpp
+++ b/modules/gdscript/gdscript_compiler.cpp
@@ -1770,25 +1770,90 @@ Error GDScriptCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, cons
 
 			} else {
 
-				if (p_class->extends_class.size() > 1) {
+				if (p_class->extends_class.size() >= 1 && p_class->extends_class[0] == "Scripts") {
 
-					_set_error("Invalid inheritance (unknown class+subclasses)", p_class);
-					return ERR_FILE_NOT_FOUND;
-				}
-				//if not found, try engine classes
-				if (!GDScriptLanguage::get_singleton()->get_global_map().has(base)) {
+					GDScriptLanguage *lang = GDScriptLanguage::get_singleton();
+					if (!lang->get_global_map().has("Scripts")) {
+						_set_error("'Scripts' global is undefined.", p_class);
+						return ERR_BUG;
+					}
+					if (p_class->extends_class.size() <= 2) {
+						_set_error("Must use a namespaced typename: Scripts.Namespace.Typename", p_class);
+						return ERR_BUG;
+					}
 
-					_set_error("Unknown class: '" + base + "'", p_class);
-					return ERR_FILE_NOT_FOUND;
+					Dictionary scripts = lang->get_global_array()[lang->get_global_map()["Scripts"]];
+					String type_name = p_class->extends_class[1];
+
+					for (int i_extends = 2; i_extends < p_class->extends_class.size(); i_extends++) {
+						type_name = StringName(type_name + String(".") + p_class->extends_class[i_extends]);
+						if (scripts.has(type_name)) {
+							Ref<GDScript> a_script = ResourceLoader::load(scripts[type_name], "GDScript");
+							if (i_extends == p_class->extends_class.size() - 1) {
+								script = a_script;
+							} else {
+
+								i_extends++;
+
+								String base = p_class->extends_class[i_extends];
+								Ref<GDScript> base_class = a_script;
+
+								if (base_class.is_valid()) {
+
+									String ident = base;
+
+									for (int i = i_extends; i < p_class->extends_class.size(); i++) {
+
+										String subclass = p_class->extends_class[i];
+
+										ident += ("." + subclass);
+
+										if (base_class->subclasses.has(subclass)) {
+
+											base_class = base_class->subclasses[subclass];
+										} else if (base_class->constants.has(subclass)) {
+
+											Ref<GDScript> new_base_class = base_class->constants[subclass];
+											if (new_base_class.is_null()) {
+												_set_error("Constant is not a class: " + ident, p_class);
+												return ERR_SCRIPT_FAILED;
+											}
+											base_class = new_base_class;
+										} else {
+
+											_set_error("Could not find subclass: " + ident, p_class);
+											return ERR_FILE_NOT_FOUND;
+										}
+									}
+
+									script = base_class;
+								}
+							}
+						}
+					}
 				}
 
-				int base_idx = GDScriptLanguage::get_singleton()->get_global_map()[base];
-				native = GDScriptLanguage::get_singleton()->get_global_array()[base_idx];
-				if (!native.is_valid()) {
+				if (script.is_null()) {
+					if (p_class->extends_class.size() > 1) {
 
-					_set_error("Global not a class: '" + base + "'", p_class);
+						_set_error("Invalid inheritance (unknown class+subclasses)", p_class);
+						return ERR_FILE_NOT_FOUND;
+					}
+					//if not found, try engine classes
+					if (!GDScriptLanguage::get_singleton()->get_global_map().has(base)) {
 
-					return ERR_FILE_NOT_FOUND;
+						_set_error("Unknown class: '" + base + "'", p_class);
+						return ERR_FILE_NOT_FOUND;
+					}
+
+					int base_idx = GDScriptLanguage::get_singleton()->get_global_map()[base];
+					native = GDScriptLanguage::get_singleton()->get_global_array()[base_idx];
+					if (!native.is_valid()) {
+
+						_set_error("Global not a class: '" + base + "'", p_class);
+
+						return ERR_FILE_NOT_FOUND;
+					}
 				}
 			}
 		}
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index fdb92a68a9ef..bd23ea65ab28 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -30,6 +30,7 @@
 
 #include "gdscript_parser.h"
 
+#include "../../core/project_settings.h"
 #include "gdscript.h"
 #include "io/resource_loader.h"
 #include "os/file_access.h"
@@ -727,9 +728,71 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			}
 
 			if (!bfn) {
-				IdentifierNode *id = alloc_node<IdentifierNode>();
-				id->name = identifier;
-				expr = id;
+
+				if (identifier == "Scripts" || identifier == "Scenes") {
+
+					if (tokenizer->get_token() != GDScriptTokenizer::TK_PERIOD) {
+						_set_error("'" + String(identifier) + "' must be accessed with a period '.'");
+						return NULL;
+					}
+					tokenizer->advance();
+
+					String type_name = "";
+					GDScriptTokenizer::Token t = tokenizer->get_token();
+					const Map<StringName, int> &map = GDScriptLanguage::get_singleton()->get_global_map();
+
+					if (map.has(identifier)) {
+						GDScriptLanguage *lang = GDScriptLanguage::get_singleton();
+						lang->add_global_constant(identifier, ProjectSettings::get_singleton()->get_setting("typedb/" + String(identifier).to_lower()));
+						Dictionary type_map = lang->get_global_array()[lang->get_global_map()[identifier]];
+						bool found_type = false;
+						while (t == GDScriptTokenizer::TK_IDENTIFIER || t == GDScriptTokenizer::TK_PERIOD) {
+
+							if (t == GDScriptTokenizer::TK_PERIOD) {
+								tokenizer->advance();
+								t = tokenizer->get_token();
+								continue;
+							}
+
+							StringName type_identifier = tokenizer->get_token_identifier();
+							if (type_name.length())
+								type_name += ".";
+							type_name += String(type_identifier);
+
+							if (type_map.has(type_name)) {
+
+								OperatorNode *op = alloc_node<OperatorNode>();
+								op->op = OperatorNode::OP_CALL;
+
+								BuiltInFunctionNode *bn = alloc_node<BuiltInFunctionNode>();
+								bn->function = GDScriptFunctions::RESOURCE_LOAD;
+								op->arguments.push_back(bn);
+
+								ConstantNode *path = alloc_node<ConstantNode>();
+								path->value = String(type_map[type_name]);
+								op->arguments.push_back(path);
+
+								expr = op;
+								found_type = true;
+								tokenizer->advance();
+								break;
+							}
+							tokenizer->advance();
+							t = tokenizer->get_token();
+						}
+						if (!found_type) {
+							if (String(type_name).get_slice_count(".") >= 2)
+								_set_error("'" + String(identifier) + "' global failed to match any substring in: " + String(type_name));
+							else
+								_set_error("'" + String(identifier) + "' global must be followed by namespaced typename: Scripts.Namespace.Typename");
+							return NULL;
+						}
+					}
+				} else {
+					IdentifierNode *id = alloc_node<IdentifierNode>();
+					id->name = identifier;
+					expr = id;
+				}
 			}
 
 		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ADD || tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB || tokenizer->get_token() == GDScriptTokenizer::TK_OP_NOT || tokenizer->get_token() == GDScriptTokenizer::TK_OP_BIT_INVERT) {
@@ -1182,7 +1245,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 		}
 	}
 
-	/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
+	/* Reduce the set of expressions and place them in an operator tree, respecting precedence */
 
 	while (expression.size() > 1) {
 
@@ -3445,6 +3508,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				tokenizer->advance();
 
+				bool typename_defined = false;
 				if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
 
 					tokenizer->advance();
@@ -3464,7 +3528,93 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 						}
 					}
 
-					if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE) {
+					if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT) {
+
+						const Variant v = tokenizer->get_token_constant();
+						String s = v;
+
+						if (!p_class->extends_used && !p_class->tool) {
+							bool good_class_export = v.get_type() == Variant::STRING && s.get_slicec('.', 0).length() && s.get_slicec('.', 1).length();
+							int token_line = tokenizer->get_token_line(0);
+							if (!good_class_export && token_line == 1) {
+								_set_error("Namespace required: export(\"Namespace.Typename\"[, ...])\\n");
+								return;
+							}
+
+							tokenizer->advance();
+							if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE || tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+								typename_defined = true;
+							}
+
+							bool is_abstract = false;
+							bool is_custom = false;
+							while (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+								tokenizer->advance();
+								if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER) {
+									String identifier = tokenizer->get_token_identifier();
+									if (identifier == "ABSTRACT") {
+										if (is_abstract) {
+											_set_error("Duplication of 'ABSTRACT' flag.");
+											return;
+										}
+										is_abstract = true;
+										tokenizer->advance();
+									} else if (identifier == "CUSTOM") {
+										if (is_custom) {
+											_set_error("Duplication of 'CUSTOM' flag.");
+											return;
+										}
+										is_custom = true;
+										tokenizer->advance();
+										if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											break;
+										} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA && tokenizer->get_token(1) == GDScriptTokenizer::TK_CONSTANT) {
+											tokenizer->advance();
+											GDScriptTokenizer::Token icon_token = tokenizer->get_token();
+											if (icon_token == GDScriptTokenizer::TK_CONSTANT) {
+												Variant icon_var = tokenizer->get_token_constant();
+												if (icon_var.get_type() == Variant::STRING) {
+													if (FileAccess::exists(String(icon_var))) {
+														tokenizer->advance();
+														break;
+													} else {
+														_set_error("Custom icon filepath in class export could not be opened.");
+														return;
+													}
+												}
+												_set_error("String parameter must follow class export's 'CUSTOM' flag.");
+												return;
+											} else if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER) {
+												while (true) {
+													switch (icon_token) {
+														case GDScriptTokenizer::TK_IDENTIFIER:
+														case GDScriptTokenizer::TK_PERIOD: {
+															tokenizer->advance();
+															icon_token = tokenizer->get_token();
+														} break;
+													}
+												}
+											} else {
+												_set_error("Expected a Texture identifier or file path after 'CUSTOM' in class export.");
+												return;
+											}
+										}
+									} else {
+										_set_error("Unrecognized class export parameter.");
+										return;
+									}
+								} else {
+									_set_error("Expected class export parameter after comma.");
+									return;
+								}
+							}
+						} else if (v.get_type() == Variant::STRING) {
+							_set_error("Misplaced class export. Must be first statement.");
+							return;
+						} else {
+							tokenizer->advance();
+						}
+					} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE) {
 
 						Variant::Type type = tokenizer->get_token_type();
 						if (type == Variant::NIL) {
@@ -3931,7 +4081,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 					tokenizer->advance();
 				}
 
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_ONREADY && tokenizer->get_token() != GDScriptTokenizer::TK_PR_REMOTE && tokenizer->get_token() != GDScriptTokenizer::TK_PR_MASTER && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SLAVE && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_REMOTESYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_MASTERSYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SLAVESYNC) {
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_ONREADY && tokenizer->get_token() != GDScriptTokenizer::TK_PR_REMOTE && tokenizer->get_token() != GDScriptTokenizer::TK_PR_MASTER && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SLAVE && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_REMOTESYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_MASTERSYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SLAVESYNC && !typename_defined) {
 
 					current_export = PropertyInfo();
 					_set_error("Expected 'var', 'onready', 'remote', 'master', 'slave', 'sync', 'remotesync', 'mastersync', 'slavesync'.");
diff --git a/modules/mono/csharp_script.cpp b/modules/mono/csharp_script.cpp
index 46c40b26900c..0eca629753c9 100644
--- a/modules/mono/csharp_script.cpp
+++ b/modules/mono/csharp_script.cpp
@@ -2183,7 +2183,7 @@ Ref<Script> CSharpScript::get_base_script() const {
 	return Ref<Script>();
 }
 
-void CSharpScript::get_script_property_list(List<PropertyInfo> *p_list) const {
+void CSharpScript::get_script_property_list(List<PropertyInfo> *p_list, bool p_no_inheritance) const {
 
 	for (Map<StringName, PropertyInfo>::Element *E = member_info.front(); E; E = E->next()) {
 		p_list->push_back(E->value());
diff --git a/modules/mono/csharp_script.h b/modules/mono/csharp_script.h
index cae2bbf40a10..1198a8379666 100644
--- a/modules/mono/csharp_script.h
+++ b/modules/mono/csharp_script.h
@@ -152,7 +152,7 @@ class CSharpScript : public Script {
 	virtual void update_signals();
 
 	/* TODO */ virtual bool get_property_default_value(const StringName &p_property, Variant &r_value) const;
-	virtual void get_script_property_list(List<PropertyInfo> *p_list) const;
+	virtual void get_script_property_list(List<PropertyInfo> *p_list, bool p_no_inheritance = false) const;
 	virtual void update_exports();
 
 	virtual bool is_tool() const { return tool; }
diff --git a/modules/visual_script/visual_script.cpp b/modules/visual_script/visual_script.cpp
index 933109217112..e677a46072d8 100644
--- a/modules/visual_script/visual_script.cpp
+++ b/modules/visual_script/visual_script.cpp
@@ -1071,7 +1071,7 @@ MethodInfo VisualScript::get_method_info(const StringName &p_method) const {
 	return mi;
 }
 
-void VisualScript::get_script_property_list(List<PropertyInfo> *p_list) const {
+void VisualScript::get_script_property_list(List<PropertyInfo> *p_list, bool p_no_inherited) const {
 
 	List<StringName> vars;
 	get_variable_list(&vars);
diff --git a/modules/visual_script/visual_script.h b/modules/visual_script/visual_script.h
index aaa6dfea11c6..237e002adfaa 100644
--- a/modules/visual_script/visual_script.h
+++ b/modules/visual_script/visual_script.h
@@ -351,7 +351,7 @@ class VisualScript : public Script {
 	virtual bool has_method(const StringName &p_method) const;
 	virtual MethodInfo get_method_info(const StringName &p_method) const;
 
-	virtual void get_script_property_list(List<PropertyInfo> *p_list) const;
+	virtual void get_script_property_list(List<PropertyInfo> *p_list, bool p_no_inherited = false) const;
 
 	virtual int get_member_line(const StringName &p_member) const;