8 files changed, 632 insertions, 264 deletions

diff --git a/core/config/project_settings.cpp b/core/config/project_settings.cpp
index 541dbfa212..c872ae2162 100644
--- a/core/config/project_settings.cpp
+++ b/core/config/project_settings.cpp
@@ -32,6 +32,7 @@
 
 #include "core/core_bind.h"
 #include "core/core_string_names.h"
+#include "core/input/input_map.h"
 #include "core/io/file_access_network.h"
 #include "core/io/file_access_pack.h"
 #include "core/io/marshalls.h"
@@ -1057,17 +1058,35 @@ void ProjectSettings::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("save_custom", "file"), &ProjectSettings::_save_custom_bnd);
 }
 
+void ProjectSettings::_add_builtin_input_map() {
+	if (InputMap::get_singleton()) {
+		OrderedHashMap<String, List<Ref<InputEvent>>> builtins = InputMap::get_singleton()->get_builtins();
+
+		for (OrderedHashMap<String, List<Ref<InputEvent>>>::Element E = builtins.front(); E; E = E.next()) {
+			Array events;
+
+			// Convert list of input events into array
+			for (List<Ref<InputEvent>>::Element *I = E.get().front(); I; I = I->next()) {
+				events.push_back(I->get());
+			}
+
+			Dictionary action;
+			action["deadzone"] = Variant(0.5f);
+			action["events"] = events;
+
+			String action_name = "input/" + E.key();
+			GLOBAL_DEF(action_name, action);
+			input_presets.push_back(action_name);
+		}
+	}
+}
+
 ProjectSettings::ProjectSettings() {
 	// Initialization of engine variables should be done in the setup() method,
 	// so that the values can be overridden from project.godot or project.binary.
 
 	singleton = this;
 
-	Array events;
-	Dictionary action;
-	Ref<InputEventKey> key;
-	Ref<InputEventJoypadButton> joyb;
-
 	GLOBAL_DEF_BASIC("application/config/name", "");
 	GLOBAL_DEF_BASIC("application/config/description", "");
 	custom_prop_info["application/config/description"] = PropertyInfo(Variant::STRING, "application/config/description", PROPERTY_HINT_MULTILINE_TEXT);
@@ -1094,163 +1113,7 @@ ProjectSettings::ProjectSettings() {
 	GLOBAL_DEF("editor/script/templates_search_path", "res://script_templates");
 	custom_prop_info["editor/script/templates_search_path"] = PropertyInfo(Variant::STRING, "editor/script/templates_search_path", PROPERTY_HINT_DIR);
 
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_ENTER);
-	events.push_back(key);
-	key.instance();
-	key->set_keycode(KEY_KP_ENTER);
-	events.push_back(key);
-	key.instance();
-	key->set_keycode(KEY_SPACE);
-	events.push_back(key);
-	joyb.instance();
-	joyb->set_button_index(JOY_BUTTON_A);
-	events.push_back(joyb);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_accept", action);
-	input_presets.push_back("input/ui_accept");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_SPACE);
-	events.push_back(key);
-	joyb.instance();
-	joyb->set_button_index(JOY_BUTTON_Y);
-	events.push_back(joyb);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_select", action);
-	input_presets.push_back("input/ui_select");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_ESCAPE);
-	events.push_back(key);
-	joyb.instance();
-	joyb->set_button_index(JOY_BUTTON_B);
-	events.push_back(joyb);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_cancel", action);
-	input_presets.push_back("input/ui_cancel");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_TAB);
-	events.push_back(key);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_focus_next", action);
-	input_presets.push_back("input/ui_focus_next");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_TAB);
-	key->set_shift(true);
-	events.push_back(key);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_focus_prev", action);
-	input_presets.push_back("input/ui_focus_prev");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_LEFT);
-	events.push_back(key);
-	joyb.instance();
-	joyb->set_button_index(JOY_BUTTON_DPAD_LEFT);
-	events.push_back(joyb);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_left", action);
-	input_presets.push_back("input/ui_left");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_RIGHT);
-	events.push_back(key);
-	joyb.instance();
-	joyb->set_button_index(JOY_BUTTON_DPAD_RIGHT);
-	events.push_back(joyb);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_right", action);
-	input_presets.push_back("input/ui_right");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_UP);
-	events.push_back(key);
-	joyb.instance();
-	joyb->set_button_index(JOY_BUTTON_DPAD_UP);
-	events.push_back(joyb);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_up", action);
-	input_presets.push_back("input/ui_up");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_DOWN);
-	events.push_back(key);
-	joyb.instance();
-	joyb->set_button_index(JOY_BUTTON_DPAD_DOWN);
-	events.push_back(joyb);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_down", action);
-	input_presets.push_back("input/ui_down");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_PAGEUP);
-	events.push_back(key);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_page_up", action);
-	input_presets.push_back("input/ui_page_up");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_PAGEDOWN);
-	events.push_back(key);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_page_down", action);
-	input_presets.push_back("input/ui_page_down");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_HOME);
-	events.push_back(key);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_home", action);
-	input_presets.push_back("input/ui_home");
-
-	action = Dictionary();
-	action["deadzone"] = Variant(0.5f);
-	events = Array();
-	key.instance();
-	key->set_keycode(KEY_END);
-	events.push_back(key);
-	action["events"] = events;
-	GLOBAL_DEF("input/ui_end", action);
-	input_presets.push_back("input/ui_end");
+	_add_builtin_input_map();
 
 	custom_prop_info["display/window/handheld/orientation"] = PropertyInfo(Variant::STRING, "display/window/handheld/orientation", PROPERTY_HINT_ENUM, "landscape,portrait,reverse_landscape,reverse_portrait,sensor_landscape,sensor_portrait,sensor");
 	custom_prop_info["rendering/driver/threads/thread_model"] = PropertyInfo(Variant::INT, "rendering/driver/threads/thread_model", PROPERTY_HINT_ENUM, "Single-Unsafe,Single-Safe,Multi-Threaded");
diff --git a/core/config/project_settings.h b/core/config/project_settings.h
index 2b230e06f9..ed8fb19fa0 100644
--- a/core/config/project_settings.h
+++ b/core/config/project_settings.h
@@ -116,6 +116,9 @@ protected:
 
 	Error _setup(const String &p_path, const String &p_main_pack, bool p_upwards = false);
 
+	void _add_builtin_input_map();
+
+protected:
 	static void _bind_methods();
 
 public:
diff --git a/core/input/input.cpp b/core/input/input.cpp
index 48e573626d..90d96e3876 100644
--- a/core/input/input.cpp
+++ b/core/input/input.cpp
@@ -604,21 +604,21 @@ void Input::_parse_input_event_impl(const Ref<InputEvent> &p_event, bool p_is_em
 		}
 	}
 
-	for (const Map<StringName, InputMap::Action>::Element *E = InputMap::get_singleton()->get_action_map().front(); E; E = E->next()) {
-		if (InputMap::get_singleton()->event_is_action(p_event, E->key())) {
+	for (OrderedHashMap<StringName, InputMap::Action>::ConstElement E = InputMap::get_singleton()->get_action_map().front(); E; E = E.next()) {
+		if (InputMap::get_singleton()->event_is_action(p_event, E.key())) {
 			// If not echo and action pressed state has changed
-			if (!p_event->is_echo() && is_action_pressed(E->key(), false) != p_event->is_action_pressed(E->key())) {
+			if (!p_event->is_echo() && is_action_pressed(E.key(), false) != p_event->is_action_pressed(E.key())) {
 				Action action;
 				action.physics_frame = Engine::get_singleton()->get_physics_frames();
 				action.process_frame = Engine::get_singleton()->get_process_frames();
-				action.pressed = p_event->is_action_pressed(E->key());
+				action.pressed = p_event->is_action_pressed(E.key());
 				action.strength = 0.0f;
 				action.raw_strength = 0.0f;
-				action.exact = InputMap::get_singleton()->event_is_action(p_event, E->key(), true);
-				action_state[E->key()] = action;
+				action.exact = InputMap::get_singleton()->event_is_action(p_event, E.key(), true);
+				action_state[E.key()] = action;
 			}
-			action_state[E->key()].strength = p_event->get_action_strength(E->key());
-			action_state[E->key()].raw_strength = p_event->get_action_raw_strength(E->key());
+			action_state[E.key()].strength = p_event->get_action_strength(E.key());
+			action_state[E.key()].raw_strength = p_event->get_action_raw_strength(E.key());
 		}
 	}
 
diff --git a/core/input/input_map.cpp b/core/input/input_map.cpp
index c03e64eaf4..1e8d3ef7d3 100644
--- a/core/input/input_map.cpp
+++ b/core/input/input_map.cpp
@@ -88,8 +88,8 @@ List<StringName> InputMap::get_actions() const {
 		return actions;
 	}
 
-	for (Map<StringName, Action>::Element *E = input_map.front(); E; E = E->next()) {
-		actions.push_back(E->key());
+	for (OrderedHashMap<StringName, Action>::Element E = input_map.front(); E; E = E.next()) {
+		actions.push_back(E.key());
 	}
 
 	return actions;
@@ -179,12 +179,12 @@ Array InputMap::_action_get_events(const StringName &p_action) {
 }
 
 const List<Ref<InputEvent>> *InputMap::action_get_events(const StringName &p_action) {
-	const Map<StringName, Action>::Element *E = input_map.find(p_action);
+	const OrderedHashMap<StringName, Action>::Element E = input_map.find(p_action);
 	if (!E) {
 		return nullptr;
 	}
 
-	return &E->get().inputs;
+	return &E.get().inputs;
 }
 
 bool InputMap::event_is_action(const Ref<InputEvent> &p_event, const StringName &p_action, bool p_exact_match) const {
@@ -192,7 +192,7 @@ bool InputMap::event_is_action(const Ref<InputEvent> &p_event, const StringName
 }
 
 bool InputMap::event_get_action_status(const Ref<InputEvent> &p_event, const StringName &p_action, bool p_exact_match, bool *p_pressed, float *p_strength, float *p_raw_strength) const {
-	Map<StringName, Action>::Element *E = input_map.find(p_action);
+	OrderedHashMap<StringName, Action>::Element E = input_map.find(p_action);
 	ERR_FAIL_COND_V_MSG(!E, false, "Request for nonexistent InputMap action '" + String(p_action) + "'.");
 
 	Ref<InputEventAction> input_event_action = p_event;
@@ -209,7 +209,7 @@ bool InputMap::event_get_action_status(const Ref<InputEvent> &p_event, const Str
 	bool pressed;
 	float strength;
 	float raw_strength;
-	List<Ref<InputEvent>>::Element *event = _find_event(E->get(), p_event, p_exact_match, &pressed, &strength, &raw_strength);
+	List<Ref<InputEvent>>::Element *event = _find_event(E.get(), p_event, p_exact_match, &pressed, &strength, &raw_strength);
 	if (event != nullptr) {
 		if (p_pressed != nullptr) {
 			*p_pressed = pressed;
@@ -226,7 +226,7 @@ bool InputMap::event_get_action_status(const Ref<InputEvent> &p_event, const Str
 	}
 }
 
-const Map<StringName, InputMap::Action> &InputMap::get_action_map() const {
+const OrderedHashMap<StringName, InputMap::Action> &InputMap::get_action_map() const {
 	return input_map;
 }
 
@@ -260,84 +260,440 @@ void InputMap::load_from_project_settings() {
 	}
 }
 
+struct _BuiltinActionDisplayName {
+	const char *name;
+	const char *display_name;
+};
+
+static const _BuiltinActionDisplayName _builtin_action_display_names[] = {
+	/* clang-format off */
+    { "ui_accept",                                     TTRC("Accept") },
+    { "ui_select",                                     TTRC("Select") },
+    { "ui_cancel",                                     TTRC("Cancel") },
+    { "ui_focus_next",                                 TTRC("Focus Next") },
+    { "ui_focus_prev",                                 TTRC("Focus Prev") },
+    { "ui_left",                                       TTRC("Left") },
+    { "ui_right",                                      TTRC("Right") },
+    { "ui_up",                                         TTRC("Up") },
+    { "ui_down",                                       TTRC("Down") },
+    { "ui_page_up",                                    TTRC("Page Up") },
+    { "ui_page_down",                                  TTRC("Page Down") },
+    { "ui_home",                                       TTRC("Home") },
+    { "ui_end",                                        TTRC("End") },
+    { "ui_cut",                                        TTRC("Cut") },
+    { "ui_copy",                                       TTRC("Copy") },
+    { "ui_paste",                                      TTRC("Paste") },
+    { "ui_undo",                                       TTRC("Undo") },
+    { "ui_redo",                                       TTRC("Redo") },
+    { "ui_text_completion_query",                      TTRC("Completion Query") },
+    { "ui_text_newline",                               TTRC("New Line") },
+    { "ui_text_newline_blank",                         TTRC("New Blank Line") },
+    { "ui_text_newline_above",                         TTRC("New Line Above") },
+    { "ui_text_indent",                                TTRC("Indent") },
+    { "ui_text_dedent",                                TTRC("Dedent") },
+    { "ui_text_backspace",                             TTRC("Backspace") },
+    { "ui_text_backspace_word",                        TTRC("Backspace Word") },
+    { "ui_text_backspace_word.OSX",                    TTRC("Backspace Word") },
+    { "ui_text_backspace_all_to_left",                 TTRC("Backspace all to Left") },
+    { "ui_text_backspace_all_to_left.OSX",             TTRC("Backspace all to Left") },
+    { "ui_text_delete",                                TTRC("Delete") },
+    { "ui_text_delete_word",                           TTRC("Delete Word") },
+    { "ui_text_delete_word.OSX",                       TTRC("Delete Word") },
+    { "ui_text_delete_all_to_right",                   TTRC("Delete all to Right") },
+    { "ui_text_delete_all_to_right.OSX",               TTRC("Delete all to Right") },
+    { "ui_text_caret_left",                            TTRC("Caret Left") },
+    { "ui_text_caret_word_left",                       TTRC("Caret Word Left") },
+    { "ui_text_caret_word_left.OSX",                   TTRC("Caret Word Left") },
+    { "ui_text_caret_right",                           TTRC("Caret Right") },
+    { "ui_text_caret_word_right",                      TTRC("Caret Word Right") },
+    { "ui_text_caret_word_right.OSX",                  TTRC("Caret Word Right") },
+    { "ui_text_caret_up",                              TTRC("Caret Up") },
+    { "ui_text_caret_down",                            TTRC("Caret Down") },
+    { "ui_text_caret_line_start",                      TTRC("Caret Line Start") },
+    { "ui_text_caret_line_start.OSX",                  TTRC("Caret Line Start") },
+    { "ui_text_caret_line_end",                        TTRC("Caret Line End") },
+    { "ui_text_caret_line_end.OSX",                    TTRC("Caret Line End") },
+    { "ui_text_caret_page_up",                         TTRC("Caret Page Up") },
+    { "ui_text_caret_page_down",                       TTRC("Caret Page Down") },
+    { "ui_text_caret_document_start",                  TTRC("Caret Document Start") },
+    { "ui_text_caret_document_start.OSX",              TTRC("Caret Document Start") },
+    { "ui_text_caret_document_end",                    TTRC("Caret Document End") },
+    { "ui_text_caret_document_end.OSX",                TTRC("Caret Document End") },
+    { "ui_text_scroll_up",                             TTRC("Scroll Up") },
+    { "ui_text_scroll_up.OSX",                         TTRC("Scroll Up") },
+    { "ui_text_scroll_down",                           TTRC("Scroll Down") },
+    { "ui_text_scroll_down.OSX",                       TTRC("Scroll Down") },
+    { "ui_text_select_all",                            TTRC("Select All") },
+    { "ui_text_toggle_insert_mode",                    TTRC("Toggle Insert Mode") },
+    { "ui_graph_duplicate",                            TTRC("Duplicate Nodes") },
+    { "ui_graph_delete",                               TTRC("Delete Nodes") },
+    { "ui_filedialog_up_one_level",                    TTRC("Go Up One Level") },
+    { "ui_filedialog_refresh",                         TTRC("Refresh") },
+    { "ui_filedialog_show_hidden",                     TTRC("Show Hidden") },
+    { "ui_swap_input_direction ",                      TTRC("Swap Input Direction") },
+    { "",                                              TTRC("")}
+	/* clang-format on */
+};
+
+String InputMap::get_builtin_display_name(const String &p_name) const {
+	int len = sizeof(_builtin_action_display_names) / sizeof(_BuiltinActionDisplayName);
+
+	for (int i = 0; i < len; i++) {
+		if (_builtin_action_display_names[i].name == p_name) {
+			return RTR(_builtin_action_display_names[i].display_name);
+		}
+	}
+
+	return p_name;
+}
+
+const OrderedHashMap<String, List<Ref<InputEvent>>> &InputMap::get_builtins() {
+	// Return cache if it has already been built.
+	if (default_builtin_cache.size()) {
+		return default_builtin_cache;
+	}
+
+	List<Ref<InputEvent>> inputs;
+	inputs.push_back(InputEventKey::create_reference(KEY_ENTER));
+	inputs.push_back(InputEventKey::create_reference(KEY_KP_ENTER));
+	inputs.push_back(InputEventKey::create_reference(KEY_SPACE));
+	default_builtin_cache.insert("ui_accept", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventJoypadButton::create_reference(JOY_BUTTON_Y));
+	inputs.push_back(InputEventKey::create_reference(KEY_SPACE));
+	default_builtin_cache.insert("ui_select", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_ESCAPE));
+	default_builtin_cache.insert("ui_cancel", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_TAB));
+	default_builtin_cache.insert("ui_focus_next", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_TAB | KEY_MASK_SHIFT));
+	default_builtin_cache.insert("ui_focus_prev", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_LEFT));
+	inputs.push_back(InputEventJoypadButton::create_reference(JOY_BUTTON_DPAD_LEFT));
+	default_builtin_cache.insert("ui_left", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_RIGHT));
+	inputs.push_back(InputEventJoypadButton::create_reference(JOY_BUTTON_DPAD_RIGHT));
+	default_builtin_cache.insert("ui_right", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_UP));
+	inputs.push_back(InputEventJoypadButton::create_reference(JOY_BUTTON_DPAD_UP));
+	default_builtin_cache.insert("ui_up", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_DOWN));
+	inputs.push_back(InputEventJoypadButton::create_reference(JOY_BUTTON_DPAD_DOWN));
+	default_builtin_cache.insert("ui_down", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_PAGEUP));
+	default_builtin_cache.insert("ui_page_up", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_PAGEDOWN));
+	default_builtin_cache.insert("ui_page_down", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_HOME));
+	default_builtin_cache.insert("ui_home", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_END));
+	default_builtin_cache.insert("ui_end", inputs);
+
+	// ///// UI basic Shortcuts /////
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_X | KEY_MASK_CMD));
+	inputs.push_back(InputEventKey::create_reference(KEY_DELETE | KEY_MASK_SHIFT));
+	default_builtin_cache.insert("ui_cut", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_C | KEY_MASK_CMD));
+	inputs.push_back(InputEventKey::create_reference(KEY_INSERT | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_copy", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_V | KEY_MASK_CMD));
+	inputs.push_back(InputEventKey::create_reference(KEY_INSERT | KEY_MASK_SHIFT));
+	default_builtin_cache.insert("ui_paste", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_Z | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_undo", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_Y | KEY_MASK_CMD));
+	inputs.push_back(InputEventKey::create_reference(KEY_Z | KEY_MASK_CMD | KEY_MASK_SHIFT));
+	default_builtin_cache.insert("ui_redo", inputs);
+
+	// ///// UI Text Input Shortcuts /////
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_SPACE | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_completion_query", inputs);
+
+	// Newlines
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_ENTER));
+	inputs.push_back(InputEventKey::create_reference(KEY_KP_ENTER));
+	default_builtin_cache.insert("ui_text_newline", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+
+	inputs.push_back(InputEventKey::create_reference(KEY_ENTER | KEY_MASK_CMD));
+	inputs.push_back(InputEventKey::create_reference(KEY_KP_ENTER | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_newline_blank", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_ENTER | KEY_MASK_SHIFT | KEY_MASK_CMD));
+	inputs.push_back(InputEventKey::create_reference(KEY_KP_ENTER | KEY_MASK_SHIFT | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_newline_above", inputs);
+
+	// Indentation
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_TAB));
+	default_builtin_cache.insert("ui_text_indent", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_TAB | KEY_MASK_SHIFT));
+	default_builtin_cache.insert("ui_text_dedent", inputs);
+
+	// Text Backspace and Delete
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_BACKSPACE));
+	default_builtin_cache.insert("ui_text_backspace", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_BACKSPACE | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_backspace_word", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_BACKSPACE | KEY_MASK_ALT));
+	default_builtin_cache.insert("ui_text_backspace_word.OSX", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	default_builtin_cache.insert("ui_text_backspace_all_to_left", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_BACKSPACE | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_backspace_all_to_left.OSX", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_DELETE));
+	default_builtin_cache.insert("ui_text_delete", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_DELETE | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_delete_word", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_DELETE | KEY_MASK_ALT));
+	default_builtin_cache.insert("ui_text_delete_word.OSX", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	default_builtin_cache.insert("ui_text_delete_all_to_right", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_DELETE | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_delete_all_to_right.OSX", inputs);
+
+	// Text Caret Movement Left/Right
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_LEFT));
+	default_builtin_cache.insert("ui_text_caret_left", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_LEFT | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_caret_word_left", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_LEFT | KEY_MASK_ALT));
+	default_builtin_cache.insert("ui_text_caret_word_left.OSX", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_RIGHT));
+	default_builtin_cache.insert("ui_text_caret_right", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_RIGHT | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_caret_word_right", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_RIGHT | KEY_MASK_ALT));
+	default_builtin_cache.insert("ui_text_caret_word_right.OSX", inputs);
+
+	// Text Caret Movement Up/Down
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_UP));
+	default_builtin_cache.insert("ui_text_caret_up", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_DOWN));
+	default_builtin_cache.insert("ui_text_caret_down", inputs);
+
+	// Text Caret Movement Line Start/End
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_HOME));
+	default_builtin_cache.insert("ui_text_caret_line_start", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_A | KEY_MASK_CTRL));
+	inputs.push_back(InputEventKey::create_reference(KEY_LEFT | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_caret_line_start.OSX", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_END));
+	default_builtin_cache.insert("ui_text_caret_line_end", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_E | KEY_MASK_CTRL));
+	inputs.push_back(InputEventKey::create_reference(KEY_RIGHT | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_caret_line_end.OSX", inputs);
+	// Text Caret Movement Page Up/Down
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_PAGEUP));
+	default_builtin_cache.insert("ui_text_caret_page_up", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_PAGEDOWN));
+	default_builtin_cache.insert("ui_text_caret_page_down", inputs);
+
+	// Text Caret Movement Document Start/End
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_HOME | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_caret_document_start", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_UP | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_caret_document_start.OSX", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_END | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_caret_document_end", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_DOWN | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_caret_document_end.OSX", inputs);
+
+	// Text Scrolling
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_UP | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_scroll_up", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_UP | KEY_MASK_CMD | KEY_MASK_ALT));
+	default_builtin_cache.insert("ui_text_scroll_up.OSX", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_DOWN | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_scroll_down", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_DOWN | KEY_MASK_CMD | KEY_MASK_ALT));
+	default_builtin_cache.insert("ui_text_scroll_down.OSX", inputs);
+
+	// Text Misc
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_A | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_text_select_all", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_INSERT));
+	default_builtin_cache.insert("ui_text_toggle_insert_mode", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_MENU));
+	default_builtin_cache.insert("ui_menu", inputs);
+
+	// ///// UI Graph Shortcuts /////
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_D | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_graph_duplicate", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_DELETE));
+	default_builtin_cache.insert("ui_graph_delete", inputs);
+
+	// ///// UI File Dialog Shortcuts /////
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_BACKSPACE));
+	default_builtin_cache.insert("ui_filedialog_up_one_level", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_F5));
+	default_builtin_cache.insert("ui_filedialog_refresh", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_H));
+	default_builtin_cache.insert("ui_filedialog_show_hidden", inputs);
+
+	inputs = List<Ref<InputEvent>>();
+	inputs.push_back(InputEventKey::create_reference(KEY_QUOTELEFT | KEY_MASK_CMD));
+	default_builtin_cache.insert("ui_swap_input_direction", inputs);
+
+	return default_builtin_cache;
+}
+
 void InputMap::load_default() {
-	Ref<InputEventKey> key;
-
-	add_action("ui_accept");
-	key.instance();
-	key->set_keycode(KEY_ENTER);
-	action_add_event("ui_accept", key);
-
-	key.instance();
-	key->set_keycode(KEY_KP_ENTER);
-	action_add_event("ui_accept", key);
-
-	key.instance();
-	key->set_keycode(KEY_SPACE);
-	action_add_event("ui_accept", key);
-
-	add_action("ui_select");
-	key.instance();
-	key->set_keycode(KEY_SPACE);
-	action_add_event("ui_select", key);
-
-	add_action("ui_cancel");
-	key.instance();
-	key->set_keycode(KEY_ESCAPE);
-	action_add_event("ui_cancel", key);
-
-	add_action("ui_focus_next");
-	key.instance();
-	key->set_keycode(KEY_TAB);
-	action_add_event("ui_focus_next", key);
-
-	add_action("ui_focus_prev");
-	key.instance();
-	key->set_keycode(KEY_TAB);
-	key->set_shift(true);
-	action_add_event("ui_focus_prev", key);
-
-	add_action("ui_left");
-	key.instance();
-	key->set_keycode(KEY_LEFT);
-	action_add_event("ui_left", key);
-
-	add_action("ui_right");
-	key.instance();
-	key->set_keycode(KEY_RIGHT);
-	action_add_event("ui_right", key);
-
-	add_action("ui_up");
-	key.instance();
-	key->set_keycode(KEY_UP);
-	action_add_event("ui_up", key);
-
-	add_action("ui_down");
-	key.instance();
-	key->set_keycode(KEY_DOWN);
-	action_add_event("ui_down", key);
-
-	add_action("ui_page_up");
-	key.instance();
-	key->set_keycode(KEY_PAGEUP);
-	action_add_event("ui_page_up", key);
-
-	add_action("ui_page_down");
-	key.instance();
-	key->set_keycode(KEY_PAGEDOWN);
-	action_add_event("ui_page_down", key);
-
-	add_action("ui_home");
-	key.instance();
-	key->set_keycode(KEY_HOME);
-	action_add_event("ui_home", key);
-
-	add_action("ui_end");
-	key.instance();
-	key->set_keycode(KEY_END);
-	action_add_event("ui_end", key);
-
-	//set("display/window/handheld/orientation", "landscape");
+	OrderedHashMap<String, List<Ref<InputEvent>>> builtins = get_builtins();
+
+	// List of Builtins which have an override for OSX.
+	Vector<String> osx_builtins;
+	for (OrderedHashMap<String, List<Ref<InputEvent>>>::Element E = builtins.front(); E; E = E.next()) {
+		if (String(E.key()).ends_with(".OSX")) {
+			// Strip .OSX from name: some_input_name.OSX -> some_input_name
+			osx_builtins.push_back(String(E.key()).split(".")[0]);
+		}
+	}
+
+	for (OrderedHashMap<String, List<Ref<InputEvent>>>::Element E = builtins.front(); E; E = E.next()) {
+		String fullname = E.key();
+		String name = fullname.split(".")[0];
+		String override_for = fullname.split(".").size() > 1 ? fullname.split(".")[1] : "";
+
+#ifdef APPLE_STYLE_KEYS
+		if (osx_builtins.has(name) && override_for != "OSX") {
+			// Name has osx builtin but this particular one is for non-osx systems - so skip.
+			continue;
+		}
+#else
+		if (override_for == "OSX") {
+			// Override for OSX - not needed on non-osx platforms.
+			continue;
+		}
+#endif
+
+		add_action(name);
+
+		List<Ref<InputEvent>> inputs = E.get();
+		for (List<Ref<InputEvent>>::Element *I = inputs.front(); I; I = I->next()) {
+			Ref<InputEventKey> iek = I->get();
+
+			// For the editor, only add keyboard actions.
+			if (iek.is_valid()) {
+				action_add_event(fullname, I->get());
+			}
+		}
+	}
 }
 
 InputMap::InputMap() {
diff --git a/core/input/input_map.h b/core/input/input_map.h
index 28c692c7ba..99c71e1e53 100644
--- a/core/input/input_map.h
+++ b/core/input/input_map.h
@@ -33,6 +33,8 @@
 
 #include "core/input/input_event.h"
 #include "core/object/class_db.h"
+#include "core/object/object.h"
+#include "core/templates/ordered_hash_map.h"
 
 class InputMap : public Object {
 	GDCLASS(InputMap, Object);
@@ -52,7 +54,8 @@ public:
 private:
 	static InputMap *singleton;
 
-	mutable Map<StringName, Action> input_map;
+	mutable OrderedHashMap<StringName, Action> input_map;
+	OrderedHashMap<String, List<Ref<InputEvent>>> default_builtin_cache;
 
 	List<Ref<InputEvent>>::Element *_find_event(Action &p_action, const Ref<InputEvent> &p_event, bool p_exact_match = false, bool *p_pressed = nullptr, float *p_strength = nullptr, float *p_raw_strength = nullptr) const;
 
@@ -81,10 +84,14 @@ public:
 	bool event_is_action(const Ref<InputEvent> &p_event, const StringName &p_action, bool p_exact_match = false) const;
 	bool event_get_action_status(const Ref<InputEvent> &p_event, const StringName &p_action, bool p_exact_match = false, bool *p_pressed = nullptr, float *p_strength = nullptr, float *p_raw_strength = nullptr) const;
 
-	const Map<StringName, Action> &get_action_map() const;
+	const OrderedHashMap<StringName, Action> &get_action_map() const;
 	void load_from_project_settings();
 	void load_default();
 
+	String get_builtin_display_name(const String &p_name) const;
+	// Use an Ordered Map so insertion order is preserved. We want the elements to be 'grouped' somewhat.
+	const OrderedHashMap<String, List<Ref<InputEvent>>> &get_builtins();
+
 	InputMap();
 };
 
diff --git a/editor/editor_settings.cpp b/editor/editor_settings.cpp
index c530058c80..40647497af 100644
--- a/editor/editor_settings.cpp
+++ b/editor/editor_settings.cpp
@@ -31,6 +31,7 @@
 #include "editor_settings.h"
 
 #include "core/config/project_settings.h"
+#include "core/input/input_map.h"
 #include "core/io/certs_compressed.gen.h"
 #include "core/io/compression.h"
 #include "core/io/config_file.h"
@@ -70,7 +71,7 @@ bool EditorSettings::_set(const StringName &p_name, const Variant &p_value) {
 bool EditorSettings::_set_only(const StringName &p_name, const Variant &p_value) {
 	_THREAD_SAFE_METHOD_
 
-	if (p_name.operator String() == "shortcuts") {
+	if (p_name == "shortcuts") {
 		Array arr = p_value;
 		ERR_FAIL_COND_V(arr.size() && arr.size() & 1, true);
 		for (int i = 0; i < arr.size(); i += 2) {
@@ -84,6 +85,24 @@ bool EditorSettings::_set_only(const StringName &p_name, const Variant &p_value)
 		}
 
 		return false;
+	} else if (p_name == "builtin_action_overrides") {
+		Array actions_arr = p_value;
+		for (int i = 0; i < actions_arr.size(); i++) {
+			Dictionary action_dict = actions_arr[i];
+
+			String name = action_dict["name"];
+			Array events = action_dict["events"];
+
+			InputMap *im = InputMap::get_singleton();
+			im->action_erase_events(name);
+
+			builtin_action_overrides[name].clear();
+			for (int ev_idx = 0; ev_idx < events.size(); ev_idx++) {
+				im->action_add_event(name, events[ev_idx]);
+				builtin_action_overrides[name].push_back(events[ev_idx]);
+			}
+		}
+		return false;
 	}
 
 	bool changed = false;
@@ -118,11 +137,16 @@ bool EditorSettings::_set_only(const StringName &p_name, const Variant &p_value)
 bool EditorSettings::_get(const StringName &p_name, Variant &r_ret) const {
 	_THREAD_SAFE_METHOD_
 
-	if (p_name.operator String() == "shortcuts") {
+	if (p_name == "shortcuts") {
 		Array arr;
 		for (const Map<String, Ref<Shortcut>>::Element *E = shortcuts.front(); E; E = E->next()) {
 			Ref<Shortcut> sc = E->get();
 
+			if (builtin_action_overrides.has(E->key())) {
+				// This shortcut was auto-generated from built in actions: don't save.
+				continue;
+			}
+
 			if (optimize_save) {
 				if (!sc->has_meta("original")) {
 					continue; //this came from settings but is not any longer used
@@ -139,6 +163,27 @@ bool EditorSettings::_get(const StringName &p_name, Variant &r_ret) const {
 		}
 		r_ret = arr;
 		return true;
+	} else if (p_name == "builtin_action_overrides") {
+		Array actions_arr;
+		for (Map<String, List<Ref<InputEvent>>>::Element *E = builtin_action_overrides.front(); E; E = E->next()) {
+			List<Ref<InputEvent>> events = E->get();
+
+			// TODO: skip actions which are the same as the builtin.
+			Dictionary action_dict;
+			action_dict["name"] = E->key();
+
+			Array events_arr;
+			for (List<Ref<InputEvent>>::Element *I = events.front(); I; I = I->next()) {
+				events_arr.push_back(I->get());
+			}
+
+			action_dict["events"] = events_arr;
+
+			actions_arr.push_back(action_dict);
+		}
+
+		r_ret = actions_arr;
+		return true;
 	}
 
 	const VariantContainer *v = props.getptr(p_name);
@@ -220,6 +265,7 @@ void EditorSettings::_get_property_list(List<PropertyInfo> *p_list) const {
 	}
 
 	p_list->push_back(PropertyInfo(Variant::ARRAY, "shortcuts", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL)); //do not edit
+	p_list->push_back(PropertyInfo(Variant::ARRAY, "builtin_action_overrides", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
 }
 
 void EditorSettings::_add_property_info_bind(const Dictionary &p_info) {
@@ -1539,12 +1585,39 @@ bool EditorSettings::is_shortcut(const String &p_name, const Ref<InputEvent> &p_
 }
 
 Ref<Shortcut> EditorSettings::get_shortcut(const String &p_name) const {
-	const Map<String, Ref<Shortcut>>::Element *E = shortcuts.find(p_name);
-	if (!E) {
-		return Ref<Shortcut>();
+	const Map<String, Ref<Shortcut>>::Element *SC = shortcuts.find(p_name);
+	if (SC) {
+		return SC->get();
+	}
+
+	// If no shortcut with the provided name is found in the list, check the built-in shortcuts.
+	// Use the first item in the action list for the shortcut event, since a shortcut can only have 1 linked event.
+
+	Ref<Shortcut> sc;
+	const Map<String, List<Ref<InputEvent>>>::Element *builtin_override = builtin_action_overrides.find(p_name);
+	if (builtin_override) {
+		sc.instance();
+		sc->set_shortcut(builtin_override->get().front()->get());
+		sc->set_name(InputMap::get_singleton()->get_builtin_display_name(p_name));
+	}
+
+	// If there was no override, check the default builtins to see if it has an InputEvent for the provided name.
+	if (sc.is_null()) {
+		const OrderedHashMap<String, List<Ref<InputEvent>>>::ConstElement builtin_default = InputMap::get_singleton()->get_builtins().find(p_name);
+		if (builtin_default) {
+			sc.instance();
+			sc->set_shortcut(builtin_default.get().front()->get());
+			sc->set_name(InputMap::get_singleton()->get_builtin_display_name(p_name));
+		}
+	}
+
+	if (sc.is_valid()) {
+		// Add the shortcut to the list.
+		shortcuts[p_name] = sc;
+		return sc;
 	}
 
-	return E->get();
+	return Ref<Shortcut>();
 }
 
 void EditorSettings::get_shortcut_list(List<String> *r_shortcuts) {
@@ -1610,6 +1683,66 @@ Ref<Shortcut> ED_SHORTCUT(const String &p_path, const String &p_name, uint32_t p
 	return sc;
 }
 
+void EditorSettings::set_builtin_action_override(const String &p_name, const Array &p_events) {
+	List<Ref<InputEvent>> event_list;
+
+	// Override the whole list, since events may have their order changed or be added, removed or edited.
+	InputMap::get_singleton()->action_erase_events(p_name);
+	for (int i = 0; i < p_events.size(); i++) {
+		event_list.push_back(p_events[i]);
+		InputMap::get_singleton()->action_add_event(p_name, p_events[i]);
+	}
+
+	// Check if the provided event array is same as built-in. If it is, it does not need to be added to the overrides.
+	// Note that event order must also be the same.
+	bool same_as_builtin = true;
+	OrderedHashMap<String, List<Ref<InputEvent>>>::ConstElement builtin_default = InputMap::get_singleton()->get_builtins().find(p_name);
+	if (builtin_default) {
+		List<Ref<InputEvent>> builtin_events = builtin_default.get();
+
+		if (p_events.size() == builtin_events.size()) {
+			int event_idx = 0;
+
+			// Check equality of each event.
+			for (List<Ref<InputEvent>>::Element *E = builtin_events.front(); E; E = E->next()) {
+				if (!E->get()->shortcut_match(p_events[event_idx])) {
+					same_as_builtin = false;
+					break;
+				}
+				event_idx++;
+			}
+		} else {
+			same_as_builtin = false;
+		}
+	}
+
+	if (same_as_builtin && builtin_action_overrides.has(p_name)) {
+		builtin_action_overrides.erase(p_name);
+	} else {
+		builtin_action_overrides[p_name] = event_list;
+	}
+
+	// Update the shortcut (if it is used somewhere in the editor) to be the first event of the new list.
+	if (shortcuts.has(p_name)) {
+		shortcuts[p_name]->set_shortcut(event_list.front()->get());
+	}
+}
+
+const Array EditorSettings::get_builtin_action_overrides(const String &p_name) const {
+	const Map<String, List<Ref<InputEvent>>>::Element *AO = builtin_action_overrides.find(p_name);
+	if (AO) {
+		Array event_array;
+
+		List<Ref<InputEvent>> events_list = AO->get();
+		for (List<Ref<InputEvent>>::Element *E = events_list.front(); E; E = E->next()) {
+			event_array.push_back(E->get());
+		}
+		return event_array;
+	}
+
+	return Array();
+}
+
 void EditorSettings::notify_changes() {
 	_THREAD_SAFE_METHOD_
 
@@ -1648,6 +1781,8 @@ void EditorSettings::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_recent_dirs", "dirs"), &EditorSettings::set_recent_dirs);
 	ClassDB::bind_method(D_METHOD("get_recent_dirs"), &EditorSettings::get_recent_dirs);
 
+	ClassDB::bind_method(D_METHOD("set_builtin_action_override", "name", "actions_list"), &EditorSettings::set_builtin_action_override);
+
 	ADD_SIGNAL(MethodInfo("settings_changed"));
 
 	BIND_CONSTANT(NOTIFICATION_EDITOR_SETTINGS_CHANGED);
diff --git a/editor/editor_settings.h b/editor/editor_settings.h
index 616a938a86..e5f8527faf 100644
--- a/editor/editor_settings.h
+++ b/editor/editor_settings.h
@@ -84,7 +84,8 @@ private:
 	int last_order;
 
 	Ref<Resource> clipboard;
-	Map<String, Ref<Shortcut>> shortcuts;
+	mutable Map<String, Ref<Shortcut>> shortcuts;
+	Map<String, List<Ref<InputEvent>>> builtin_action_overrides;
 
 	String resource_path;
 	String settings_dir;
@@ -186,6 +187,9 @@ public:
 	Ref<Shortcut> get_shortcut(const String &p_name) const;
 	void get_shortcut_list(List<String> *r_shortcuts);
 
+	void set_builtin_action_override(const String &p_name, const Array &p_events);
+	const Array get_builtin_action_overrides(const String &p_name) const;
+
 	void notify_changes();
 
 	EditorSettings();
diff --git a/main/main.cpp b/main/main.cpp
index f068c39b58..0970f81ff1 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -515,8 +515,8 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
 
 	MAIN_PRINT("Main: Initialize Globals");
 
-	globals = memnew(ProjectSettings);
 	input_map = memnew(InputMap);
+	globals = memnew(ProjectSettings);
 
 	register_core_settings(); //here globals is present