@@ -344,21 +344,13 @@ and padded to four digits.
 
 ### The keyboards
 
-The letter keyboards are QWERTY by default, or alphabetical if Settings says so
-— `Keyboard: QWERTY` / `Keyboard: ABC`, for readers who do not touch-type and
-would rather not hunt. The number keyboard has no such choice, digits having
-only one order. The setting lives in Settings, which is reachable only from the
-main menu, so it cannot change while a seed is loaded: no session can have half
-a passphrase typed on one arrangement and half on the other. Keys are found by
-character rather than by position in any case, so the same presses spell the
-same string either way.
-
-The cursor opens on the middle key of the middle row — because on a ring of
-thirty keys walked with two buttons the corner is the furthest possible place to
-start from. It then keeps its place, so repeating a character is one press rather
-than a walk back, and returns to the centre when a keyboard is opened or a symbol
-page is turned. When the letter it was resting on stops leading to a word, it
-moves to the nearest key that still does.
+The keyboards are QWERTY. The cursor opens on the middle key of the middle row —
+`g` on the letter keyboards, `5` on the number one — because on a ring of thirty
+keys walked with two buttons the corner is the furthest possible place to start
+from. It then keeps its place, so repeating a character is one press rather than
+a walk back, and returns to the centre when a keyboard is opened or a symbol page
+is turned. When the letter it was resting on stops leading to a word, it moves to
+the nearest key that still does.
 
 The suggestion order, the initially selected key and where a list has scrolled to
 are pure functions of what has been typed and chosen. None is randomised: no
 
@@ -291,19 +291,19 @@ static bool layout_is_well_formed(const char* layout)
     return row && seedtool_layout_center(layout) < seedtool_layout_keys(layout);
 }
 
-/* Every letter exactly once, and exactly one backspace: a row with a letter
- * dropped would make some BIP39 words impossible to type. Takes the layout
- * rather than naming one, because there are now two arrangements of these keys
- * and an alphabetical one typed out by hand is exactly where a missing letter
- * would come from. */
-static bool word_layout_is_complete(const char* const layout)
+static bool layouts_are_complete(void)
 {
     bool seen[128] = { false };
-    if (!layout_is_well_formed(layout) || seedtool_layout_keys(layout) != SEEDTOOL_LETTERS + 1) {
+
+    if (!layout_is_well_formed(SEEDTOOL_WORD_LAYOUT) || !layout_is_well_formed(SEEDTOOL_WORD_NUMBER_LAYOUT)
+        || seedtool_layout_keys(SEEDTOOL_WORD_LAYOUT) != SEEDTOOL_LETTERS + 1
+        || seedtool_layout_keys(SEEDTOOL_WORD_NUMBER_LAYOUT) != SEEDTOOL_DIGITS + 2) {
         return false;
     }
-    for (size_t i = 0; i < seedtool_layout_keys(layout); ++i) {
-        const unsigned char key = (unsigned char)seedtool_layout_key(layout, i);
+    /* Every letter exactly once, and exactly one backspace: a QWERTY row with a
+     * letter dropped would make some BIP39 words impossible to type. */
+    for (size_t i = 0; i < seedtool_layout_keys(SEEDTOOL_WORD_LAYOUT); ++i) {
+        const unsigned char key = (unsigned char)seedtool_layout_key(SEEDTOOL_WORD_LAYOUT, i);
         if (key != SEEDTOOL_KEY_BACKSPACE && (key < 'a' || key > 'z')) {
             return false;
         }
@@ -317,45 +317,6 @@ static bool word_layout_is_complete(const char* const layout)
             return false;
         }
     }
-    return true;
-}
-
-/* The pages of one arrangement must reach all 95 printable ASCII characters
- * between them. Checked per arrangement, not over both together: a character
- * present only in the QWERTY pages would leave a passphrase containing it
- * untypeable for a reader who had switched to alphabetical, which is the same
- * failure as dropping it outright for half the users. */
-static bool passphrase_pages_are_complete(const char* const* const pages)
-{
-    bool seen[128] = { false };
-    for (size_t page = 0; page < SEEDTOOL_PASSPHRASE_PAGES; ++page) {
-        if (!layout_is_well_formed(pages[page])) {
-            return false;
-        }
-        for (size_t i = 0; i < seedtool_layout_keys(pages[page]); ++i) {
-            seen[(unsigned char)seedtool_layout_key(pages[page], i)] = true;
-        }
-    }
-    for (unsigned char character = 0x20; character <= 0x7e; ++character) {
-        if (!seen[character]) {
-            return false;
-        }
-    }
-    return true;
-}
-
-static bool layouts_are_complete(void)
-{
-    bool seen[128] = { false };
-
-    if (!layout_is_well_formed(SEEDTOOL_WORD_NUMBER_LAYOUT)
-        || seedtool_layout_keys(SEEDTOOL_WORD_NUMBER_LAYOUT) != SEEDTOOL_DIGITS + 2) {
-        return false;
-    }
-    /* Both arrangements, or the one that is not the default ships unchecked. */
-    if (!word_layout_is_complete(SEEDTOOL_WORD_LAYOUT) || !word_layout_is_complete(SEEDTOOL_WORD_LAYOUT_ALPHA)) {
-        return false;
-    }
     /* The number keyboard's characters, not just its key count. enter_word_number
      * indexes reachable[key - '0'] for every key that is neither backspace nor
      * accept (seedtool_app.c), so a non-digit smuggled into this layout reads
@@ -377,11 +338,25 @@ static bool layouts_are_complete(void)
             return false;
         }
     }
-    /* Each arrangement's pages must reach all 95 printable ASCII characters, or
-     * a passphrase typed on an older build - or under the other setting -
-     * could not be retyped. Space repeats on every page on purpose. */
-    return passphrase_pages_are_complete(seedtool_passphrase_layouts)
-        && passphrase_pages_are_complete(seedtool_passphrase_layouts_alpha);
+    /* The passphrase pages together must still reach all 95 printable ASCII
+     * characters, or a passphrase typed on an older build could not be retyped
+     * on this one. Space repeats on every page on purpose. */
+    memset(seen, 0, sizeof(seen));
+    for (size_t page = 0; page < SEEDTOOL_PASSPHRASE_PAGES; ++page) {
+        const char* const layout = seedtool_passphrase_layouts[page];
+        if (!layout_is_well_formed(layout)) {
+            return false;
+        }
+        for (size_t i = 0; i < seedtool_layout_keys(layout); ++i) {
+            seen[(unsigned char)seedtool_layout_key(layout, i)] = true;
+        }
+    }
+    for (unsigned char character = 0x20; character <= 0x7e; ++character) {
+        if (!seen[character]) {
+            return false;
+        }
+    }
+    return true;
 }
 
 /* Type `digits` one key at a time and require that the keyboard offered every
 
@@ -49,9 +49,8 @@ _Static_assert(ADDRESS_SHOWN_ROWS <= ADDRESS_LIST_ROWS, "more address rows are s
 #define NAV_FOOTER "Up/Down move   BOTH select"
 #define ACK_FOOTER "BOTH continue   Up/Down back"
 
-/* Word entry keyboard: the letters plus backspace. Which arrangement is in use
- * is word_layout()'s business; the key count is the same either way, since
- * both hold every letter exactly once. */
+/* Word entry keyboard: the letters plus backspace. */
+#define WORD_LAYOUT SEEDTOOL_WORD_LAYOUT
 #define WORD_KEYS (SEEDTOOL_LETTERS + 1)
 
 /* Word number keyboard, for a backup that records numbers rather than words. */
@@ -86,17 +85,6 @@ const char* const seedtool_passphrase_layouts[PASSPHRASE_PAGES] = {
     ":;<=>?@\n[\\]^_`~\n{|} \b\t\r",
 };
 
-/* Alphabetical: the two letter pages reordered, the digit and symbol pages
- * shared with the array above rather than repeated - punctuation has no
- * alphabetical order, and two copies of the same page would be two places to
- * keep a character from going missing instead of one. */
-const char* const seedtool_passphrase_layouts_alpha[PASSPHRASE_PAGES] = {
-    "abcdefghij\nklmnopqrs \ntuvwxyz\b\t\r",
-    "ABCDEFGHIJ\nKLMNOPQRS \nTUVWXYZ\b\t\r",
-    "1234567890\n!\"#$%&'()\n*+,-./ \b\t\r",
-    ":;<=>?@\n[\\]^_`~\n{|} \b\t\r",
-};
-
 typedef void (*format_fn)(unsigned value, char* output, size_t output_len);
 
 static uint64_t last_action;
@@ -112,23 +100,6 @@ static bool chord_learned;
  * every boot - Origo has no persistence to save them to. */
 static bool orientation_flipped;
 static unsigned backlight_level = SEEDTOOL_DISPLAY_BRIGHTNESS_DEFAULT;
-/* Which arrangement the letter keyboards use. Settings is reachable only from
- * the Origo menu, and the wallet has no row that returns there, so this cannot
- * change while a seed is loaded: no session can have half a passphrase typed
- * on one arrangement and half on the other. Keys are found by character rather
- * than position in any case, so the same presses spell the same string either
- * way - but the ordering is what makes that a fact about the menu tree rather
- * than about the reader being careful. */
-static bool alphabetical_keys;
-
-/* The letter keyboards in whichever arrangement is set. The number keyboard
- * has no alphabetical form and is not routed through here. */
-static const char* word_layout(void) { return alphabetical_keys ? SEEDTOOL_WORD_LAYOUT_ALPHA : SEEDTOOL_WORD_LAYOUT; }
-
-static const char* passphrase_layout(const size_t page)
-{
-    return alphabetical_keys ? seedtool_passphrase_layouts_alpha[page] : seedtool_passphrase_layouts[page];
-}
 
 static const char* nav_hint(void) { return chord_learned ? "" : "   " NAV_FOOTER; }
 
@@ -830,7 +801,7 @@ static int enter_word(
     size_t stem_len = 0;
     /* The cursor opens at the centre and then keeps its place between letters,
      * so a word is not retyped from the far corner every time. */
-    size_t selected = seedtool_layout_center(word_layout());
+    size_t selected = seedtool_layout_center(WORD_LAYOUT);
     char title[24];
     (void)snprintf(title, sizeof(title), "Word %u/%u", (unsigned)position, (unsigned)total);
 
@@ -880,13 +851,13 @@ static int enter_word(
             bool enabled[WORD_KEYS] = { false };
             (void)seedtool_next_letters_in(allowed, stem, stem_len, letters);
             for (size_t i = 0; i < WORD_KEYS; ++i) {
-                const char key = seedtool_layout_key(word_layout(), i);
+                const char key = seedtool_layout_key(WORD_LAYOUT, i);
                 enabled[i] = key == SEEDTOOL_KEY_BACKSPACE || letters[key - 'a'];
             }
             selected = nearest_enabled(enabled, WORD_KEYS, selected);
             bool picked = false;
             while (!picked) {
-                seedtool_display_keyboard(title, stem_len ? stem : "-", word_layout(), enabled, selected, position, total);
+                seedtool_display_keyboard(title, stem_len ? stem : "-", WORD_LAYOUT, enabled, selected, position, total);
                 switch (wait_key()) {
                 case KEY_SELECT:
                     picked = true;
@@ -905,7 +876,7 @@ static int enter_word(
                     return -1;
                 }
             }
-            const char key = seedtool_layout_key(word_layout(), selected);
+            const char key = seedtool_layout_key(WORD_LAYOUT, selected);
             if (key == SEEDTOOL_KEY_BACKSPACE) {
                 erase = true;
             } else if (stem_len < SEEDTOOL_MAX_WORD_LEN) {
@@ -1422,10 +1393,10 @@ static int restore_mnemonic(const size_t count, char* mnemonic, const size_t mne
 static bool enter_passphrase_once(char* output, const size_t output_len)
 {
     size_t used = 0, page = 0;
-    size_t selected = seedtool_layout_center(passphrase_layout(0));
+    size_t selected = seedtool_layout_center(seedtool_passphrase_layouts[0]);
     output[0] = '\0';
     for (;;) {
-        const char* const layout = passphrase_layout(page);
+        const char* const layout = seedtool_passphrase_layouts[page];
         const size_t keys = seedtool_layout_keys(layout);
         if (selected >= keys) {
             selected = seedtool_layout_center(layout);
@@ -1454,7 +1425,7 @@ static bool enter_passphrase_once(char* output, const size_t output_len)
             page = (page + 1) % PASSPHRASE_PAGES;
             /* A new page is a new keyboard, so the cursor starts from its centre
              * rather than from wherever the page key happened to sit. */
-            selected = seedtool_layout_center(passphrase_layout(page));
+            selected = seedtool_layout_center(seedtool_passphrase_layouts[page]);
         } else if (pressed == SEEDTOOL_KEY_BACKSPACE) {
             if (used) {
                 output[--used] = '\0';
@@ -2776,24 +2747,16 @@ static void show_settings_menu(void)
             orientation_flipped ? "On" : "Off");
         format_brightness(brightness_fraction, sizeof(brightness_fraction));
         (void)snprintf(brightness_item, sizeof(brightness_item), "Brightness: %s", brightness_fraction);
-        char keyboard_item[24];
-        (void)snprintf(
-            keyboard_item, sizeof(keyboard_item), "Keyboard: %s", alphabetical_keys ? "ABC" : "QWERTY");
-        const char* items[] = { orientation_item, brightness_item, keyboard_item, "About", "Back" };
-        const int selected = choose_kept("Settings", items, 5, true, &cursor);
-        if (selected < 0 || selected == 4) {
+        const char* items[] = { orientation_item, brightness_item, "About", "Back" };
+        const int selected = choose_kept("Settings", items, 4, true, &cursor);
+        if (selected < 0 || selected == 3) {
             return;
         }
         if (selected == 0) {
             orientation_flipped = !orientation_flipped;
             seedtool_display_set_orientation(orientation_flipped);
         } else if (selected == 1) {
             show_brightness();
-        } else if (selected == 2) {
-            /* Toggled in place: two arrangements, and the row names the one in
-             * force, so a chooser would be a screen to say what the label
-             * says. Nothing to apply - the keyboards read it when they draw. */
-            alphabetical_keys = !alphabetical_keys;
         } else {
             (void)page_text("Safety",
                 "No seed is stored. No radio, wallet signing, PIN, OTA or serial RPC. Verify the firmware hash and "
 
@@ -6,11 +6,6 @@
  * prove they cover what they must — a rearranged layout that quietly dropped a
  * character would otherwise leave a passphrase impossible to retype. */
 #define SEEDTOOL_WORD_LAYOUT "qwertyuiop\nasdfghjkl\nzxcvbnm\b"
-/* The same keys in alphabetical order, offered from Settings for readers who
- * do not touch-type and find QWERTY a scatter to hunt through. Same 10/9/8
- * shape as the layout above, so it fits the three rows the keyboard is drawn
- * in without the renderer knowing either of them apart. */
-#define SEEDTOOL_WORD_LAYOUT_ALPHA "abcdefghij\nklmnopqrs\ntuvwxyz\b"
 /* Accept before Backspace, not after: nearest_enabled (seedtool_app.c) walks
  * the keyboard as a circular ring, so whichever of the two sits closer to the
  * digit row is what a disabled key's cursor snaps to first. Backspace is
@@ -20,13 +15,6 @@
 #define SEEDTOOL_WORD_NUMBER_LAYOUT "1234567890\n\r\b"
 #define SEEDTOOL_PASSPHRASE_PAGES 4
 extern const char* const seedtool_passphrase_layouts[SEEDTOOL_PASSPHRASE_PAGES];
-/* The alphabetical passphrase pages. Only the two letter pages differ; the
- * digit and symbol pages are the same strings, since there is no alphabetical
- * order for punctuation. Both arrays must still cover every printable ASCII
- * character between them - the self-test and the Python suite check each one
- * separately, because a page dropped from one arrangement and not the other
- * would leave a passphrase typeable only under the setting it was made with. */
-extern const char* const seedtool_passphrase_layouts_alpha[SEEDTOOL_PASSPHRASE_PAGES];
 
 void seedtool_run(void);
 
 
@@ -1,6 +1,5 @@
 import importlib.util
 from pathlib import Path
-import string
 import re
 import unittest
 
@@ -548,42 +547,17 @@ def test_firmware_emits_the_branch_it_is_tested_for(self):
             self.assertFalse(fragment in app, why)
 
     def test_passphrase_keyboards_cover_printable_ascii(self):
-        # Once per arrangement, not over both together: a character present
-        # only in the QWERTY pages would leave a passphrase containing it
-        # untypeable for a reader who had switched the keyboard to
-        # alphabetical, which is the same failure as dropping it outright for
-        # half the users. The firmware's own self-test asserts the same thing
-        # against the compiled arrays; this reads the source, so the two agree
-        # only if the definition really is what ships.
         source = (Path(__file__).parents[1] / "main/seedtool_app.c").read_text()
-        arrays = {
-            "seedtool_passphrase_layouts[PASSPHRASE_PAGES] = {": "QWERTY",
-            "seedtool_passphrase_layouts_alpha[PASSPHRASE_PAGES] = {": "alphabetical",
-        }
-        for anchor, which in arrays.items():
-            self.assertIn(anchor, source, f"the {which} passphrase array is not where this test looks for it")
-            layouts = source.split(anchor, 1)[1].split("};", 1)[0]
-            covered = set()
-            for line in layouts.splitlines():
-                line = line.strip()
-                if not line.startswith('"'):
-                    continue
-                body = line[1 : line.rindex('"')]
-                covered.update(body.replace("\\n", "").replace("\\b", "").replace("\\t", "").replace("\\r", "")
-                               .replace('\\"', '"').replace("\\\\", "\\"))
-            self.assertEqual(covered, {chr(c) for c in range(0x20, 0x7F)}, f"the {which} pages do not cover ASCII")
-
-    def test_word_keyboards_hold_every_letter(self):
-        # Both arrangements of the letter keyboard, from the header where they
-        # are defined. A layout with a letter missing makes some BIP39 words
-        # impossible to type - the reader would reach for a key that is not
-        # there and have no way to finish a restore.
-        header = (Path(__file__).parents[1] / "main/seedtool_app.h").read_text()
-        for name in ("SEEDTOOL_WORD_LAYOUT", "SEEDTOOL_WORD_LAYOUT_ALPHA"):
-            match = re.search(rf'#define {name} "([^"]*)"', header)
-            self.assertIsNotNone(match, f"{name} is not defined as a plain string literal")
-            keys = match.group(1).replace("\\n", "").replace("\\b", "")
-            self.assertEqual(sorted(keys), sorted(string.ascii_lowercase), f"{name} is not the 26 letters exactly once")
+        layouts = source.split("passphrase_layouts[PASSPHRASE_PAGES] = {", 1)[1].split("};", 1)[0]
+        covered = set()
+        for line in layouts.splitlines():
+            line = line.strip()
+            if not line.startswith('"'):
+                continue
+            body = line[1 : line.rindex('"')]
+            covered.update(body.replace("\\n", "").replace("\\b", "").replace("\\t", "").replace("\\r", "")
+                           .replace('\\"', '"').replace("\\\\", "\\"))
+        self.assertEqual(covered, {chr(c) for c in range(0x20, 0x7F)})
 
     def test_logo_asset_matches_its_header(self):
         # The artwork is generated by an authoring tool that needs Pillow, but