Index: binaries/data/config/default.cfg
===================================================================
--- binaries/data/config/default.cfg
+++ binaries/data/config/default.cfg
@@ -312,8 +312,8 @@
 ; Overlays
 showstatusbars = Tab         ; Toggle display of status bars
 devcommands.toggle = "Alt+D" ; Toggle developer commands panel
-highlightguarding = PgDn     ; Toggle highlight of guarding units
-highlightguarded = PgUp      ; Toggle highlight of guarded units
+highlightguarding = PageDown ; Toggle highlight of guarding units
+highlightguarded = PageUp    ; Toggle highlight of guarded units
 diplomacycolors = "Alt+X"    ; Toggle diplomacy colors
 toggleattackrange = "Alt+C"  ; Toggle display of attack range overlays of selected defensive structures
 toggleaurasrange = "Alt+V"   ; Toggle display of aura range overlays of selected units and structures
Index: binaries/data/config/keys.txt
===================================================================
--- binaries/data/config/keys.txt
+++ binaries/data/config/keys.txt
@@ -1,7 +1,7 @@
 ## This file documents keynames that can be used in .cfg files for specifying hotkeys
 ## Note: the keynames are not actually configured or implemented here
-## Also note: if your keyboard supports keys that do not appear here (such as the French é letter),
-## you should be able to use it directly.
+## Note: those names map to 'scancodes', i.e. positions on a classic QWERTY keyboard.
+## The in-game hotkey editor will show you what that corresponds to.
 
 Backspace, BkSp
 Tab
@@ -19,7 +19,7 @@
 (, LeftParen
 ), RightParen
 *, Asterisk
-+, Plus
++, Plus 		## This maps to the same key as =
 ,, Comma
 -, Minus
 ., Period
@@ -34,7 +34,6 @@
 7
 8
 9
-:, Colon
 ;, Semicolon
 <, LessThan
 =, Equals
@@ -92,15 +91,15 @@
 Numpad Enter, NumEnter
 Numpad =, NumEquals
 
-Arrow Up, UpArrow
-Arrow Down, DownArrow
-Arrow Right, RightArrow
-Arrow Left, LeftArrow
+UpArrow
+DownArrow
+RightArrow
+LeftArrow
 Insert, Ins
 Home
 End
-Page Up, PgUp
-Page Down, PgDn
+PageUp
+PageDown
 
 F1
 F2
@@ -149,6 +148,5 @@
 Middle Mouse Button, MouseMiddle
 Mouse Wheel Up, WheelUp
 Mouse Wheel Down, WheelDown
-MouseButtonX, MouseNX # where X is a number 1-255, for extra mouse buttons
-## (note that some mice start numbering their buttons at higher numbers
-##  so the first extra button on your mouse might be #8 here)
+Mouse Wheel Left, MouseX1
+Mouse Wheel Right, MouseX2
Index: binaries/data/mods/public/gui/hotkeys/HotkeyPicker.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/hotkeys/HotkeyPicker.js
@@ -0,0 +1,106 @@
+/**
+ * Handle the interface to pick a hotkey combination.
+ * The player must keep a key combination for 2s in the input field for it to be registered.
+ */
+class HotkeyPicker
+{
+	constructor(onClose, name, combinations)
+	{
+		this.name = name;
+		this.combinations = combinations;
+		this.window = Engine.GetGUIObjectByName("hotkeyPicker");
+		this.window.hidden = false;
+
+		this.enteringInput = -1;
+
+		Engine.GetGUIObjectByName("hotkeyPickerTitle").caption = translate(this.name);
+
+		Engine.GetGUIObjectByName("hotkeyPickerDesc").caption = '' +
+		`Click on any mapping to modify it.`;
+
+		this.setupCombinations();
+
+		Engine.GetGUIObjectByName("hotkeyPickerReset").onPress = () => {
+			// This is a bit "using a bazooka to kill a fly"
+			Engine.ConfigDB_RemoveValue("user", "hotkey." + this.name);
+			Engine.ConfigDB_WriteFile("user", "config/user.cfg");
+			Engine.ReloadHotkeys();
+			let data = Engine.GetHotkeyMap();
+			this.combinations = data[this.name];
+			this.setupCombinations();
+		};
+		Engine.GetGUIObjectByName("hotkeyPickerCancel").onPress = () => {
+			onClose(this, false);
+		}
+		Engine.GetGUIObjectByName("hotkeyPickerAccept").onPress = () => {
+			onClose(this, true);
+		}
+	}
+
+	setupCombinations()
+	{
+		for (let i  = 0; i < 4; ++i)
+		{
+			let s = Engine.GetGUIObjectByName("combination[" + i + "]").size;
+			s.top = +i * 60 + 90;
+			s.bottom = +i * 60 + 120;
+			Engine.GetGUIObjectByName("combination[" + i + "]").size = s;
+			Engine.GetGUIObjectByName("combNb[" + i + "]").caption = translate(`#${i+1}`);
+
+			if (i == this.combinations.length)
+				this.combinations.push([]);
+
+			let input = Engine.GetGUIObjectByName("combMapping[" + i + "]");
+			input.caption = formatHotkeyCombination(this.combinations[i]);
+
+			let picker = Engine.GetGUIObjectByName("picker[" + i + "]");
+			Engine.GetGUIObjectByName("combMappingBtn[" + i + "]").onPress = () => {
+				if (this.enteringInput)
+				{
+
+				}
+				input.caption = translate("Enter new Hotkey, hold to register.");
+				this.enteringInput = i;
+				picker.focus();
+			};
+
+			picker.onKeyChange = keys => {
+				input.caption = (keys.length ?
+					formatHotkeyCombination(keys) + translate(" (hold to register)") :
+					translate("Enter new Hotkey, hold to register."));
+			}
+
+			Engine.GetGUIObjectByName("deleteComb[" + i + "]").onPress = (i => () => {
+				this.combinations[i] = [];
+				input.caption = "";
+			})(i);
+
+			Engine.GetGUIObjectByName("conflicts[" + i + "]").caption = "";
+
+			picker.onCombination = (i => keys => {
+				this.combinations[i] = keys;
+				input.caption = formatHotkeyCombination(this.combinations[i]);
+				picker.blur();
+
+				let conflicts = (Engine.GetConflicts(keys) || [])
+					.filter(name => name != this.name).map(translate);
+				if (conflicts.length)
+					Engine.GetGUIObjectByName("conflicts[" + i + "]").caption =
+						translate(`${coloredText("Conflicts with", "255 153 0")}: ${conflicts.join(", ")}`);
+			})(i);
+		}
+	}
+
+	close()
+	{
+		this.window.hidden = true;
+		for (let i  = 0; i < 4; ++i)
+			Engine.GetGUIObjectByName("picker[" + i + "]").blur();
+	}
+
+	renderButtons()
+	{
+		Engine.GetGUIObjectByName("hotkeyPickerAccept").enabled = !!this.combination;
+		Engine.GetGUIObjectByName("hotkeyPickerRepick").enabled = !!this.combination;
+	}
+}
Index: binaries/data/mods/public/gui/hotkeys/HotkeysPage.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/hotkeys/HotkeysPage.js
@@ -0,0 +1,190 @@
+class HotkeysPage
+{
+	constructor()
+	{
+		g_ScancodesMap = Engine.GetScancodeKeyNames();
+
+		Engine.GetGUIObjectByName("hotkeyList").onMouseLeftDoubleClickItem = () => {
+			let idx = Engine.GetGUIObjectByName("hotkeyList").selected;
+			new HotkeyPicker(
+				this.onHotkeyPicked.bind(this),
+				Engine.GetGUIObjectByName("hotkeyList").list_data[idx],
+				this.hotkeys[Engine.GetGUIObjectByName("hotkeyList").list_data[idx]]
+			);
+		};
+		Engine.GetGUIObjectByName("hotkeyFilter").onSelectionChange = () => this.setupHotkeyList();
+
+		Engine.GetGUIObjectByName("hotkeyTextFilter").onTextEdit = () => this.setupHotkeyList();
+
+		Engine.GetGUIObjectByName("hotkeyCancel").onPress = () => Engine.PopGuiPage();
+		Engine.GetGUIObjectByName("hotkeyReset").onPress = () => this.resetUserHotkeys();
+		Engine.GetGUIObjectByName("hotkeySave").onPress = () => {
+			this.saveUserHotkeys();
+		};
+
+		this.setupHotkeyData();
+		this.setupFilters();
+		this.setupHotkeyList();
+	}
+
+	setupFilters()
+	{
+		let dropdown = Engine.GetGUIObjectByName("hotkeyFilter");
+		let names = [];
+		for (let cat in this.categories)
+			names.push(this.categories[cat].label);
+		dropdown.list = [translate("All Hotkeys")].concat(names);
+		dropdown.list_data = [-1].concat(Object.keys(this.categories));
+		dropdown.selected = 0;
+	}
+
+	setupHotkeyList()
+	{
+		let hotkeyList = Engine.GetGUIObjectByName("hotkeyList");
+		hotkeyList.selected = -1;
+		let textFilter = Engine.GetGUIObjectByName("hotkeyTextFilter").caption;
+		let dropdown = Engine.GetGUIObjectByName("hotkeyFilter");
+		if (dropdown.selected && dropdown.selected !== 0)
+		{
+			let category = this.categories[dropdown.list_data[dropdown.selected]];
+			// This is inefficient but it seems fast enough.
+			let hotkeys = category.hotkeys.filter(x => translate(x[0]).indexOf(textFilter) !== -1);
+			hotkeyList.list_name = hotkeys.map(x => translate(x[0]));
+			hotkeyList.list_mapping = hotkeys.map(x => this.formatHotkeyCombinations(x[1]));
+			hotkeyList.list = hotkeys.map(() => 0);
+			hotkeyList.list_data = hotkeys.map(x => x[0]);
+		}
+		else
+		{
+			// TODO SM62+ : refactor using flat()
+			let flattened = [];
+			for (let cat in this.categories)
+				flattened = flattened.concat(this.categories[cat].hotkeys);
+			flattened = flattened.filter(x => translate(x[0]).indexOf(textFilter) !== -1);
+			hotkeyList.list_name = flattened.map(x => translate(x[0]));
+			hotkeyList.list_mapping = flattened.map(x => this.formatHotkeyCombinations(x[1]));
+			hotkeyList.list = flattened.map(() => 0);
+			hotkeyList.list_data = flattened.map(x => x[0]);
+		}
+	}
+
+	formatHotkeyCombinations(combinations)
+	{
+		return combinations.map(formatHotkeyCombination).join(", ");
+	}
+
+	formatHotkeyCombinationsScancode(combinations)
+	{
+		return combinations.map(formatHotkeyCombinationScancode).join(", ");
+	}
+
+	onHotkeyPicked(picker, success)
+	{
+		picker.close();
+		if (!success)
+			return;
+
+		// Remove empty combinations which the picker added.
+		picker.combinations = picker.combinations.filter(x => x.length);
+
+		this.hotkeys[picker.name] = picker.combinations;
+		// Have to find the correct line.
+		let panel = Engine.GetGUIObjectByName("hotkeyList");
+		for (let cat in this.categories)
+		{
+			let idx = this.categories[cat].hotkeys.findIndex(([name, _]) => name == picker.name);
+			if (idx === -1)
+				continue;
+			this.categories[cat].hotkeys[idx][1] = picker.combinations;
+		}
+
+		this.setupHotkeyList();
+	}
+
+	setupHotkeyData()
+	{
+		let hotkeydata = Engine.GetHotkeyMap();
+		this.hotkeys = hotkeydata;
+
+		let categories = {
+			"other": {
+				"label": translate("Other hotkeys"),
+				"hotkeys": []
+			}
+		};
+		let n_categories = 1;
+		for (let hotkeyName in this.hotkeys)
+		{
+			let category = "other";
+			let firstdot = hotkeyName.indexOf('.');
+			if (firstdot !== -1)
+				category = hotkeyName.substr(0, firstdot);
+			if (!(category in categories))
+			{
+				if (n_categories > 18)
+					category = "other";
+				categories[category] = {
+					"label": category,
+					"hotkeys": []
+				};
+			}
+			categories[category].hotkeys.push([hotkeyName, this.hotkeys[hotkeyName]]);
+		}
+		// Remove categories that are too small to deserve a tab.
+		for (let cat of Object.keys(categories))
+			if (categories[cat].hotkeys.length < 3)
+			{
+				categories.other.hotkeys = categories.other.hotkeys.concat(categories[cat].hotkeys);
+				delete categories[cat];
+			}
+		for (let cat in categories)
+			categories[cat].hotkeys = categories[cat].hotkeys.sort();
+
+		this.categories = categories;
+	}
+
+	resetUserHotkeys()
+	{
+		messageBox(
+			400, 200,
+			translate("Reset all hotkeys to default values?"),
+			translate("Confirmation"),
+			[translate("No"), translate("Yes")],
+			[
+				() => {},
+				() => {
+					for (let cat in this.categories)
+						this.categories[cat].hotkeys.forEach(([name, _]) => {
+							Engine.ConfigDB_RemoveValue("user", "hotkey." + name);
+						});
+					Engine.ConfigDB_WriteFile("user", "config/user.cfg");
+					Engine.ReloadHotkeys();
+					this.setupHotkeyData();
+					this.setupHotkeyList();
+				}
+			]);
+	}
+
+	saveUserHotkeys()
+	{
+		for (let cat in this.categories)
+		{
+			this.categories[cat].hotkeys.forEach(([name, mapping]) => {
+				let keymap = mapping.map(comb => comb.sort(hotkeySort).join("+"));
+				Engine.ConfigDB_RemoveValue("user", "hotkey." + name);
+				let val = Engine.ConfigDB_GetValue("user", "hotkey." + name);
+				// val is a string here so I join above.
+				if (keymap.join(", ") !== val)
+					Engine.ConfigDB_CreateValues("user", "hotkey." + name, keymap);
+			});
+		}
+		Engine.ConfigDB_WriteFile("user", "config/user.cfg");
+		Engine.ReloadHotkeys();
+	}
+}
+
+
+function init(data)
+{
+	let hotkeyPage = new HotkeysPage(data);
+}
Index: binaries/data/mods/public/gui/hotkeys/hotkeys.xml
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/hotkeys/hotkeys.xml
@@ -0,0 +1,103 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<objects>
+
+	<script directory="gui/common/"/>
+	<script directory="gui/hotkeys/"/>
+
+	<object type="image" sprite="BackgroundTranslucent"/>
+
+	<!-- Hotkey List Window -->
+	<object name="hotkeys" type="image" style="ModernDialog" size="50%-350 50%-344 50%+350 50%+344">
+
+		<object style="ModernLabelText" type="text" size="50%-128 -16 50%+128 16">
+			<translatableAttribute id="caption">Hotkeys</translatableAttribute>
+		</object>
+
+		<object style="ModernLabelText" type="text" size="32 32 132 58" text_align="left">
+			<translatableAttribute id="caption">Category:</translatableAttribute>
+		</object>
+
+		<object name="hotkeyFilter" type="dropdown" style="ModernDropDown" size="132 32 300 58"/>
+
+		<object style="ModernLabelText" type="text" size="100%-300 32 100%-200 58" text_align="left">
+			<translatableAttribute id="caption">Filter:</translatableAttribute>
+		</object>
+
+		<object name="hotkeyTextFilter" type="input" style="ModernInput" size="100%-200 32 100%-32 58"/>
+
+		<object name="hotkeyList"
+				style="ModernSortedList"
+				selected_column="name"
+				selected_column_order="-1"
+				sortable="false"
+				size="32 70 100%-32 100%-70"
+				type="olist"
+				auto_scroll="true"
+			>
+			<column id="name" color="255 255 255" width="60%">
+				<translatableAttribute id="heading" context="hotkey list">Name</translatableAttribute>
+			</column>
+
+			<column id="mapping" color="255 255 255" width="40%">
+				<translatableAttribute id="heading" context="hotkey list">Mapping</translatableAttribute>
+			</column>
+		</object>
+
+		<object name="hotkeyCancel" type="button" size="8 100%-60 98 100%-32" style="ModernButtonRed" hotkey="cancel">
+			<translatableAttribute id="caption">Cancel</translatableAttribute>
+		</object>
+
+		<object name="hotkeyReset" type="button" size="100%-282 100%-60 100%-102 100%-32" style="ModernButtonRed">
+			<translatableAttribute id="caption">Reset All to Defaults</translatableAttribute>
+		</object>
+
+		<object name="hotkeySave" type="button" size="100%-98 100%-60 100%-8 100%-32" style="ModernButtonRed">
+			<translatableAttribute id="caption">Save</translatableAttribute>
+		</object>
+	</object>
+
+
+	<!-- Hotkey Picker popup -->
+
+	<object name="hotkeyPicker" type="image" sprite="BackgroundTranslucent" hidden="true" z="100">
+		<object type="image"
+			style="ModernDialog"
+			size="50%-300 50%-200 50%+300 50%+200"
+		>
+			<object name="hotkeyPickerTitle" style="ModernLabelText" type="text" size="50%-128 -16 50%+128 16">
+				<translatableAttribute id="caption">Hotkey</translatableAttribute>
+			</object>
+
+			<object name="hotkeyPickerDesc"  style="ModernLabelText" type="text" size="8 20 100%-8 66">
+				<translatableAttribute id="caption"></translatableAttribute>
+			</object>
+
+			<repeat count="4" var="n">
+				<object name="combination[n]" size="8 40 100%-8 70" hidden="false">
+					<object name="combNb[n]" style="ModernLabelText" type="text" size="0 0 20 100%" text_align="left"/>
+					<object name="picker[n]" type="hotkeypicker"/>
+					<object name="combMapping[n]" style="ModernInput" type="input" readonly="true" size="30 2 60% 100%-2"/>
+					<!-- Used to detect clicks on the input. -->
+					<object name="combMappingBtn[n]" type="button" size="30 2 60% 100%-2"/>
+					<object name="deleteComb[n]" type="button" size="60%+10 2 60%+36 100%-2"
+						sprite="stretched:session/icons/kill.png"
+						/>
+					<object name="conflicts[n]"  style="ModernLabelText" type="text" size="60%+40 2 100%-8 100%-2" clip="false" text_valign="center"/>
+				</object>
+			</repeat>
+
+			<object name="hotkeyPickerCancel" type="button" size="8 100%-60 98 100%-32" style="ModernButtonRed" hotkey="cancel">
+				<translatableAttribute id="caption">Cancel</translatableAttribute>
+			</object>
+
+			<object name="hotkeyPickerReset" type="button" size="100%-192 100%-60 100%-102 100%-32" style="ModernButtonRed">
+				<translatableAttribute id="caption">Reset</translatableAttribute>
+			</object>
+
+			<object name="hotkeyPickerAccept" type="button" size="100%-98 100%-60 100%-8 100%-32" style="ModernButtonRed">
+				<translatableAttribute id="caption">Accept</translatableAttribute>
+			</object>
+		</object>
+	</object>
+</objects>
Index: binaries/data/mods/public/gui/hotkeys/page_hotkeys.xml
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/hotkeys/page_hotkeys.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<page>
+	<include>common/modern/setup.xml</include>
+	<include>common/modern/styles.xml</include>
+	<include>common/modern/sprites.xml</include>
+
+	<include>common/setup.xml</include>
+	<include>common/sprites.xml</include>
+	<include>common/styles.xml</include>
+
+	<include>common/global.xml</include>
+
+	<include>hotkeys/hotkeys.xml</include>
+</page>
Index: binaries/data/mods/public/gui/hotkeys/utils.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/hotkeys/utils.js
@@ -0,0 +1,21 @@
+/**
+ * Holds a map of scancode name -> user keyboard name
+ */
+var g_ScancodesMap = {};
+
+function hotkeySort(a, b)
+{
+	const specialKeys = ["Shift", "Alt", "Ctrl", "Super"];
+	// Quick hack to put those first.
+	if (specialKeys.indexOf(a) !== -1)
+		a = ' ' + a;
+	if (specialKeys.indexOf(b) !== -1)
+		b = ' ' + b;
+	return a.localeCompare(b, Engine.GetCurrentLocale().substr(0,2), { "numeric": true });
+}
+
+function formatHotkeyCombination(comb)
+{
+	let str = comb.sort(hotkeySort).map(hk => g_ScancodesMap[hk]).join("+");
+	return str.replace('\\', '\\\\').replace('[', '\\[');
+}
Index: binaries/data/mods/public/gui/pregame/MainMenuItems.js
===================================================================
--- binaries/data/mods/public/gui/pregame/MainMenuItems.js
+++ binaries/data/mods/public/gui/pregame/MainMenuItems.js
@@ -148,6 +148,13 @@
 						fireConfigChangeHandlers);
 				}
 			},
+			{
+				"caption": translate("Hotkeys"),
+				"tooltip": translate("Adjust hotkeys."),
+				"onPress": () => {
+					Engine.PushGuiPage("hotkeys/page_hotkeys.xml");
+				}
+			},
 			{
 				"caption": translate("Language"),
 				"tooltip": translate("Choose the language of the game."),
Index: binaries/data/mods/public/gui/session/MenuButtons.js
===================================================================
--- binaries/data/mods/public/gui/session/MenuButtons.js
+++ binaries/data/mods/public/gui/session/MenuButtons.js
@@ -174,6 +174,27 @@
 	}
 };
 
+MenuButtons.prototype.Hotkeys = class
+{
+	constructor(button, pauseControl)
+	{
+		this.button = button;
+		this.button.caption = translate("Hotkeys");
+		this.pauseControl = pauseControl;
+	}
+
+	onPress()
+	{
+		closeOpenDialogs();
+		this.pauseControl.implicitPause();
+
+		Engine.PushGuiPage(
+			"hotkeys/page_hotkeys.xml",
+			{},
+			() => { resumeGame(); });
+	}
+};
+
 MenuButtons.prototype.Pause = class
 {
 	constructor(button, pauseControl, playerViewControl)
Index: source/gui/CGUI.cpp
===================================================================
--- source/gui/CGUI.cpp
+++ source/gui/CGUI.cpp
@@ -255,16 +255,12 @@
 	// Handle keys for input boxes
 	if (GetFocusedObject())
 	{
-		if ((ev->ev.type == SDL_KEYDOWN &&
-		     ev->ev.key.keysym.sym != SDLK_ESCAPE &&
-		     !g_keys[SDLK_LCTRL] && !g_keys[SDLK_RCTRL] &&
-		     !g_keys[SDLK_LALT] && !g_keys[SDLK_RALT]) ||
-		    ev->ev.type == SDL_HOTKEYDOWN ||
-		    ev->ev.type == SDL_TEXTINPUT ||
-		    ev->ev.type == SDL_TEXTEDITING)
-		{
+		if (ev->ev.type == SDL_MOUSEBUTTONUP || ev->ev.type == SDL_MOUSEBUTTONDOWN ||
+			ev->ev.type == SDL_MOUSEWHEEL ||
+			ev->ev.type == SDL_KEYUP || ev->ev.type == SDL_KEYDOWN ||
+			ev->ev.type == SDL_HOTKEYUP || ev->ev.type == SDL_HOTKEYDOWN ||
+			ev->ev.type == SDL_TEXTINPUT || ev->ev.type == SDL_TEXTEDITING)
 			ret = GetFocusedObject()->ManuallyHandleEvent(ev);
-		}
 		// else will return IN_PASS because we never used the button.
 	}
 
@@ -273,6 +269,7 @@
 
 void CGUI::TickObjects()
 {
+	m_BaseObject.RecurseObject(&IGUIObject::IsHiddenOrGhost, &IGUIObject::Tick);
 	SendEventToAll(EventNameTick);
 	m_Tooltip.Update(FindObjectUnderMouse(), m_MousePos, *this);
 }
Index: source/gui/GUIObjectTypes.h
===================================================================
--- source/gui/GUIObjectTypes.h
+++ source/gui/GUIObjectTypes.h
@@ -21,6 +21,7 @@
 #include "gui/ObjectTypes/CChart.h"
 #include "gui/ObjectTypes/CCheckBox.h"
 #include "gui/ObjectTypes/CDropDown.h"
+#include "gui/ObjectTypes/CHotkeyPicker.h"
 #include "gui/ObjectTypes/CImage.h"
 #include "gui/ObjectTypes/CInput.h"
 #include "gui/ObjectTypes/CList.h"
@@ -39,6 +40,7 @@
 	AddObjectType("checkbox", &CCheckBox::ConstructObject);
 	AddObjectType("dropdown", &CDropDown::ConstructObject);
 	AddObjectType("empty", &CGUIDummyObject::ConstructObject);
+	AddObjectType("hotkeypicker", &CHotkeyPicker::ConstructObject);
 	AddObjectType("image", &CImage::ConstructObject);
 	AddObjectType("input", &CInput::ConstructObject);
 	AddObjectType("list", &CList::ConstructObject);
Index: source/gui/ObjectBases/IGUIObject.h
===================================================================
--- source/gui/ObjectBases/IGUIObject.h
+++ source/gui/ObjectBases/IGUIObject.h
@@ -255,6 +255,12 @@
 	//@{
 
 public:
+
+	/**
+	 * Called on every GUI tick unless the object or one of its parent is hidden/ghost.
+	 */
+	virtual void Tick() {};
+
 	/**
      * This function is called with different messages
 	 * for instance when the mouse enters the object.
Index: source/gui/ObjectTypes/CHotkeyPicker.h
===================================================================
--- /dev/null
+++ source/gui/ObjectTypes/CHotkeyPicker.h
@@ -0,0 +1,75 @@
+/* Copyright (C) 2020 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_CHOTKEYPICKER
+#define INCLUDED_CHOTKEYPICKER
+
+#include "lib/external_libraries/libsdl.h"
+
+class ScriptInterface;
+
+/**
+ * When in focus, returns all currently pressed keys.
+ * After a set time without changes, it will trigger a "combination" event.
+ *
+ * Used to create new hotkey combinations in-game. Mostly custom.
+ * This object does not draw anything.
+ */
+class CHotkeyPicker : public IGUIObject
+{
+	GUI_OBJECT(CHotkeyPicker)
+
+	friend class ScriptInterface;
+public:
+	CHotkeyPicker(CGUI& pGUI);
+	virtual ~CHotkeyPicker();
+
+	// Do nothing.
+	virtual void Draw() {};
+
+	// Checks if the timer has passed and we need to fire a "combination" event.
+	virtual void Tick();
+
+	// React to blur/focus.
+	virtual void HandleMessage(SGUIMessage& Message);
+
+	// Handle events manually: this is our sole purpose.
+	virtual InReaction ManuallyHandleEvent(const SDL_Event_* ev);
+protected:
+	// Fire an event with m_KeysPressed as argument.
+	void FireEvent(const CStr& event);
+
+	// Time without changes until a "combination" event is sent.
+	float m_TimeToCombination;
+	// Time of the last registered key change.
+	double m_LastKeyChange;
+
+	// Keep track of which keys we are pressing, and precompute their name for JS code.
+	struct Key
+	{
+		// The scancode is used for fast comparisons.
+		SDL_Scancode code;
+		// This is the name ultimately stored in the config file.
+		std::string scancodeName;
+	};
+	std::vector<Key> m_KeysPressed;
+
+	static const CStr EventNameCombination;
+	static const CStr EventNameKeyChange;
+};
+
+#endif // INCLUDED_CHOTKEYPICKER
Index: source/gui/ObjectTypes/CHotkeyPicker.cpp
===================================================================
--- /dev/null
+++ source/gui/ObjectTypes/CHotkeyPicker.cpp
@@ -0,0 +1,186 @@
+/* Copyright (C) 2020 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "CHotkeyPicker.h"
+
+#include "lib/timer.h"
+#include "ps/Hotkey.h"
+#include "ps/KeyName.h"
+#include "scriptinterface/ScriptConversions.h"
+
+const CStr CHotkeyPicker::EventNameCombination = "Combination";
+const CStr CHotkeyPicker::EventNameKeyChange = "KeyChange";
+
+// Don't send the scancode, JS doesn't care.
+template<> void ScriptInterface::ToJSVal(JSContext *cx, JS::MutableHandleValue ret, const CHotkeyPicker::Key& val)
+{
+	ScriptInterface::ToJSVal(cx, ret, val.scancodeName);
+}
+
+// Unused, but JSVAL_VECTOR requires it.
+template<> bool ScriptInterface::FromJSVal(JSContext*, const JS::HandleValue, CHotkeyPicker::Key&)
+{
+	LOGWARNING("FromJSVal<CHotkeyPicker>: Not implemented");
+	return false;
+}
+
+JSVAL_VECTOR(CHotkeyPicker::Key);
+
+CHotkeyPicker::CHotkeyPicker(CGUI& pGUI) : IGUIObject(pGUI), m_TimeToCombination(1.f)
+{
+	RegisterSetting("time_to_combination", m_TimeToCombination);
+	// 8 keys at the same time is probably more than we'll ever need.
+	m_KeysPressed.reserve(8);
+}
+
+CHotkeyPicker::~CHotkeyPicker()
+{
+}
+
+void CHotkeyPicker::FireEvent(const CStr& event)
+{
+	JSContext* cx = m_pGUI.GetScriptInterface()->GetContext();
+	JSAutoRequest rq(cx);
+
+	JS::AutoValueArray<1> args(cx);
+	JS::RootedValue keys(cx);
+	m_pGUI.GetScriptInterface()->ToJSVal(cx, &keys, m_KeysPressed);
+	args[0].set(keys);
+	ScriptEvent(event, args);
+}
+
+void CHotkeyPicker::Tick()
+{
+	if (m_KeysPressed.size() == 0)
+		return;
+
+	double time = timer_Time();
+	if (time - m_LastKeyChange < m_TimeToCombination)
+		return;
+
+	FireEvent(EventNameCombination);
+
+	return;
+}
+
+void CHotkeyPicker::HandleMessage(SGUIMessage& Message)
+{
+	IGUIObject::HandleMessage(Message);
+	switch (Message.type)
+	{
+	case GUIM_GOT_FOCUS:
+	case GUIM_LOST_FOCUS:
+	{
+		m_KeysPressed.clear();
+		m_LastKeyChange = timer_Time();
+		break;
+	}
+	default:
+		break;
+	}
+}
+
+InReaction CHotkeyPicker::ManuallyHandleEvent(const SDL_Event_* ev)
+{
+	switch (ev->ev.type)
+	{
+	// Handle the same mouse events that hotkeys handle
+	case SDL_MOUSEBUTTONUP:
+	case SDL_MOUSEWHEEL:
+	{
+		SDL_Scancode scancode;
+
+		if (ev->ev.type != SDL_MOUSEWHEEL)
+		{
+			// Wait a little bit -> this gets triggered when clicking on a button,
+			// but after the button click is processed, thus immediately triggering...
+			if (timer_Time()-m_LastKeyChange < 0.2)
+				return IN_HANDLED;
+			// This is from hotkeyHandler - not sure what it does in all honesty.
+			if(ev->ev.button.button >= SDL_BUTTON_X1)
+				scancode = static_cast<SDL_Scancode>(MOUSE_BASE + (int)ev->ev.button.button + 2);
+			else
+				scancode = static_cast<SDL_Scancode>(MOUSE_BASE + (int)ev->ev.button.button);
+		}
+		else
+		{
+			if (ev->ev.wheel.y > 0)
+				scancode = static_cast<SDL_Scancode>(MOUSE_WHEELUP);
+			else if (ev->ev.wheel.y < 0)
+				scancode = static_cast<SDL_Scancode>(MOUSE_WHEELDOWN);
+			else if (ev->ev.wheel.x > 0)
+				scancode = static_cast<SDL_Scancode>(MOUSE_X2);
+			else if (ev->ev.wheel.x < 0)
+				scancode = static_cast<SDL_Scancode>(MOUSE_X1);
+			else
+				return IN_HANDLED;
+		}
+		// Don't handle keys and mouse together
+		m_KeysPressed.clear();
+		m_KeysPressed.emplace_back(Key{scancode, FindScancodeName(scancode)});
+		// For mouse events, assume we immediately want to return.
+		FireEvent(EventNameCombination);
+
+		return IN_HANDLED;
+	}
+	case SDL_KEYDOWN:
+	case SDL_KEYUP:
+	{
+		SDL_Scancode scancode = ev->ev.key.keysym.scancode;
+
+		if (scancode == SDL_SCANCODE_LSHIFT || scancode == SDL_SCANCODE_RSHIFT)
+			scancode = static_cast<SDL_Scancode>(UNIFIED_SHIFT);
+		else if (scancode == SDL_SCANCODE_LCTRL || scancode == SDL_SCANCODE_RCTRL)
+			scancode = static_cast<SDL_Scancode>(UNIFIED_CTRL);
+		else if (scancode == SDL_SCANCODE_LALT || scancode == SDL_SCANCODE_RALT)
+			scancode = static_cast<SDL_Scancode>(UNIFIED_ALT);
+		else if (scancode == SDL_SCANCODE_LGUI || scancode == SDL_SCANCODE_RGUI)
+			scancode = static_cast<SDL_Scancode>(UNIFIED_SUPER);
+
+		if (ev->ev.type == SDL_KEYDOWN)
+		{
+			std::vector<Key>::const_iterator it = \
+				std::find_if(m_KeysPressed.begin(), m_KeysPressed.end(), [&scancode](Key& k) { return k.code == scancode; });
+			// Can happen if multiple keys are mapped the same.
+			if (it != m_KeysPressed.end())
+				return IN_HANDLED;
+			m_KeysPressed.emplace_back(Key{scancode, FindScancodeName(scancode)});
+		}
+		else
+		{
+			std::vector<Key>::const_iterator it = \
+				std::find_if(m_KeysPressed.begin(), m_KeysPressed.end(), [&scancode](Key& k) { return k.code == scancode; });
+			// Might happen if a key was down before this object is created.
+			if (it == m_KeysPressed.end())
+				return IN_HANDLED;
+			m_KeysPressed.erase(it);
+		}
+
+		FireEvent(EventNameKeyChange);
+
+		// Register after-JS in case this takes a while (probably not but it doesn't hurt).
+		m_LastKeyChange = timer_Time();
+		return IN_HANDLED;
+	}
+	default:
+	{
+		return IN_PASS;
+	}
+	}
+}
Index: source/gui/Scripting/ScriptFunctions.cpp
===================================================================
--- source/gui/Scripting/ScriptFunctions.cpp
+++ source/gui/Scripting/ScriptFunctions.cpp
@@ -30,6 +30,7 @@
 #include "ps/scripting/JSInterface_Console.h"
 #include "ps/scripting/JSInterface_Debug.h"
 #include "ps/scripting/JSInterface_Game.h"
+#include "ps/scripting/JSInterface_Hotkey.h"
 #include "ps/scripting/JSInterface_Main.h"
 #include "ps/scripting/JSInterface_Mod.h"
 #include "ps/scripting/JSInterface_ModIo.h"
@@ -59,6 +60,7 @@
 	JSI_GUIManager::RegisterScriptFunctions(scriptInterface);
 	JSI_Game::RegisterScriptFunctions(scriptInterface);
 	JSI_GameView::RegisterScriptFunctions(scriptInterface);
+	JSI_Hotkey::RegisterScriptFunctions(scriptInterface);
 	JSI_L10n::RegisterScriptFunctions(scriptInterface);
 	JSI_Lobby::RegisterScriptFunctions(scriptInterface);
 	JSI_Main::RegisterScriptFunctions(scriptInterface);
Index: source/ps/ConfigDB.h
===================================================================
--- source/ps/ConfigDB.h
+++ source/ps/ConfigDB.h
@@ -110,6 +110,8 @@
 
 	void SetValueBool(EConfigNamespace ns, const CStr& name, const bool value);
 
+	void SetValueList(EConfigNamespace ns, const CStr& name, std::vector<CStr> values);
+
 	/**
 	 * Remove a config value in the specified namespace.
 	 */
Index: source/ps/ConfigDB.cpp
===================================================================
--- source/ps/ConfigDB.cpp
+++ source/ps/ConfigDB.cpp
@@ -210,6 +210,18 @@
 	SetValueString(ns, name, valueString);
 }
 
+void CConfigDB::SetValueList(EConfigNamespace ns, const CStr& name, std::vector<CStr> values)
+{
+	CHECK_NS(;);
+
+	std::lock_guard<std::recursive_mutex> s(cfgdb_mutex);
+	TConfigMap::iterator it = m_Map[ns].find(name);
+	if (it == m_Map[ns].end())
+		it = m_Map[ns].insert(m_Map[ns].begin(), make_pair(name, CConfigValueSet(1)));
+
+	it->second = values;
+}
+
 void CConfigDB::RemoveValue(EConfigNamespace ns, const CStr& name)
 {
 	CHECK_NS(;);
Index: source/ps/Hotkey.h
===================================================================
--- source/ps/Hotkey.h
+++ source/ps/Hotkey.h
@@ -33,15 +33,43 @@
 
 #include "CStr.h"
 #include "lib/input.h"
-#include "lib/external_libraries/libsdl.h"	// see note below
 
-// note: we need the real SDL header - it defines SDL_USEREVENT, which is
-// required for our HOTKEY event type definition. this is OK since
-// hotkey.h is not included from any headers.
+// SDL_Scancode is an enum, we'll use an explicit int to avoid including SDL in this header.
+using SDL_Scancode_ = int;
 
-const uint SDL_HOTKEYPRESS = SDL_USEREVENT;
-const uint SDL_HOTKEYDOWN = SDL_USEREVENT + 1;
-const uint SDL_HOTKEYUP = SDL_USEREVENT + 2;
+// 0x8000 is SDL_USEREVENT, this is static_asserted in Hotkey.cpp
+// We do this to avoid including SDL in this header.
+const uint SDL_USEREVENT_ = 0x8000;
+const uint SDL_HOTKEYPRESS = SDL_USEREVENT_;
+const uint SDL_HOTKEYDOWN = SDL_USEREVENT_ + 1;
+const uint SDL_HOTKEYUP = SDL_USEREVENT_ + 2;
+
+struct SKey
+{
+	SDL_Scancode_ code; // scancode or MOUSE_ or UNIFIED_ value
+	bool negated; // whether the key must be pressed (false) or unpressed (true)
+
+	bool operator<(const SKey& o) const { return code < o.code && negated < o.negated; }
+	bool operator==(const SKey& o) const { return code == o.code && negated == o.negated; }
+};
+
+// Hotkey data associated with an externally-specified 'primary' keycode
+struct SHotkeyMapping
+{
+	CStr name; // name of the hotkey
+	bool negated; // whether the primary key must be pressed (false) or unpressed (true)
+	std::vector<SKey> requires; // list of non-primary keys that must also be active
+};
+
+typedef std::vector<SHotkeyMapping> KeyMapping;
+
+// A mapping of scancodes onto the hotkeys that are associated with that key.
+// (A hotkey triggered by a combination of multiple keys will be in this map
+// multiple times.)
+extern std::map<SDL_Scancode_, KeyMapping> g_HotkeyMap;
+
+// The current pressed status of hotkeys
+extern std::map<std::string, bool> g_HotkeyStatus;
 
 extern void LoadHotkeys();
 extern void UnloadHotkeys();
Index: source/ps/Hotkey.cpp
===================================================================
--- source/ps/Hotkey.cpp
+++ source/ps/Hotkey.cpp
@@ -20,6 +20,7 @@
 
 #include <boost/tokenizer.hpp>
 
+#include "lib/external_libraries/libsdl.h"
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
@@ -29,30 +30,12 @@
 
 static bool unified[UNIFIED_LAST - UNIFIED_SHIFT];
 
-struct SKey
-{
-	SDL_Keycode code; // keycode or MOUSE_ or UNIFIED_ value
-	bool negated; // whether the key must be pressed (false) or unpressed (true)
-};
-
-// Hotkey data associated with an externally-specified 'primary' keycode
-struct SHotkeyMapping
-{
-	CStr name; // name of the hotkey
-	bool negated; // whether the primary key must be pressed (false) or unpressed (true)
-	std::vector<SKey> requires; // list of non-primary keys that must also be active
-};
-
-typedef std::vector<SHotkeyMapping> KeyMapping;
-
-// A mapping of keycodes onto the hotkeys that are associated with that key.
-// (A hotkey triggered by a combination of multiple keys will be in this map
-// multiple times.)
-static std::map<int, KeyMapping> g_HotkeyMap;
-
-// The current pressed status of hotkeys
+std::map<int, KeyMapping> g_HotkeyMap;
 std::map<std::string, bool> g_HotkeyStatus;
 
+static_assert(std::is_integral<std::underlying_type<SDL_Scancode>::type>::value, "SDL_Scancode is not an integral enum.");
+static_assert(SDL_USEREVENT_ == SDL_USEREVENT, "SDL_USEREVENT_ is not the same type as the real SDL_USEREVENT");
+
 // Look up each key binding in the config file and set the mappings for
 // all key combinations that trigger it.
 static void LoadConfigBindings()
@@ -73,17 +56,16 @@
 			tokenizer tok(hotkey, sep);
 			for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it)
 			{
+				CStrW t = hotkey.FromUTF8();
 				// Attempt decode as key name
-				int mapping = FindKeyCode(*it);
-				if (!mapping)
-					mapping = SDL_GetKeyFromName(it->c_str());
-				if (!mapping)
+				SDL_Scancode scancode = FindScancode(it->c_str());
+				if (!scancode)
 				{
 					LOGWARNING("Hotkey mapping used invalid key '%s'", hotkey.c_str());
 					continue;
 				}
 
-				SKey key = { (SDL_Keycode)mapping, false };
+				SKey key = { scancode, false };
 				keyCombination.push_back(key);
 			}
 
@@ -107,8 +89,6 @@
 
 void LoadHotkeys()
 {
-	InitKeyNameMap();
-
 	LoadConfigBindings();
 
 	// Set up the state of the hotkeys given no key is down.
@@ -146,7 +126,7 @@
 	else if ((int)key.code < MOUSE_LAST && (int)key.code > MOUSE_BASE && g_mouse_buttons[key.code - MOUSE_BASE] == key.negated)
 		return false;
 	// Modifier keycodes are between the normal keys and the mouse 'keys'
-	else if ((int)key.code < UNIFIED_LAST && (int)key.code > SDL_SCANCODE_TO_KEYCODE(SDL_NUM_SCANCODES) && unified[key.code - UNIFIED_SHIFT] == key.negated)
+	else if ((int)key.code < UNIFIED_LAST && (int)key.code > SDL_NUM_SCANCODES && unified[key.code - UNIFIED_SHIFT] == key.negated)
 		return false;
 	else
 		return true;
@@ -163,13 +143,13 @@
 
 InReaction HotkeyInputHandler(const SDL_Event_* ev)
 {
-	int keycode = 0;
+	int scancode = SDL_SCANCODE_UNKNOWN;
 
 	switch(ev->ev.type)
 	{
 	case SDL_KEYDOWN:
 	case SDL_KEYUP:
-		keycode = (int)ev->ev.key.keysym.sym;
+		scancode = ev->ev.key.keysym.scancode;
 		break;
 
 	case SDL_MOUSEBUTTONDOWN:
@@ -177,30 +157,30 @@
 		// Mousewheel events are no longer buttons, but we want to maintain the order
 		// expected by g_mouse_buttons for compatibility
 		if (ev->ev.button.button >= SDL_BUTTON_X1)
-			keycode = MOUSE_BASE + (int)ev->ev.button.button + 2;
+			scancode = MOUSE_BASE + (int)ev->ev.button.button + 2;
 		else
-		keycode = MOUSE_BASE + (int)ev->ev.button.button;
+			scancode = MOUSE_BASE + (int)ev->ev.button.button;
 		break;
 
 	case SDL_MOUSEWHEEL:
 		if (ev->ev.wheel.y > 0)
 		{
-			keycode = MOUSE_WHEELUP;
+			scancode = MOUSE_WHEELUP;
 			break;
 		}
 		else if (ev->ev.wheel.y < 0)
 		{
-			keycode = MOUSE_WHEELDOWN;
+			scancode = MOUSE_WHEELDOWN;
 			break;
 		}
 		else if (ev->ev.wheel.x > 0)
 		{
-			keycode = MOUSE_X2;
+			scancode = MOUSE_X2;
 			break;
 		}
 		else if (ev->ev.wheel.x < 0)
 		{
-			keycode = MOUSE_X1;
+			scancode = MOUSE_X1;
 			break;
 		}
 		return IN_PASS;
@@ -219,33 +199,33 @@
 	if (phantom.ev.type == SDL_KEYDOWN)
 		phantom.ev.key.repeat = ev->ev.type == SDL_KEYDOWN ? ev->ev.key.repeat : 0;
 
-	if ((keycode == SDLK_LSHIFT) || (keycode == SDLK_RSHIFT))
+	if (scancode == SDL_SCANCODE_LSHIFT || scancode == SDL_SCANCODE_RSHIFT)
 	{
-		phantom.ev.key.keysym.sym = (SDL_Keycode)UNIFIED_SHIFT;
+		phantom.ev.key.keysym.scancode = static_cast<SDL_Scancode>(UNIFIED_SHIFT);
 		unified[0] = (phantom.ev.type == SDL_KEYDOWN);
 		HotkeyInputHandler(&phantom);
 	}
-	else if ((keycode == SDLK_LCTRL) || (keycode == SDLK_RCTRL))
+	else if (scancode == SDL_SCANCODE_LCTRL || scancode == SDL_SCANCODE_RCTRL)
 	{
-		phantom.ev.key.keysym.sym = (SDL_Keycode)UNIFIED_CTRL;
+		phantom.ev.key.keysym.scancode = static_cast<SDL_Scancode>(UNIFIED_CTRL);
 		unified[1] = (phantom.ev.type == SDL_KEYDOWN);
 		HotkeyInputHandler(&phantom);
 	}
-	else if ((keycode == SDLK_LALT) || (keycode == SDLK_RALT))
+	else if (scancode == SDL_SCANCODE_LALT || scancode == SDL_SCANCODE_RALT)
 	{
-		phantom.ev.key.keysym.sym = (SDL_Keycode)UNIFIED_ALT;
+		phantom.ev.key.keysym.scancode = static_cast<SDL_Scancode>(UNIFIED_ALT);
 		unified[2] = (phantom.ev.type == SDL_KEYDOWN);
 		HotkeyInputHandler(&phantom);
 	}
-	else if ((keycode == SDLK_LGUI) || (keycode == SDLK_RGUI))
+	else if (scancode == SDL_SCANCODE_LGUI || scancode == SDL_SCANCODE_RGUI)
 	{
-		phantom.ev.key.keysym.sym = (SDL_Keycode)UNIFIED_SUPER;
+		phantom.ev.key.keysym.scancode = static_cast<SDL_Scancode>(UNIFIED_SUPER);
 		unified[3] = (phantom.ev.type == SDL_KEYDOWN);
 		HotkeyInputHandler(&phantom);
 	}
 
 	// Check whether we have any hotkeys registered for this particular keycode
-	if (g_HotkeyMap.find(keycode) == g_HotkeyMap.end())
+	if (g_HotkeyMap.find(scancode) == g_HotkeyMap.end())
 		return (IN_PASS);
 
 	// Inhibit the dispatch of hotkey events caused by real keys (not fake mouse button
@@ -253,7 +233,7 @@
 
 	bool consoleCapture = false;
 
-	if (g_Console && g_Console->IsActive() && keycode < SDL_SCANCODE_TO_KEYCODE(SDL_NUM_SCANCODES))
+	if (g_Console && g_Console->IsActive() && scancode < SDL_NUM_SCANCODES)
 		consoleCapture = true;
 
 	// Here's an interesting bit:
@@ -273,7 +253,7 @@
 	std::vector<const char*> closestMapNames;
 	size_t closestMapMatch = 0;
 
-	for (const SHotkeyMapping& hotkey : g_HotkeyMap[keycode])
+	for (const SHotkeyMapping& hotkey : g_HotkeyMap[scancode])
 	{
 		// If a key has been pressed, and this event triggers on its release, skip it.
 		// Similarly, if the key's been released and the event triggers on a keypress, skip it.
@@ -329,7 +309,7 @@
 
 	// -- KEYUP SECTION --
 
-	for (const SHotkeyMapping& hotkey : g_HotkeyMap[keycode])
+	for (const SHotkeyMapping& hotkey : g_HotkeyMap[scancode])
 	{
 		// If it's a keydown event, won't cause HotKeyUps in anything that doesn't
 		// use this key negated => skip them
Index: source/ps/KeyName.h
===================================================================
--- source/ps/KeyName.h
+++ source/ps/KeyName.h
@@ -23,14 +23,16 @@
 
 class CStr8;
 
-extern void InitKeyNameMap();
-extern CStr8 FindKeyName(int keycode);
-extern int FindKeyCode(const CStr8& keyname);
+extern SDL_Scancode FindScancode(const CStr& keyname);
+// Map a scancode to a locale-independent scancode name.
+extern CStr8 FindScancodeName(SDL_Scancode scancode);
+// Map a scancode to a locale-dependent key name (to show the user).
+extern CStr8 FindKeyName(SDL_Scancode scancode);
 
 enum {
 	// Start sequential IDs in the right place
-	// Pick a code which is greater than any keycodes used by SDL itself
-	EXTRA_KEYS_BASE = SDL_SCANCODE_TO_KEYCODE(SDL_NUM_SCANCODES),
+	// Pick a code which is greater than any scancodes used by SDL itself
+	EXTRA_KEYS_BASE = SDL_NUM_SCANCODES,
 	// 'Keycodes' for the unified modifier keys
 	UNIFIED_SHIFT,
 	UNIFIED_CTRL,
Index: source/ps/KeyName.cpp
===================================================================
--- source/ps/KeyName.cpp
+++ source/ps/KeyName.cpp
@@ -24,215 +24,111 @@
 #include "lib/external_libraries/libsdl.h"
 #include "ps/CStr.h"
 
-#include <map>
-
-static std::map<CStr,int> keymap;
-
-struct SKeycodeMapping
+#include <unordered_map>
+
+// Some scancodes for names that SDL doesn't recognise.
+// Those are tested first so they override SDL defaults (useful for UNIFIED keys).
+static const std::unordered_map<std::string, int> scancodemap {{
+	{ "DownArrow", SDL_SCANCODE_DOWN },
+	{ "UpArrow", SDL_SCANCODE_UP },
+	{ "LeftArrow", SDL_SCANCODE_LEFT },
+	{ "RightArrow", SDL_SCANCODE_RIGHT },
+
+	{ "Plus", SDL_SCANCODE_EQUALS },
+	{ "Equals", SDL_SCANCODE_EQUALS },
+	{ "Minus", SDL_SCANCODE_MINUS },
+	{ "NumPlus", SDL_SCANCODE_KP_PLUS },
+	{ "NumMinus", SDL_SCANCODE_KP_MINUS },
+
+	{ "Comma", SDL_SCANCODE_COMMA },
+	{ "Period", SDL_SCANCODE_PERIOD },
+	{ "Semicolon", SDL_SCANCODE_SEMICOLON },
+	{ "BackQuote", SDL_SCANCODE_GRAVE },
+
+	{ "LeftBracket", SDL_SCANCODE_LEFTBRACKET },
+	{ "RightBracket", SDL_SCANCODE_RIGHTBRACKET },
+	{ "BackSlash", SDL_SCANCODE_BACKSLASH },
+	{ "ForwardSlash", SDL_SCANCODE_SLASH },
+
+	{ "Esc", SDL_SCANCODE_ESCAPE },
+	{ "Break", SDL_SCANCODE_ESCAPE },
+	{ "Del", SDL_SCANCODE_ESCAPE },
+
+	{ "MouseLeft", MOUSE_LEFT },
+	{ "MouseRight", MOUSE_RIGHT },
+	{ "MouseMiddle", MOUSE_MIDDLE },
+	{ "MouseX1", MOUSE_X1 },
+	{ "MouseX2", MOUSE_X2 },
+	{ "WheelUp", MOUSE_X1 },
+	{ "WheelDown", MOUSE_X2 },
+	{ "WheelLeft", MOUSE_X1 },
+	{ "WheelRight", MOUSE_X2 },
+
+	{ "Shift", UNIFIED_SHIFT },
+	{ "AnyShift", UNIFIED_SHIFT },
+	{ "LeftShift", UNIFIED_SHIFT },
+	{ "Left Shift", UNIFIED_SHIFT },
+	{ "RightShift", UNIFIED_SHIFT },
+	{ "Right Shift", UNIFIED_SHIFT },
+	{ "Ctrl", UNIFIED_CTRL },
+	{ "AnyCtrl", UNIFIED_CTRL },
+	{ "LeftCtrl", UNIFIED_CTRL },
+	{ "Left Ctrl", UNIFIED_CTRL },
+	{ "RightCtrl", UNIFIED_CTRL },
+	{ "Right Ctrl", UNIFIED_CTRL },
+	{ "Alt", UNIFIED_ALT },
+	{ "AnyAlt", UNIFIED_ALT },
+	{ "LeftAlt", UNIFIED_ALT },
+	{ "Left Alt", UNIFIED_ALT },
+	{ "RightAlt", UNIFIED_ALT },
+	{ "Right Alt", UNIFIED_ALT },
+	{ "Super", UNIFIED_SUPER },
+	{ "AnySuper", UNIFIED_SUPER },
+	{ "LeftSuper", UNIFIED_SUPER },
+	{ "Left Super", UNIFIED_SUPER },
+	{ "RightSuper", UNIFIED_SUPER },
+	{ "Right Super", UNIFIED_SUPER }
+}};
+
+// Canonical names for some scancodes.
+static const std::unordered_map<int, std::string> scancodenames {{
+	{ UNIFIED_SHIFT, "Shift" },
+	{ UNIFIED_CTRL, "Ctrl" },
+	{ UNIFIED_ALT, "Alt" },
+	{ UNIFIED_SUPER, "Super" },
+	{ MOUSE_LEFT, "MouseLeft" },
+	{ MOUSE_MIDDLE, "MouseMiddle" },
+	{ MOUSE_RIGHT, "MouseRight" },
+	{ MOUSE_WHEELUP, "WheelUp" },
+	{ MOUSE_WHEELDOWN, "WheelDown" },
+	{ MOUSE_X1, "WheelLeft" },
+	{ MOUSE_X2, "WheelRight" },
+
+	{ SDL_SCANCODE_KP_PLUS, "NumPlus" },
+	{ SDL_SCANCODE_KP_MINUS, "NumMinus" }
+}};
+
+
+SDL_Scancode FindScancode(const CStr& keyname)
 {
-	int keycode;
-	const char* keyname;
-	const char* altkeyname;
-};
-
-// You can use either key name in the config file...
+	if (scancodemap.find(keyname) != scancodemap.end())
+		return static_cast<SDL_Scancode>(scancodemap.at(keyname));
 
-static const SKeycodeMapping keycodeMapping[] =
-{
-	/* Just a tad friendlier than SDL_GetKeyName's name */
-	{ SDLK_BACKSPACE, "Backspace", "BkSp" },
-	{ SDLK_TAB, "Tab", 0 },
-	{ SDLK_CLEAR, "Clear", 0 }, // ?
-	{ SDLK_RETURN, "Return", "Ret" },
-	{ SDLK_PAUSE, "Pause", 0 }, // ?
-	{ SDLK_ESCAPE, "Escape", "Esc" },
-	{ SDLK_SPACE, "Space", "Spc" },
-	{ SDLK_EXCLAIM, "!", "Exclaim" },
-	{ SDLK_QUOTEDBL, "\"", "DoubleQuote" },
-	{ SDLK_HASH, "#", "Hash" },
-	{ SDLK_DOLLAR, "$", "Dollar" },
-	{ SDLK_AMPERSAND, "&", "Ampersand" },
-	{ SDLK_QUOTE, "'", "SingleQuote" },
-	{ SDLK_LEFTPAREN, "(", "LeftParen" },
-	{ SDLK_RIGHTPAREN, ")", "RightParen" },
-	{ SDLK_ASTERISK, "*", "Asterisk" },
-	{ SDLK_PLUS, "+", "Plus" },
-	{ SDLK_COMMA, ",", "Comma" },
-	{ SDLK_MINUS, "-", "Minus" },
-	{ SDLK_PERIOD, ".", "Period" },
-	{ SDLK_SLASH, "/", "ForwardSlash" },
-	{ SDLK_0, "0", 0 },
-	{ SDLK_1, "1", 0 },
-	{ SDLK_2, "2", 0 },
-	{ SDLK_3, "3", 0 },
-	{ SDLK_4, "4", 0 },
-	{ SDLK_5, "5", 0 },
-	{ SDLK_6, "6", 0 },
-	{ SDLK_7, "7", 0 },
-	{ SDLK_8, "8", 0 },
-	{ SDLK_9, "9", 0 },
-	{ SDLK_COLON, ":", "Colon" },
-	{ SDLK_SEMICOLON, ";", "Semicolon" },
-	{ SDLK_LESS, "<", "LessThan" },
-	{ SDLK_EQUALS, "=", "Equals" },
-	{ SDLK_GREATER, ">", "GreaterThan" },
-	{ SDLK_QUESTION, "?", "Question" },
-	{ SDLK_AT, "@", "At" },
-	{ SDLK_LEFTBRACKET, "[", "LeftBracket" },
-	{ SDLK_BACKSLASH, "\\", "BackSlash" },
-	{ SDLK_RIGHTBRACKET, "]", "RightBracket" },
-	{ SDLK_CARET, "^", "Caret", },
-	{ SDLK_UNDERSCORE, "_", "Underscore" },
-	{ SDLK_BACKQUOTE, "`", "BackQuote" },
-	{ SDLK_a, "A", 0 },
-	{ SDLK_b, "B", 0 },
-	{ SDLK_c, "C", 0 },
-	{ SDLK_d, "D", 0 },
-	{ SDLK_e, "E", 0 },
-	{ SDLK_f, "F", 0 },
-	{ SDLK_g, "G", 0 },
-	{ SDLK_h, "H", 0 },
-	{ SDLK_i, "I", 0 },
-	{ SDLK_j, "J", 0 },
-	{ SDLK_k, "K", 0 },
-	{ SDLK_l, "L", 0 },
-	{ SDLK_m, "M", 0 },
-	{ SDLK_n, "N", 0 },
-	{ SDLK_o, "O", 0 },
-	{ SDLK_p, "P", 0 },
-	{ SDLK_q, "Q", 0 },
-	{ SDLK_r, "R", 0 },
-	{ SDLK_s, "S", 0 },
-	{ SDLK_t, "T", 0 },
-	{ SDLK_u, "U", 0 },
-	{ SDLK_v, "V", 0 },
-	{ SDLK_w, "W", 0 },
-	{ SDLK_x, "X", 0 },
-	{ SDLK_y, "Y", 0 },
-	{ SDLK_z, "Z", 0 },
-	{ SDLK_DELETE, "Delete", "Del" },
-
-	{ SDLK_KP_0, "Numpad 0", "Num0" },
-	{ SDLK_KP_1, "Numpad 1", "Num1" },
-	{ SDLK_KP_2, "Numpad 2", "Num2" },
-	{ SDLK_KP_3, "Numpad 3", "Num3" },
-	{ SDLK_KP_4, "Numpad 4", "Num4" },
-	{ SDLK_KP_5, "Numpad 5", "Num5" },
-	{ SDLK_KP_6, "Numpad 6", "Num6" },
-	{ SDLK_KP_7, "Numpad 7", "Num7" },
-	{ SDLK_KP_8, "Numpad 8", "Num8" },
-	{ SDLK_KP_9, "Numpad 9", "Num9" },
-
-	{ SDLK_KP_PERIOD, "Numpad .", "NumPoint" },
-	{ SDLK_KP_DIVIDE, "Numpad /", "NumDivide" },
-	{ SDLK_KP_MULTIPLY, "Numpad *", "NumMultiply" },
-	{ SDLK_KP_MINUS, "Numpad -", "NumMinus" },
-	{ SDLK_KP_PLUS, "Numpad +", "NumPlus" },
-	{ SDLK_KP_ENTER, "Numpad Enter", "NumEnter" },
-	{ SDLK_KP_EQUALS, "Numpad =", "NumEquals" }, //?
-
-	{ SDLK_UP, "Arrow Up", "UpArrow" },
-	{ SDLK_DOWN, "Arrow Down", "DownArrow" },
-	{ SDLK_RIGHT, "Arrow Right", "RightArrow" },
-	{ SDLK_LEFT, "Arrow Left", "LeftArrow" },
-	{ SDLK_INSERT, "Insert", "Ins" },
-	{ SDLK_HOME, "Home", 0 },
-	{ SDLK_END, "End", 0 },
-	{ SDLK_PAGEUP, "Page Up", "PgUp" },
-	{ SDLK_PAGEDOWN, "Page Down", "PgDn" },
-
-	{ SDLK_F1, "F1", 0 },
-	{ SDLK_F2, "F2", 0 },
-	{ SDLK_F3, "F3", 0 },
-	{ SDLK_F4, "F4", 0 },
-	{ SDLK_F5, "F5", 0 },
-	{ SDLK_F6, "F6", 0 },
-	{ SDLK_F7, "F7", 0 },
-	{ SDLK_F8, "F8", 0 },
-	{ SDLK_F9, "F9", 0 },
-	{ SDLK_F10, "F10", 0 },
-	{ SDLK_F11, "F11", 0 },
-	{ SDLK_F12, "F12", 0 },
-	{ SDLK_F13, "F13", 0 },
-	{ SDLK_F14, "F14", 0 },
-	{ SDLK_F15, "F15", 0 },
-
-	{ SDLK_NUMLOCKCLEAR, "Num Lock", "NumLock" },
-
-	{ SDLK_CAPSLOCK, "Caps Lock", "CapsLock" },
-
-	{ SDLK_SCROLLLOCK, "Scroll Lock", "ScrlLock" },
-
-	{ SDLK_RSHIFT, "Right Shift", "RightShift" },
-	{ SDLK_LSHIFT, "Left Shift", "LeftShift" },
-	{ SDLK_RCTRL, "Right Ctrl", "RightCtrl" },
-	{ SDLK_LCTRL, "Left Ctrl", "LeftCtrl" },
-	{ SDLK_RALT, "Right Alt", "RightAlt" },
-	{ SDLK_LALT, "Left Alt", "LeftAlt" },
-
-	{ SDLK_LGUI, "Left Super", "LeftWin" },        /* "Windows" keys */
-	{ SDLK_RGUI, "Right Super", "RightWin" },
-
-	{ SDLK_MODE, "Alt Gr", "AltGr" },
-
-	{ SDLK_HELP, "Help", 0 }, // ?
-
-	{ SDLK_PRINTSCREEN, "Print Screen", "PrtSc" },
-
-	{ SDLK_SYSREQ, "SysRq", 0 },
-
-	{ SDLK_STOP, "Break", 0 },
-
-	{ SDLK_MENU, "Menu", 0 }, // ?
-	{ SDLK_POWER, "Power", 0 }, // ?
-	{ SDLK_UNDO, "Undo", 0 }, // ?
-	{ MOUSE_LEFT, "Left Mouse Button", "MouseLeft" },
-	{ MOUSE_RIGHT, "Right Mouse Button", "MouseRight" },
-	{ MOUSE_MIDDLE, "Middle Mouse Button", "MouseMiddle" },
-	{ MOUSE_WHEELUP, "Mouse Wheel Up", "WheelUp" },
-	{ MOUSE_WHEELDOWN, "Mouse Wheel Down", "WheelDown" },
-	{ MOUSE_X1, "Mouse X1", "MouseX1" },
-	{ MOUSE_X2, "Mouse X2", "MouseX2" },
-	{ UNIFIED_SHIFT, "Shift", "AnyShift" },
-	{ UNIFIED_CTRL, "Ctrl", "AnyCtrl" },
-	{ UNIFIED_ALT, "Alt", "AnyAlt" },
-	{ UNIFIED_SUPER, "Super", "AnyWindows" },
-	{ 0, 0, 0 },
-};
-
-void InitKeyNameMap()
-{
-	for (const SKeycodeMapping* it = keycodeMapping; it->keycode != 0; ++it)
-	{
-		keymap.insert(std::pair<CStr,int>(CStr(it->keyname).LowerCase(), it->keycode));
-		if(it->altkeyname)
-			keymap.insert(std::pair<CStr,int>(CStr(it->altkeyname).LowerCase(), it->keycode));
-	}
-
-	// Extra mouse buttons.
-	for (int i = 1; i < 256; ++i) // There is no mouse 0
-	{
-		keymap.insert(std::pair<CStr,int>("mousebutton" + CStr::FromInt(i), MOUSE_BASE + i));
-		keymap.insert(std::pair<CStr,int>("mousen" + CStr::FromInt(i), MOUSE_BASE + i));
-	}
+	return SDL_GetScancodeFromName(keyname.c_str());
 }
 
-int FindKeyCode(const CStr& keyname)
+CStr FindScancodeName(SDL_Scancode scancode)
 {
-	std::map<CStr,int>::iterator it;
-	it = keymap.find(keyname.LowerCase());
-	if (it != keymap.end())
-		return it->second;
-	return 0;
+	if (scancodenames.find(scancode) != scancodenames.end())
+		return scancodenames.at(scancode);
+	return SDL_GetScancodeName(scancode);
 }
 
-CStr FindKeyName(int keycode)
+CStr FindKeyName(SDL_Scancode scancode)
 {
-	for (const SKeycodeMapping* it = keycodeMapping; it->keycode != 0; ++it)
-		if (it->keycode == keycode)
-			return CStr(it->keyname);
-
-	return CStr("Unknown");
+	if (scancodenames.find(scancode) != scancodenames.end())
+		return scancodenames.at(scancode);
+	return SDL_GetKeyName(SDL_GetKeyFromScancode(scancode));
 }
 
 
Index: source/ps/scripting/JSInterface_ConfigDB.h
===================================================================
--- source/ps/scripting/JSInterface_ConfigDB.h
+++ source/ps/scripting/JSInterface_ConfigDB.h
@@ -31,6 +31,7 @@
 	bool SetChanges(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& cfgNsString, bool value);
 	std::string GetValue(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& cfgNsString, const std::string& name);
 	bool CreateValue(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& cfgNsString, const std::string& name, const std::string& value);
+	bool CreateValues(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& cfgNsString, const std::string& name, const std::vector<CStr>& values);
 	bool RemoveValue(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& cfgNsString, const std::string& name);
 	bool WriteFile(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& cfgNsString, const Path& path);
 	bool WriteValueToFile(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& cfgNsString, const std::string& name, const std::string& value, const Path& path);
Index: source/ps/scripting/JSInterface_ConfigDB.cpp
===================================================================
--- source/ps/scripting/JSInterface_ConfigDB.cpp
+++ source/ps/scripting/JSInterface_ConfigDB.cpp
@@ -112,6 +112,19 @@
 	return true;
 }
 
+bool JSI_ConfigDB::CreateValues(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::wstring& cfgNsString, const std::string& name, const std::vector<CStr>& values)
+{
+	if (IsProtectedConfigName(name))
+		return false;
+
+	EConfigNamespace cfgNs;
+	if (!GetConfigNamespace(cfgNsString, cfgNs))
+		return false;
+
+	g_ConfigDB.SetValueList(cfgNs, name, values);
+	return true;
+}
+
 bool JSI_ConfigDB::RemoveValue(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::wstring& cfgNsString, const std::string& name)
 {
 	if (IsProtectedConfigName(name))
@@ -177,6 +190,7 @@
 	scriptInterface.RegisterFunction<bool, std::wstring, bool, &JSI_ConfigDB::SetChanges>("ConfigDB_SetChanges");
 	scriptInterface.RegisterFunction<std::string, std::wstring, std::string, &JSI_ConfigDB::GetValue>("ConfigDB_GetValue");
 	scriptInterface.RegisterFunction<bool, std::wstring, std::string, std::string, &JSI_ConfigDB::CreateValue>("ConfigDB_CreateValue");
+	scriptInterface.RegisterFunction<bool, std::wstring, std::string, std::vector<CStr>, &JSI_ConfigDB::CreateValues>("ConfigDB_CreateValues");
 	scriptInterface.RegisterFunction<bool, std::wstring, std::string, &JSI_ConfigDB::RemoveValue>("ConfigDB_RemoveValue");
 	scriptInterface.RegisterFunction<bool, std::wstring, Path, &JSI_ConfigDB::WriteFile>("ConfigDB_WriteFile");
 	scriptInterface.RegisterFunction<bool, std::wstring, std::string, std::string, Path, &JSI_ConfigDB::WriteValueToFile>("ConfigDB_WriteValueToFile");
Index: source/ps/scripting/JSInterface_Hotkey.h
===================================================================
--- /dev/null
+++ source/ps/scripting/JSInterface_Hotkey.h
@@ -0,0 +1,28 @@
+/* Copyright (C) 2020 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_JSI_HOTKEY
+#define INCLUDED_JSI_HOTKEY
+
+#include "scriptinterface/ScriptInterface.h"
+
+namespace JSI_Hotkey
+{
+	void RegisterScriptFunctions(const ScriptInterface& ScriptInterface);
+}
+
+#endif // INCLUDED_JSI_HOTKEY
Index: source/ps/scripting/JSInterface_Hotkey.cpp
===================================================================
--- /dev/null
+++ source/ps/scripting/JSInterface_Hotkey.cpp
@@ -0,0 +1,178 @@
+/* Copyright (C) 2020 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "JSInterface_Hotkey.h"
+
+#include <unordered_map>
+#include <vector>
+
+#include "lib/external_libraries/libsdl.h"
+#include "ps/Hotkey.h"
+#include "ps/KeyName.h"
+#include "scriptinterface/ScriptConversions.h"
+
+// extern std::map<int, KeyMapping> g_HotkeyMap;
+// extern std::map<std::string, bool> g_HotkeyStatus;
+
+//JSVAL_VECTOR(std::wstring);
+
+/**
+ * Convert an unordered map to a JS object, mapping keys to values.
+ * Assumes T to have a c_str() method that returns a const char*
+ * NB: this is unordered since no particular effort is made to preserve order.
+ * TODO: this could be moved to ScriptConversions.cpp if the need arises.
+ */
+template<typename T, typename U>
+static void ToJSVal_unordered_map(JSContext* cx, JS::MutableHandleValue ret, const std::unordered_map<T, U>& val)
+{
+	JSAutoRequest rq(cx);
+	JS::RootedObject obj(cx, JS_NewPlainObject(cx));
+	if (!obj)
+	{
+		ret.setUndefined();
+		return;
+	}
+	for (const std::pair<T, U>& item : val)
+	{
+		JS::RootedValue el(cx);
+		ScriptInterface::ToJSVal<U>(cx, &el, item.second);
+		JS_SetProperty(cx, obj, item.first.c_str(), el);
+	}
+	ret.setObject(*obj);
+}
+
+template<>
+void ScriptInterface::ToJSVal<std::unordered_map<std::string, std::vector<std::vector<std::string>>>>(JSContext* cx, JS::MutableHandleValue ret, const std::unordered_map<std::string, std::vector<std::vector<std::string>>>& val)
+{
+	ToJSVal_unordered_map(cx, ret, val);
+}
+
+template<>
+void ScriptInterface::ToJSVal<std::unordered_map<std::string, std::string>>(JSContext* cx, JS::MutableHandleValue ret, const std::unordered_map<std::string, std::string>& val)
+{
+	ToJSVal_unordered_map(cx, ret, val);
+}
+
+/**
+ * @return a (js) object mapping hotkey name (from cfg files) to a list ofscancode names
+ */
+JS::Value GetHotkeyMap(ScriptInterface::CxPrivate* pCxPrivate)
+{
+	JSContext* cx = pCxPrivate->pScriptInterface->GetContext();
+	JSAutoRequest rq(cx);
+
+	JS::RootedValue hotkeyMap(cx);
+
+	std::unordered_map<std::string, std::vector<std::vector<std::string>>> hotkeys;
+	for (const std::pair<SDL_Scancode_, KeyMapping>& key : g_HotkeyMap)
+		for (const SHotkeyMapping& mapping : key.second)
+		{
+			std::vector<std::string> keymap;
+			keymap.push_back(FindScancodeName(static_cast<SDL_Scancode>(key.first)));
+			for (const SKey& secondary_key : mapping.requires)
+				keymap.push_back(FindScancodeName(static_cast<SDL_Scancode>(secondary_key.code)));
+			// All hotkey permutations are present so only push one (arbitrarily).
+			if (keymap.size() == 1 || keymap[0] < keymap[1])
+				hotkeys[mapping.name].emplace_back(keymap);
+		}
+	pCxPrivate->pScriptInterface->ToJSVal(cx, &hotkeyMap, hotkeys);
+
+	return hotkeyMap;
+}
+
+/**
+ * @return a (js) object mapping scancode names to their locale-dependent name.
+ */
+JS::Value GetScancodeKeyNames(ScriptInterface::CxPrivate* pCxPrivate)
+{
+	JSContext* cx = pCxPrivate->pScriptInterface->GetContext();
+	JSAutoRequest rq(cx);
+
+	JS::RootedValue obj(cx);
+	std::unordered_map<std::string, std::string> map;
+
+	// Get the name of all scancodes.
+	// This is slightly wasteful but should be fine overall, they are dense.
+	for (int i = 0; i < MOUSE_LAST; ++i)
+		map[FindScancodeName(static_cast<SDL_Scancode>(i))] = FindKeyName(static_cast<SDL_Scancode>(i));
+	pCxPrivate->pScriptInterface->ToJSVal(cx, &obj, map);
+
+	return obj;
+}
+
+void ReloadHotkeys(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
+{
+	UnloadHotkeys();
+	LoadHotkeys();
+}
+
+JS::Value GetConflicts(ScriptInterface::CxPrivate* pCxPrivate, JS::HandleValue combination)
+{
+	ScriptInterface* scriptInterface = pCxPrivate->pScriptInterface;
+	JSContext* cx = scriptInterface->GetContext();
+	JSAutoRequest rq(cx);
+
+	std::vector<std::string> keys;
+	if (!scriptInterface->FromJSVal(cx, combination, keys))
+	{
+		LOGERROR("Invalid hotkey combination");
+		return JS::NullValue();
+	}
+
+	if (keys.empty())
+		return JS::NullValue();
+
+	// Pick a random code as a starting point of the hotkeys (they are all equivalent).
+	SDL_Scancode_ startCode = FindScancode(keys.back());
+
+	std::map<SDL_Scancode_, KeyMapping>::const_iterator it = g_HotkeyMap.find(startCode);
+	if (it == g_HotkeyMap.end())
+		return JS::NullValue();
+
+	// Create a sorted vector with the remaining keys.
+	keys.pop_back();
+
+	std::set<SKey> codes;
+	for (const std::string& key : keys)
+		codes.insert(SKey{ FindScancode(key), false });
+
+	std::vector<CStr> conflicts;
+	// This isn't very efficient, but we shouldn't iterate too many hotkeys
+	// since we at least have one matching key.
+	for (const SHotkeyMapping& keymap : it->second)
+	{
+		std::set<SKey> match(keymap.requires.begin(), keymap.requires.end());
+		if (codes == match)
+			conflicts.emplace_back(keymap.name);
+	}
+	if (conflicts.empty())
+		return JS::NullValue();
+
+	JS::RootedValue ret(cx);
+	scriptInterface->ToJSVal(cx, &ret, conflicts);
+	return ret;
+}
+
+void JSI_Hotkey::RegisterScriptFunctions(const ScriptInterface& scriptInterface)
+{
+	scriptInterface.RegisterFunction<JS::Value, &GetHotkeyMap>("GetHotkeyMap");
+	scriptInterface.RegisterFunction<JS::Value, &GetScancodeKeyNames>("GetScancodeKeyNames");
+	scriptInterface.RegisterFunction<void, &ReloadHotkeys>("ReloadHotkeys");
+	scriptInterface.RegisterFunction<JS::Value, JS::HandleValue, &GetConflicts>("GetConflicts");
+}