diff --git a/ZATACKA.html b/ZATACKA.html
index 029d788..8367950 100644
--- a/ZATACKA.html
+++ b/ZATACKA.html
@@ -63,7 +63,7 @@ <h1>Achtung, die Kurve!</h1>
         <div id="border1" class="border">
             <canvas id="canvas_main" width="559" height="480"></canvas>
             <canvas id="canvas_overlay"  width="559" height="480" class="overlay"></canvas>
-            <div id="lobby" class="overlay">
+            <div id="lobby" class="flex overlay">
                 <ul id="controls">
                     <li>
                         <div class="red controls"></div>
@@ -90,6 +90,7 @@ <h1>Achtung, die Kurve!</h1>
                         <div class="blue ready"></div>
                     </li>
                 </ul>
+                <a id="button-show-settings" class="corner icon-button"></a>
             </div>
             <div id="KONEC_HRY" class="hidden overlay">
                 <ul id="results">
@@ -102,6 +103,10 @@ <h1>Achtung, die Kurve!</h1>
                 </ul>
             </div>
             <div id="messages" class="unobtrusive overlay"></div>
+            <div id="settings" class="hidden overlay">
+                <a id="button-hide-settings" class="corner icon-button"></a>
+                <form id="settings-form"></form>
+            </div>
         </div>
         </div>
         </div>
@@ -135,6 +140,7 @@ <h1>Achtung, die Kurve!</h1>
     <script src="js/lib/WarningMessage.js"></script>
     <script src="js/locales/Zatacka.en_US.js"></script>
     <script src="js/lib/preferences/Preference.js"></script>
+    <script src="js/lib/preferences/PreferenceWithValue.js"></script>
     <script src="js/lib/preferences/MultichoicePreference.js"></script>
     <script src="js/lib/preferences/BooleanPreference.js"></script>
     <script src="js/lib/preferences/RangePreference.js"></script>
diff --git a/Zatacka.css b/Zatacka.css
index 55642fe..da1760b 100644
--- a/Zatacka.css
+++ b/Zatacka.css
@@ -34,43 +34,61 @@ a:hover, a:focus, a:active {
     text-decoration: none;
 }
 
-input[type="checkbox"] {
+input[type="checkbox"],
+input[type="radio"] {
     display: none;
 }
 
 /* Checkbox and label: */
-input[type="checkbox"] + label {
-    cursor: pointer;
-    opacity: 0.75;
+input[type="checkbox"] + label,
+input[type="radio"] + label {
     padding-left: 18px;
     position: relative;
 }
 
-/* Checkbox and label on hover: */
-input[type="checkbox"] + label:hover,
-input[type="checkbox"] + label:focus,
-input[type="checkbox"] + label:active {
-    opacity: 1;
-}
-
 /* Actual checkbox: */
-input[type="checkbox"] + label::before {
-    border: 1px white solid;
+input[type="checkbox"] + label::before,
+input[type="radio"] + label::before {
+    background-position: center center;
+    background-repeat: no-repeat;
     box-sizing: border-box;
     content: "";
     display: inline-block;
     height: 12px;
     left: 0;
     position: absolute;
-    top: 1px;
+    top: 2px;
     width: 12px;
 }
 
+input[type="checkbox"] + label::before {
+    border: 1px white solid;
+}
+
+input[type="radio"] + label::before {
+    background-image: url("resources/kurve-radio-button.png");
+}
+
 /* Actual checkbox when checked: */
 input[type="checkbox"]:checked + label::before {
     background-image: url("resources/kurve-checkbox-tickmark.png");
-    background-position: center center;
-    background-repeat: no-repeat;
+}
+
+input[type="radio"]:checked + label::before {
+    background-image: url("resources/kurve-radio-button-checked.png");
+}
+
+input[type="checkbox"] + label,
+input[type="radio"] + label {
+    padding-top: 1px;
+    padding-bottom: 1px;
+}
+
+/* Checkbox and label on hover: */
+input[type="checkbox"] + label,
+input[type="radio"] + label,
+select {
+    cursor: pointer;
 }
 
 .button {
@@ -131,6 +149,24 @@ input[type="checkbox"]:checked + label::before {
     cursor: none;
 }
 
+.icon-button {
+    background-image: url("resources/kurve-icons.png");
+    cursor: pointer;
+    height: 16px;
+    opacity: 0.75;
+    width: 16px;
+}
+
+.icon-button:hover, .icon-button:focus, .icon-button:active {
+    opacity: 1;
+}
+
+.corner {
+    position: absolute;
+    right: 16px;
+    top: 16px;
+}
+
 #debug {
     background-color: black;
     border: 1px white solid;
@@ -185,6 +221,10 @@ input[type="checkbox"]:checked + label::before {
     border-color: #515151;
 }
 
+.flex {
+    display: flex;
+}
+
 .overlay {
     display: block;
     height: 100%;
@@ -195,6 +235,10 @@ input[type="checkbox"]:checked + label::before {
     box-sizing: border-box;
 }
 
+.hidden {
+    display: none;
+}
+
 .unobtrusive {
     pointer-events: none;
 }
@@ -204,14 +248,15 @@ input[type="checkbox"]:checked + label::before {
     overflow: hidden;
 }
 
-#lobby.hidden, #KONEC_HRY.hidden {
-    display: none;
+#lobby {
+    padding-left: 81px;
+    padding-top: 50px;
+    padding-bottom: 130px; /* 130 = 480 - 7 * 50, where 50 is the total height of each player's controls and 7 is 6 players plus 1 for margin */
 }
 
 #lobby #controls {
+    display: inline-block;
     list-style-type: none;
-    margin-left: 80px;
-    margin-top: 50px;
 }
 
 #lobby #controls li {
@@ -229,13 +274,13 @@ input[type="checkbox"]:checked + label::before {
 }
 
 #lobby #controls .ready {
+    visibility: hidden;
     background-image: url("resources/kurve-lobby-controls-ready.png");
-    display: none;
     width: 80px;
 }
 
 #lobby #controls .ready.active {
-    display: block;
+    visibility: visible;
 }
 
 #lobby #controls .red.controls    { background-position:    0px    0px; }
@@ -251,8 +296,77 @@ input[type="checkbox"]:checked + label::before {
 #lobby #controls .blue.controls   { background-position:    0px -250px; }
 #lobby #controls .blue.ready      { background-position: -160px -250px; }
 
-#lobby footer {
+#button-show-settings {
+    background-position: 0 -16px;
+}
+
+#button-hide-settings {
+    background-position: 0 0;
+}
+
+#settings {
+    background-color: rgba(0, 0, 0, 0.95);
+    padding: 50px 80px 50px 80px;
+}
+
+#settings-form > div {
+    box-sizing: border-box;
+    margin: 12px 0;
+    opacity: 0.6;
+}
+
+#settings-form > div:hover {
+    opacity: 1;
+}
+
+#settings-form > div:hover .description {
+    visibility: visible;
+}
+
+#settings-form fieldset {
+    border: 1px solid white;
+    padding: 2px 8px 6px 8px;
+}
+
+#settings-form fieldset legend {
+    padding: 0 4px;
+}
+
+#settings-form input[type="checkbox"] + label {
+    margin-left: 13px; /* to align with fieldset content */
+}
+
+#settings-form fieldset input[type="radio"] + label {
+    margin-left: 4px; /* to align with legend */
+}
+
+#settings-form label {
+    display: inline-block;
+}
+
+#settings-form .description {
+    box-sizing: border-box;
+    bottom: 0;
+    font-size: 0.75em;
+    height: 50px;
+    left: 0;
+    opacity: 0.8;
     padding: 0 80px;
+    position: absolute;
+    visibility: hidden;
+    width: 100%;
+}
+
+#settings-form select {
+    background: black;
+    border: 1px solid white;
+    color: white;
+    margin-top: 2px;
+    width: 219px;
+}
+
+#settings-form input[type="radio"] + label {
+    display: block;
 }
 
 #messages {
@@ -274,6 +388,15 @@ input[type="checkbox"]:checked + label::before {
     color: #C3C300;
 }
 
+#messages.hints-none .message,
+#messages.hints-warnings-only .message {
+    display: none;
+}
+
+#messages.hints-warnings-only .message.warning {
+    display: block;
+}
+
 .canvasHeight {
     height: 480px;
 }
diff --git a/index.html b/index.html
index 089a101..b4f78c4 100644
--- a/index.html
+++ b/index.html
@@ -64,6 +64,7 @@ <h1>Achtung, die Kurve!</h1>
         <main>
             <p id="start-hint"></p>
             <p id="fullscreen-hint"></p>
+            <p id="popup-hint"></p>
             <footer>
                 <a href="http://github.com/SimonAlling/kurve">Source Code</a>
             </footer>
diff --git a/js/GUIController.js b/js/GUIController.js
index 6a904fb..40c8cc9 100644
--- a/js/GUIController.js
+++ b/js/GUIController.js
@@ -2,10 +2,6 @@
 
 function GUIController(cfg) {
 
-    const CURSOR_VISIBLE = "visible";
-    const CURSOR_HIDDEN_ON_CANVAS = "hidden_on_canvas";
-    const CURSOR_HIDDEN = "hidden";
-
     const config = cfg;
     const lobby = byID("lobby");
     const controls = byID("controls");
@@ -16,6 +12,8 @@ function GUIController(cfg) {
     const results = byID("results");
     const KONEC_HRY = byID("KONEC_HRY");
     const messagesContainer = byID("messages");
+    const settingsContainer = byID("settings");
+    const settingsForm = byID("settings-form");
 
     const ORIGINAL_LEFT_WIDTH = left.offsetWidth;
 
@@ -52,14 +50,10 @@ function GUIController(cfg) {
 
     function setCursorBehavior(behavior) {
         switch (behavior) {
-            case CURSOR_VISIBLE:
+            case STRINGS.cursor_visible:
                 document.body.classList.remove(STRINGS.class_nocursor);
                 break;
-            case CURSOR_HIDDEN_ON_CANVAS:
-                canvas_main.classList.add(STRINGS.class_nocursor);
-                canvas_overlay.classList.add(STRINGS.class_nocursor);
-                break;
-            case CURSOR_HIDDEN:
+            case STRINGS.cursor_hidden:
                 document.body.classList.add(STRINGS.class_nocursor);
                 break;
             default:
@@ -67,8 +61,66 @@ function GUIController(cfg) {
         }
     }
 
-    function resetCursorBehavior() {
-        setCursorBehavior(CURSOR_VISIBLE);
+    function settingsEntryHTMLElement(preference, preferenceValue) {
+        if (!preference instanceof Preference) {
+            throw new TypeError(`${preference} is not a preference.`);
+        }
+
+        // Common
+        const div = document.createElement("div");
+        const label = document.createElement("label");
+        label.textContent = preference.label;
+        label.setAttribute("for", `${STRINGS.html_name_preference_prefix}${preference.key}`);
+        const description = document.createElement("aside");
+        description.textContent = preference.description;
+        description.classList.add(STRINGS.class_description);
+
+        // Boolean
+        if (preference instanceof BooleanPreference) {
+            const input = document.createElement("input");
+            input.type = "checkbox";
+            input.dataset.key = preference.key;
+            input.id = STRINGS.html_name_preference_prefix + preference.key;
+            input.checked = preferenceValue === true;
+            div.appendChild(input);
+            div.appendChild(label);
+        }
+
+        // Multichoice
+        else if (preference instanceof MultichoicePreference) {
+            const fieldset = document.createElement("fieldset");
+            const legend = document.createElement("legend");
+            legend.textContent = preference.label;
+            fieldset.appendChild(legend);
+            preference.values.forEach((value, index) => {
+                const id = STRINGS.html_name_preference_prefix + preference.key + "-" + preference.values[index];
+                const radioButton = document.createElement("input");
+                radioButton.type = "radio";
+                radioButton.id = id;
+                radioButton.name = STRINGS.html_name_preference_prefix + preference.key;
+                radioButton.value = value;
+                radioButton.dataset.key = preference.key;
+                radioButton.checked = preferenceValue === value;
+                const radioButtonLabel = document.createElement("label");
+                radioButtonLabel.textContent = preference.labels[index];
+                radioButtonLabel.setAttribute("for", id);
+                fieldset.appendChild(radioButton);
+                fieldset.appendChild(radioButtonLabel);
+            });
+            div.appendChild(fieldset);
+        }
+
+        // Range
+        else if (preference instanceof RangePreference) {
+            div.appendChild(label);
+            const input = document.createElement("input");
+            input.type = "number";
+            input.name = STRINGS.html_name_preference_prefix + preference.key;
+            div.appendChild(input);
+        }
+
+        div.appendChild(description);
+        return div;
     }
 
 
@@ -115,7 +167,7 @@ function GUIController(cfg) {
         resetScoreboard();
         resetResults();
         allPlayersUnready();
-        resetCursorBehavior();
+        setCursorBehavior(STRINGS.cursor_visible);
     }
 
     function konecHry() {
@@ -138,6 +190,47 @@ function GUIController(cfg) {
         updateMessages(currentMessages);
     }
 
+    function showSettings() {
+        settings.classList.remove(STRINGS.class_hidden);
+    }
+
+    function hideSettings() {
+        settings.classList.add(STRINGS.class_hidden);
+    }
+
+    function updateSettingsForm(preferencesWithData) {
+        flush(settingsForm);
+        preferencesWithData.forEach((preferenceWithData) => {
+            settingsForm.appendChild(settingsEntryHTMLElement(preferenceWithData.preference, preferenceWithData.value));
+        });
+    }
+
+    function parseSettingsForm() {
+        const newSettings = [];
+        // <input> elements:
+        const inputs = settingsForm.querySelectorAll("input");
+        Array.from(inputs).forEach((input) => {
+            if (input.type === "checkbox") {
+                // checkbox
+                newSettings.push({ key: input.dataset.key, value: input.checked });
+            } else if (input.type === "radio") {
+                // radio
+                if (input.checked === true) {
+                    newSettings.push({ key: input.dataset.key, value: input.value });
+                }
+            } else {
+                // text, number etc
+                newSettings.push({ key: input.dataset.key, value: input.value.toString() });
+            }
+        });
+        // <select> elements:
+        const selects = settingsForm.querySelectorAll("select");
+        Array.from(selects).forEach((select) => {
+            newSettings.push({ key: select.dataset.key, value: select.options[select.selectedIndex].value });
+        });
+        return newSettings;
+    }
+
     function hideMessage(message) {
         currentMessages = currentMessages.filter(msg => msg !== message);
         updateMessages(currentMessages);
@@ -159,6 +252,23 @@ function GUIController(cfg) {
         updateMessages(currentMessages);
     }
 
+    function setMessageMode(mode) {
+        log(`Setting message mode to ${mode}.`);
+        switch (mode) {
+            case STRINGS.pref_value_hints_warnings_only:
+                messagesContainer.classList.remove(STRINGS.class_hints_none);
+                messagesContainer.classList.add(STRINGS.class_hints_warnings_only);
+                break;
+            case STRINGS.pref_value_hints_none:
+                messagesContainer.classList.remove(STRINGS.class_hints_warnings_only);
+                messagesContainer.classList.add(STRINGS.class_hints_none);
+                break;
+            default:
+                messagesContainer.classList.remove(STRINGS.class_hints_warnings_only);
+                messagesContainer.classList.remove(STRINGS.class_hints_none);
+        }
+    }
+
     function updateBoard(board, id, newScore) {
         if (!isHTMLElement(board)) {
             logWarning(`Cannot update any entry in ${board} because it is not an HTML element.`);
@@ -190,19 +300,21 @@ function GUIController(cfg) {
     }
 
     return {
-        CURSOR_VISIBLE,
-        CURSOR_HIDDEN_ON_CANVAS,
-        CURSOR_HIDDEN,
         playerReady,
         playerUnready,
         gameStarted,
         gameQuit,
         konecHry,
+        showSettings,
+        hideSettings,
+        updateSettingsForm,
+        parseSettingsForm,
         updateScoreOfPlayer,
         updateMessages,
         showMessage,
         hideMessage,
         clearMessages,
+        setMessageMode,
         setCursorBehavior,
         setEdgePadding
     };
diff --git a/js/SplashScreen.js b/js/SplashScreen.js
index 5abd904..c3d13c7 100644
--- a/js/SplashScreen.js
+++ b/js/SplashScreen.js
@@ -8,7 +8,11 @@
     }
 
     function proceedToGame() {
-        document.location.href = STRINGS.game_url;
+        const newWindow = window.open(STRINGS.game_url);
+        if (!newWindow || newWindow.closed || typeof newWindow.closed === "undefined") {
+            // Browser is blocking popups.
+            showPopupHint();
+        }
     }
 
     function splashScreenKeyHandler(event) {
@@ -32,6 +36,13 @@
         }
     }
 
+    function showPopupHint() {
+        const popupHintElement = byID(STRINGS.id_popup_hint);
+        if (isHTMLElement(popupHintElement)) {
+            popupHintElement.innerHTML = TEXT.hint_popup;
+        }
+    }
+
     function addEventListeners() {
         document.addEventListener("keydown", splashScreenKeyHandler);
         document.addEventListener("DOMContentLoaded", showStartHint);
diff --git a/js/Zatacka.js b/js/Zatacka.js
index 99185d5..92ab933 100644
--- a/js/Zatacka.js
+++ b/js/Zatacka.js
@@ -37,6 +37,8 @@ const Zatacka = ((window, document) => {
             alt:     new WarningMessage(TEXT.hint_alt),
             ctrl:    new WarningMessage(TEXT.hint_ctrl),
             mouse:   new WarningMessage(TEXT.hint_mouse),
+            preferences_access_denied: new WarningMessage(TEXT.hint_preferences_access_denied),
+            preferences_localstorage_failed: new WarningMessage(TEXT.hint_preferences_localstorage_failed),
         }),
         defaultPlayers: Object.freeze([
             { id: 1, name: "Red"   , color: "#FF2800", keyL: KEY["1"]                              , keyR: KEY.Q                         },
@@ -49,25 +51,63 @@ const Zatacka = ((window, document) => {
     });
 
     const PREFERENCES = Object.freeze([
+        // {
+        //     type: BooleanPreference,
+        //     key: STRINGS.pref_key_prevent_spawnkill,
+        //     label: TEXT.pref_label_prevent_spawnkill,
+        //     description: TEXT.pref_label_description_prevent_spawnkill,
+        //     default: true,
+        // },
         {
             type: MultichoicePreference,
             key: STRINGS.pref_key_cursor,
+            label: TEXT.pref_label_cursor,
+            description: TEXT.pref_label_description_cursor,
             values: [
                 STRINGS.pref_value_cursor_always_visible,
                 STRINGS.pref_value_cursor_hidden_when_mouse_used_by_player,
-                STRINGS.pref_value_cursor_always_hidden
+                STRINGS.pref_value_cursor_always_hidden,
             ],
-            default: STRINGS.pref_value_cursor_hidden_when_mouse_used_by_player
+            labels: [
+                TEXT.pref_label_cursor_always_visible,
+                TEXT.pref_label_cursor_hidden_when_mouse_used_by_player,
+                TEXT.pref_label_cursor_always_hidden,
+            ],
+            default: STRINGS.pref_value_cursor_hidden_when_mouse_used_by_player,
+        },
+        {
+            type: MultichoicePreference,
+            key: STRINGS.pref_key_edge_fix,
+            label: TEXT.pref_label_edge_fix,
+            description: TEXT.pref_label_description_edge_fix,
+            values: [
+                STRINGS.pref_value_edge_fix_full,
+                STRINGS.pref_value_edge_fix_minimal,
+                STRINGS.pref_value_edge_fix_off,
+            ],
+            labels: [
+                TEXT.pref_label_edge_fix_full,
+                TEXT.pref_label_edge_fix_minimal,
+                TEXT.pref_label_edge_fix_off,
+            ],
+            default: STRINGS.pref_value_edge_fix_off,
         },
         {
             type: MultichoicePreference,
             key: STRINGS.pref_key_hints,
+            label: TEXT.pref_label_hints,
+            description: TEXT.pref_label_description_hints,
             values: [
                 STRINGS.pref_value_hints_all,
                 STRINGS.pref_value_hints_warnings_only,
-                STRINGS.pref_value_hints_none
+                STRINGS.pref_value_hints_none,
             ],
-            default: STRINGS.pref_value_hints_all
+            labels: [
+                TEXT.pref_label_hints_all,
+                TEXT.pref_label_hints_warnings_only,
+                TEXT.pref_label_hints_none,
+            ],
+            default: STRINGS.pref_value_hints_all,
         }
     ]);
 
@@ -150,15 +190,15 @@ const Zatacka = ((window, document) => {
     function applyCursorBehavior() {
         const mouseIsBeingUsed = game.getPlayers().some(hasMouseButton);
         let behavior;
-        switch (preferenceManager.get(STRINGS.pref_key_cursor)) {
+        switch (preferenceManager.getCached(STRINGS.pref_key_cursor)) {
             case STRINGS.pref_value_cursor_hidden_when_mouse_used_by_player:
-                behavior = mouseIsBeingUsed ? guiController.CURSOR_HIDDEN : guiController.CURSOR_VISIBLE;
+                behavior = mouseIsBeingUsed ? STRINGS.cursor_hidden : STRINGS.cursor_visible;
                 break;
             case STRINGS.pref_value_cursor_always_hidden:
-                behavior = guiController.CURSOR_HIDDEN;
+                behavior = STRINGS.cursor_hidden;
                 break;
             default:
-                behavior = guiController.CURSOR_VISIBLE;
+                behavior = STRINGS.cursor_visible;
         }
         log(`Setting cursor behavior to ${behavior}.`);
         guiController.setCursorBehavior(behavior);
@@ -167,9 +207,7 @@ const Zatacka = ((window, document) => {
     function proceedKeyPressedInLobby() {
         const numberOfReadyPlayers = game.getNumberOfPlayers();
         if (numberOfReadyPlayers > 0) {
-            clearTimeout(hintPickTimer);
-            clearTimeout(hintProceedTimer);
-            guiController.clearMessages();
+            clearMessages();
             removeLobbyEventListeners();
             addGameEventListeners();
             applyCursorBehavior();
@@ -242,6 +280,10 @@ const Zatacka = ((window, document) => {
         }
     }
 
+    function eventConsumer(event) {
+        event.stopPropagation();
+    }
+
     function keyPressedInLobby(pressedKey) {
         config.defaultPlayers.forEach((playerData) => {
             addOrRemovePlayer(playerData, pressedKey);
@@ -299,8 +341,106 @@ const Zatacka = ((window, document) => {
         event.preventDefault();
     }
 
+    function gameUnloadHandler(event) {
+        // A simple trick to prevent accidental unloading of the entire game.
+        const message = TEXT.hint_unload;
+        event.returnValue = message; // Gecko, Trident, Chrome 34+
+        return message;              // Gecko, Webkit, Chrome <34
+    }
+
+    function settingsKeyHandler(event) {
+        const pressedKey = event.keyCode;
+        if (isQuitKey(pressedKey)) {
+            hideSettings();
+        }
+    }
+
+    function showSettings() {
+        clearTimeout(hintPickTimer);
+        clearTimeout(hintProceedTimer);
+        try {
+            guiController.updateSettingsForm(preferenceManager.getAllPreferencesWithValues_saved());
+        } catch(e) {
+            logWarning("Could not load settings from localStorage. Using cached settings instead.");
+            guiController.updateSettingsForm(preferenceManager.getAllPreferencesWithValues_cached());
+            handleSettingsAccessError(e);
+        }
+        removeLobbyEventListeners();
+        addHideSettingsButtonEventListener();
+        document.addEventListener("keydown", settingsKeyHandler);
+        guiController.showSettings();
+    }
+
+    function hideSettings() {
+        document.removeEventListener("keydown", settingsKeyHandler);
+        addLobbyEventListeners();
+        guiController.parseSettingsForm().forEach((newSetting) => {
+            try {
+                preferenceManager.set(newSetting.key, newSetting.value);
+            } catch(e) {
+                logWarning(`Could not save setting '${newSetting.key}' to localStorage.`);
+                handleSettingsAccessError(e);
+            }
+        });
+        applySettings();
+        guiController.hideSettings();
+    }
+
+    function applySettings() {
+        try {
+            // Edge fix:
+            setEdgeMode(preferenceManager.getSaved(STRINGS.pref_key_edge_fix));
+            // Hints:
+            guiController.setMessageMode(preferenceManager.getSaved(STRINGS.pref_key_hints));
+        } catch(e) {
+            logWarning("Could not load settings from localStorage. Using cached settings instead.");
+            setEdgeMode(preferenceManager.getCached(STRINGS.pref_key_edge_fix));
+            guiController.setMessageMode(preferenceManager.getCached(STRINGS.pref_key_hints));
+            handleSettingsAccessError(e);
+        }
+    }
+
+    function handleSettingsAccessError(error) {
+        if (error.name === STRINGS.error_name_security) {
+            guiController.showMessage(config.messages.preferences_access_denied);
+        } else {
+            guiController.showMessage(config.messages.preferences_localstorage_failed);
+        }
+    }
+
+    function clearMessages() {
+        clearTimeout(hintPickTimer);
+        clearTimeout(hintProceedTimer);
+        guiController.clearMessages();
+    }
+
+    function addShowSettingsButtonEventListener() {
+        const showSettingsButton = byID("button-show-settings");
+        if (showSettingsButton instanceof HTMLElement) {
+            showSettingsButton.addEventListener("mousedown", eventConsumer);
+            showSettingsButton.addEventListener("click", showSettings);
+        }
+    }
+
+    function addHideSettingsButtonEventListener() {
+        const hideSettingsButton = byID("button-hide-settings");
+        if (hideSettingsButton instanceof HTMLElement) {
+            hideSettingsButton.addEventListener("mousedown", eventConsumer);
+            hideSettingsButton.addEventListener("click", hideSettings);
+        }
+    }
+
+    function removeShowSettingsButtonEventListener() {
+        const showSettingsButton = byID("button-show-settings");
+        if (showSettingsButton instanceof HTMLElement) {
+            showSettingsButton.removeEventListener("mousedown", eventConsumer);
+            showSettingsButton.removeEventListener("click", showSettings);
+        }
+    }
+
     function addLobbyEventListeners() {
         log("Adding lobby event listeners ...");
+        addShowSettingsButtonEventListener();
         document.addEventListener("keydown", lobbyKeyHandler);
         document.addEventListener("mousedown", lobbyMouseHandler);
         document.addEventListener("contextmenu", lobbyMouseHandler);
@@ -309,6 +449,7 @@ const Zatacka = ((window, document) => {
 
     function removeLobbyEventListeners() {
         log("Removing lobby event listeners ...");
+        removeShowSettingsButtonEventListener();
         document.removeEventListener("keydown", lobbyKeyHandler);
         document.removeEventListener("mousedown", lobbyMouseHandler);
         document.removeEventListener("contextmenu", lobbyMouseHandler);
@@ -324,6 +465,7 @@ const Zatacka = ((window, document) => {
         document.addEventListener("keydown", gameKeyHandler);
         document.addEventListener("mousedown", gameMouseHandler);
         document.addEventListener("contextmenu", gameMouseHandler);
+        window.addEventListener("beforeunload", gameUnloadHandler);
         log("Done.");
     }
 
@@ -331,6 +473,7 @@ const Zatacka = ((window, document) => {
         log("Removing game event listeners ...");
         document.removeEventListener("keydown", gameKeyHandler);
         document.removeEventListener("mousedown", gameMouseHandler);
+        window.removeEventListener("beforeunload", gameUnloadHandler);
         log("Done.");
     }
 
@@ -348,6 +491,8 @@ const Zatacka = ((window, document) => {
         guiController.showMessage(config.messages.pick);
     }, config.hintDelay);
 
+    applySettings();
+
     return {
         getConfig: () => config,
         getGame: () => game,
diff --git a/js/lib/preferences/BooleanPreference.js b/js/lib/preferences/BooleanPreference.js
index 93d3b45..175c9ca 100644
--- a/js/lib/preferences/BooleanPreference.js
+++ b/js/lib/preferences/BooleanPreference.js
@@ -1,12 +1,15 @@
 "use strict";
 
-class BooleanPreference extends MultichoicePreference {
+class BooleanPreference extends Preference {
     constructor(data) {
-        super({
-            key: data.key,
-            values: ["true", "false"],
-            default: data.default
-        });
+        super(data);
+        if (!(data.default === true || data.default === false)) {
+            super.invalidValue(data.default);
+        }
+    }
+
+    isValidValue(value) {
+        return value === true || value === false;
     }
 
     static stringify(value) {
diff --git a/js/lib/preferences/MultichoicePreference.js b/js/lib/preferences/MultichoicePreference.js
index 73ca245..6c654d0 100644
--- a/js/lib/preferences/MultichoicePreference.js
+++ b/js/lib/preferences/MultichoicePreference.js
@@ -7,6 +7,7 @@ class MultichoicePreference extends Preference {
         }
         super(data);
         this.values = data.values;
+        this.labels = data.labels;
         if (!this.isValidValue(data.default)) {
             super.invalidValue(data.default);
         }
diff --git a/js/lib/preferences/Preference.js b/js/lib/preferences/Preference.js
index 5ee563e..96ad090 100644
--- a/js/lib/preferences/Preference.js
+++ b/js/lib/preferences/Preference.js
@@ -8,7 +8,9 @@ class Preference {
             throw new TypeError(`Preference '${data.key}' must have a default value.`);
         }
         this.key = data.key;
+        this.label = data.label;
         this.default = data.default;
+        this.description = data.description;
     }
 
     isValidValue(value) {
diff --git a/js/lib/preferences/PreferenceManager.js b/js/lib/preferences/PreferenceManager.js
index 79dc539..4bb0460 100644
--- a/js/lib/preferences/PreferenceManager.js
+++ b/js/lib/preferences/PreferenceManager.js
@@ -2,12 +2,36 @@
 
 function PreferenceManager(preferencesData) {
     const LOCALSTORAGE_PREFIX = "pref_key_";
+    const CONSOLE_PREFIX = "[PreferenceManager] ";
 
     // Parse and validate preferences:
     log("Validating preferences ...");
     const PREFERENCES = parsePreferences(preferencesData);
     log("Done.");
 
+    // Initialize cached preference database:
+    let CACHED_PREFERENCES_WITH_VALUES = getAllPreferencesWithDefaultValues();
+    CACHED_PREFERENCES_WITH_VALUES.forEach((preferenceWithValue) => {
+        const key = preferenceWithValue.preference.key;
+        try {
+            preferenceWithValue.value = getSaved(key);
+        } catch(e) {
+            logWarning(`Using default value '${preferenceWithValue.preference.getDefaultValue()}' for preference '${key}' since no saved value could be loaded from localStorage.`);
+        }
+    });
+
+    function log(string) {
+        console.log(CONSOLE_PREFIX + string);
+    }
+
+    function logWarning(string) {
+        console.warn(CONSOLE_PREFIX + string);
+    }
+
+    function logError(string) {
+        console.error(CONSOLE_PREFIX + string);
+    }
+
     function parsePreferences(preferencesData) {
         return preferencesData.map(parsePreference);
     }
@@ -31,6 +55,22 @@ function PreferenceManager(preferencesData) {
         return PREFERENCES.find((pref) => pref.key === key);
     }
 
+    function getCachedPreference(key) {
+        return CACHED_PREFERENCES_WITH_VALUES.find((preferenceWithValue) => preferenceWithValue.preference.key === key);
+    }
+
+    function getAllPreferencesWithValues_saved() { // throws SecurityError etc
+        return PREFERENCES.map((preference) => new PreferenceWithValue(preference, getSaved(preference.key)));
+    }
+
+    function getAllPreferencesWithValues_cached() {
+        return PREFERENCES.map((preference) => new PreferenceWithValue(preference, getCached(preference.key)));
+    }
+
+    function getAllPreferencesWithDefaultValues() {
+        return PREFERENCES.map((preference) => new PreferenceWithValue(preference, preference.getDefaultValue()));
+    }
+
     function getKey(pref) {
         return pref.key;
     }
@@ -39,13 +79,13 @@ function PreferenceManager(preferencesData) {
         return getPreference(key).isValidValue(value);
     }
 
-    function setToDefaultValue(key) {
+    function setToDefaultValue(key) { // throws SecurityError etc
         set(key, getDefaultValue(key));
     }
 
     function getDefaultValue(key) {
         if (!preferenceExists(key)) {
-            throw new Error(`Preference ${key} does not exist.`);
+            throw new Error(`Preference '${key}' does not exist.`);
         }
         return getPreference(key).getDefaultValue();
     }
@@ -54,7 +94,7 @@ function PreferenceManager(preferencesData) {
         return LOCALSTORAGE_PREFIX + key;
     }
 
-    function set(key, value) {
+    function set(key, value) { // throws SecurityError etc
         if (!preferenceExists(key)) {
             throw new Error(`There is no preference with key '${key}'.`);
         }
@@ -62,18 +102,34 @@ function PreferenceManager(preferencesData) {
         if (!isValidPreferenceValue(key, value)) {
             pref.invalidValue(value);
         } else {
-            log(`Setting preference ${key} to ${value}.`);
-            localStorage.setItem(LS_prefix(key), pref.stringify(value));
+            log(`Setting preference '${key}' to '${value}'.`);
+            getCachedPreference(key).value = value;
+            try {
+                localStorage.setItem(LS_prefix(key), pref.constructor.stringify(value));
+            } catch(e) {
+                logError(`Failed to save value for preference '${key}' to localStorage. The following error was thrown:\n${e}`);
+                throw e; // likely a SecurityError, but could be others as well
+            }
         }
     }
 
-    function get(key) {
+    function getSaved(key) { // throws SecurityError etc
         if (!preferenceExists(key)) {
             throw new Error(`There is no preference with key '${key}'.`);
         }
         const pref = getPreference(key);
-        const savedValue = localStorage.getItem(LS_prefix(key));
-        return isValidPreferenceValue(key, savedValue) ? pref.parse(savedValue) : getDefaultValue(key);
+        let savedValue;
+        try {
+            savedValue = localStorage.getItem(LS_prefix(key));
+        } catch(e) {
+            logError(`Failed to load saved value for preference '${key}' from localStorage. The following error was thrown:\n${e}`);
+            throw e; // likely a SecurityError, but could be others as well
+        }
+        return isValidPreferenceValue(key, pref.constructor.parse(savedValue)) ? pref.constructor.parse(savedValue) : getDefaultValue(key);
+    }
+
+    function getCached(key) {
+        return getCachedPreference(key).value;
     }
 
     function setAllToDefault() {
@@ -85,9 +141,13 @@ function PreferenceManager(preferencesData) {
     return {
         isValidPreferenceValue,
         set,
-        get,
+        getSaved,
+        getCached,
         setToDefaultValue,
         getDefaultValue,
+        getAllPreferencesWithValues_saved,
+        getAllPreferencesWithValues_cached,
+        getAllPreferencesWithDefaultValues,
         setAllToDefault
     }
 }
\ No newline at end of file
diff --git a/js/lib/preferences/PreferenceWithValue.js b/js/lib/preferences/PreferenceWithValue.js
new file mode 100644
index 0000000..ee00955
--- /dev/null
+++ b/js/lib/preferences/PreferenceWithValue.js
@@ -0,0 +1,11 @@
+"use strict";
+
+class PreferenceWithValue {
+    constructor(preference, value) {
+        if (!preference.isValidValue(value)) {
+            throw new TypeError(`${value} is not a valid value for preference ${preference.key}.`);
+        }
+        this.preference = preference;
+        this.value = value;
+    }
+}
diff --git a/js/locales/Zatacka.en_US.js b/js/locales/Zatacka.en_US.js
index 6dcd1b8..b6d706f 100644
--- a/js/locales/Zatacka.en_US.js
+++ b/js/locales/Zatacka.en_US.js
@@ -5,7 +5,9 @@ const TEXT = (() => {
     const KEY_CMD   = "⌘";
 
     return Object.freeze({
+        hint_unload: `Are you sure you want to unload the page?`,
         hint_start: `Press Space to start`,
+        hint_popup: `It is recommended to run Kurve in its own window without history (to avoid switching tabs or navigating back in history mid-game). To do that, please allow popups or <a href="ZATACKA.html" target="_blank">click here</a>.`,
         hint_pick: `Pick your desired color by pressing the corresponding LEFT key (e.g. M for Orange).`,
         hint_proceed: `Press Space or Enter to start!`,
         hint_next: `Press Space or Enter to proceed, or Esc to quit.`,
@@ -13,10 +15,33 @@ const TEXT = (() => {
         hint_alt: `Alt plus some other keys may cause undesired behavior (e.g. switching windows).`,
         hint_ctrl: `Ctrl plus some other keys may cause undesired behavior (e.g. closing the tab).`,
         hint_mouse: `Make sure to keep the mouse cursor inside the browser window.`,
+        hint_preferences_access_denied: `Could not save/load settings because access to localStorage was denied by the browser. This might be caused by "third-party site data" being blocked or similar.`,
+        hint_preferences_localstorage_failed: `Could not save/load settings because access to localStorage failed.`,
 
         keyboard_fullscreen_mac: `${KEY_CMD} + ${KEY_SHIFT} + F`,
         keyboard_fullscreen_standard: "F11",
 
         getFullscreenHint: (shortcut) => `Press ${shortcut} to toggle fullscreen`,
+
+        pref_label_cursor: `Cursor`,
+        pref_label_description_cursor: `Control how the cursor behaves when the game is running.`,
+        pref_label_cursor_always_visible: `Always visible`,
+        pref_label_cursor_hidden_when_mouse_used_by_player: `Hidden when mouse used by player`,
+        pref_label_cursor_always_hidden: `Always hidden`,
+
+        pref_label_edge_fix: `Edge fix`,
+        pref_label_description_edge_fix: `Shrink the playing field slightly to make the edge visible if the monitor is exactly the same height or width as the game.`,
+        pref_label_edge_fix_full: `Full`,
+        pref_label_edge_fix_minimal: `Minimal`,
+        pref_label_edge_fix_off: `Off`,
+
+        pref_label_hints: `Hints`,
+        pref_label_description_hints: `Hints, except for warnings, are redundant for experienced Kurve players.`,
+        pref_label_hints_all: `All`,
+        pref_label_hints_warnings_only: `Warnings only`,
+        pref_label_hints_none: `None`,
+
+        pref_label_prevent_spawnkill: `Prevent spawnkills`,
+        pref_label_description_prevent_spawnkill: `Enforce a minimum distance between player spawns.`,
     });
 })();
diff --git a/js/strings.js b/js/strings.js
index 212f8b6..e625383 100644
--- a/js/strings.js
+++ b/js/strings.js
@@ -1,24 +1,39 @@
 "use strict";
 
-const STRINGS = (() => {
-    return Object.freeze({
-        game_url: "ZATACKA.html",
-
-        class_hidden: "hidden",
-        class_active: "active",
-        class_nocursor: "nocursor",
-
-        id_start_hint: "start-hint",
-        id_fullscreen_hint: "fullscreen-hint",
-
-        pref_key_cursor: "cursor",
-        pref_value_cursor_always_visible: "always_visible",
-        pref_value_cursor_hidden_when_mouse_used_by_player: "hidden_when_mouse_used_by_player",
-        pref_value_cursor_always_hidden: "always_hidden",
-
-        pref_key_hints: "hints",
-        pref_value_hints_all: "all",
-        pref_value_hints_warnings_only: "warnings",
-        pref_value_hints_none: "none",
-    });
-})();
+const STRINGS = (() => Object.freeze({
+    game_url: "ZATACKA.html",
+
+    error_name_security: "SecurityError",
+
+    class_hidden: "hidden",
+    class_active: "active",
+    class_description: "description",
+    class_nocursor: "nocursor",
+    class_hints_warnings_only: "hints-warnings-only",
+    class_hints_none: "hints-none",
+    html_name_preference_prefix: "preference-",
+
+    cursor_hidden: "hidden",
+    cursor_visible: "visible",
+
+    id_start_hint: "start-hint",
+    id_fullscreen_hint: "fullscreen-hint",
+    id_popup_hint: "popup-hint",
+
+    pref_key_cursor: "cursor",
+    pref_value_cursor_always_visible: "always_visible",
+    pref_value_cursor_hidden_when_mouse_used_by_player: "hidden_when_mouse_used_by_player",
+    pref_value_cursor_always_hidden: "always_hidden",
+
+    pref_key_edge_fix: "edge_fix",
+    pref_value_edge_fix_full: "full",
+    pref_value_edge_fix_minimal: "minimal",
+    pref_value_edge_fix_off: "off",
+
+    pref_key_hints: "hints",
+    pref_value_hints_all: "all",
+    pref_value_hints_warnings_only: "warnings",
+    pref_value_hints_none: "none",
+
+    pref_key_prevent_spawnkill: "prevent_spawnkill",
+}))();
diff --git a/kurve.se.css b/kurve.se.css
index 07704ba..c61d09f 100644
--- a/kurve.se.css
+++ b/kurve.se.css
@@ -27,13 +27,17 @@ main {
     font-size: 1.2em;
 }
 
-#fullscreen-hint {
+#fullscreen-hint, #popup-hint {
     font-size: 0.9em;
 }
 
+#popup-hint a {
+    text-decoration: underline;
+}
+
 main footer {
     bottom: 0;
-    height: 80px;
+    height: 40px;
     position: absolute;
     width: 100%;
 }
diff --git a/resources/kurve-icons.png b/resources/kurve-icons.png
new file mode 100644
index 0000000..b9bd2c4
Binary files /dev/null and b/resources/kurve-icons.png differ
diff --git a/resources/kurve-radio-button-checked.png b/resources/kurve-radio-button-checked.png
new file mode 100644
index 0000000..17746d0
Binary files /dev/null and b/resources/kurve-radio-button-checked.png differ
diff --git a/resources/kurve-radio-button.png b/resources/kurve-radio-button.png
new file mode 100644
index 0000000..b70702a
Binary files /dev/null and b/resources/kurve-radio-button.png differ