diff --git a/developer/docs/help/guides/develop/index.md b/developer/docs/help/guides/develop/index.md
index 8d8490c42c1..d53a5274316 100644
--- a/developer/docs/help/guides/develop/index.md
+++ b/developer/docs/help/guides/develop/index.md
@@ -2,6 +2,8 @@
title: Developing Keyboards
---
+[Keyman Developer Walkthrough](walkthrough)
+
[Keyman keyboard tutorial](tutorial)
[An advanced keyboard development example](advanced-keyboard-development-example)
@@ -16,4 +18,4 @@ title: Developing Keyboards
------------------------------------------------------------------------
-[Keyman Developer 16 Tutorial](https://lingtran.net/Keyman-Developer-16-Tutorial) (external on Lingtran.net)
\ No newline at end of file
+[Keyman Developer 16 Tutorial](https://lingtran.net/Keyman-Developer-16-Tutorial) (external on Lingtran.net)
diff --git a/developer/docs/help/guides/develop/walkthrough/00-introduction.md b/developer/docs/help/guides/develop/walkthrough/00-introduction.md
new file mode 100644
index 00000000000..0577ecef535
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/00-introduction.md
@@ -0,0 +1,87 @@
+---
+title: Introduction
+---
+
+
+
+ Introduction to the [Keyman Developer Walkthrough](.).
+
+ [Next: Part 1 - Creating a Keyboard Project →](01-creating-keyboard-project)
+
+
+## Step-by-Step
+
+The Step-by-Step tutorial starts with an introduction to the Keyman Developer program and instructions on installing it. Then use the link to advance to the next topic and complete the Step-by-Step section there. Continue on through all the topics, completing the Step-by-Step section and moving on to the next topic by using the link at the end of each Step-by-Step section.
+
+If you encounter unfamiliar terms, please consult the [glossary](glossary).
+
+### Introducing Keyman Developer
+
+Keyman Developer is a powerful tool you can use to create custom software keyboards optimized to type in any language you choose. Keyboard authors can distribute their work for desktop, web, tablet and phone, enabling global communities to quickly benefit from keyboards made for their own language.
+
+Keyboards created with Keyman Developer can be used on Windows, macOS, Linux, iOS, Android, and the web.
+
+This tutorial focuses on the Keyman Developer IDE (integrated development environment).
+Currently this software is Windows-only, although the command line tools it uses can run on other platforms (such as Linux and macOS).
+
+### Installing Keyman Developer
+
+Keyman Developer is completely free to download and use. You can download it from [https://keyman.com/developer/download](https://keyman.com/developer/download).
+
+On the downloads page, just click the big green “Download Now” button to get the latest version of Keyman. Once you have it, run the `keymandeveloper-a.b.c.exe` file you’ve downloaded. The numbers following “keymandeveloper” indicate which version of Keyman Developer you are installing; you can also see the Keyman Developer version in the main installer window, or after installation, in the Help/About dialog.
+
+After installing Keyman Developer, you should be able to run it on your computer and begin creating projects immediately.
+
+Note that Keyman Developer is a separate app from Keyman, which is the app that lets you use any keyboard created with Keyman Developer.
+In order to use the keyboard you create with Keyman Developer, you'll need to have the Keyman app installed on your computer or device.
+Keyman is available on the following platforms: Windows, macOS, Linux, iOS, Android, and the web.
+
+The Keyman Developer icon  is a faded version of the Keyman icon .
+
+
+To continue the Step-by-Step tutorial move to the next page: [Part 1 - Creating a Keyboard Project](01-creating-keyboard-project)
+
+
+---
+
+
+## Engaging with the Keyman Community and Resources
+
+Keyman Developer also has an active community and documentation for each major release of the app. If you need any additional help, be sure to visit the following resources for information:
+
+### Keyman Community Forum
+
+Ask questions and talk with other keyboard authors on the [Keyman Community Forum](https://community.software.sil.org/c/keyman/19)
+
+### Keyman online help
+
+[Keyman Developer Language Guide](https://help.keyman.com/developer/language/guide/)
+
+Information about the general structure and concepts of the Keyman language.
+
+[Keyman Developer Language Reference](https://help.keyman.com/developer/language/reference/)
+
+Reference for keywords and other components of the Keyman language.
+
+[Keyman Developer Training Videos](https://help.keyman.com/developer/videos)
+
+Videos from past Keyman Developer workshops hosted by the team.
+
+### Keyman Blog
+
+Read up on Keyman’s latest releases and patch notes on the [Keyman Blog](https://blog.keyman.com/).
+
+### Keyman GitHub repositories
+
+Keyman uses a number of [Github](https://github.com/keymanapp) repositories to store source code, keyboards, lexical models and documentation.
+There is also a mechanism for reporting problems. [Keyman Bug Reports](https://github.com/keymanapp/keyman/issues)
+
+Report Keyman software bugs and issues here.
+
+> [!NOTE]
+> GitHub issues are not the best place to ask for help or support questions. The Keyman community forum is a better place to ask for help with keyboard development. Think you’ve found a Keyman bug or a problem with a specific keyboard? Describe what you’ve found on the Keyman community forum and ask whether to report a bug.
+
+
+ [Next: Part 1 - Creating a Keyboard Project →](01-creating-keyboard-project)
+
+
diff --git a/developer/docs/help/guides/develop/walkthrough/01-creating-keyboard-project.md b/developer/docs/help/guides/develop/walkthrough/01-creating-keyboard-project.md
new file mode 100644
index 00000000000..1e5c8f8078f
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/01-creating-keyboard-project.md
@@ -0,0 +1,200 @@
+---
+title: Creating a Keyboard Project
+---
+
+
+
+ Part 1 of the [Keyman Developer Walkthrough](.).
+
+ [← Introduction](00-introduction) [Part 2 - Designing a Desktop Layout →](02-designing-desktop-layout)
+
diff --git a/developer/docs/help/guides/develop/walkthrough/02-designing-desktop-layout.md b/developer/docs/help/guides/develop/walkthrough/02-designing-desktop-layout.md
new file mode 100644
index 00000000000..ad87d0052d4
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/02-designing-desktop-layout.md
@@ -0,0 +1,149 @@
+---
+title: Designing a Desktop Layout
+---
+
+
+
+Part 2 of the [Keyman Developer Walkthrough](.).
+
+[← Part 1 - Creating a Keyboard Project](01-creating-keyboard-project) [Part 3 - Creating a Desktop Layout →](03-creating-desktop-layout)
+
+
+## Step-by-Step
+
+Dagbani uses the characters **ɛ ɔ ŋ ɣ ʒ** and the corresponding capital letters **Ɛ Ɔ Ŋ Ɣ Ʒ**.
+Rather than try to assign each of these characters to a key on the physical keyboard,
+we will use a pair of keys to produce each of these characters.
+We’ll start with the default QWERTY layout and add rules so that typing ; followed by e will produce “ɛ”,
+; followed by o will produce “ɔ”, etc.
+
+This Step-by-Step tutorial won’t be using the visual layout features of Keyman Developer for creating the desktop keyboard.
+
+
+To continue the Step-by-Step tutorial move to the next page: [Part 3 - Creating a Desktop Layout](03-creating-desktop-layout)
+
+
+---
+
+## Defining a List of Keys
+
+After you have gathered some basic information about the language for which you are creating a keyboard,
+along with the needs of the people who will be using it,
+the next step is to figure out what format will suit the needs of your keyboard’s users and be most familiar to them.
+
+Keyman is available across [many different platforms](https://help.keyman.com/products/), so consider whether you need to design keyboard formats for computer keyboards, phones, or tablets.
+Keyman makes it easy to keep designs consistent across these types, but it is also possible to design each layout individually.
+
+Make a list of all of the characters that your language uses in its written form. For example, the Dagbani language uses the following characters, in addition to a standard A-Z alphabet:
+
+| Name | Character |
+|--------|-------------|
+| Open e | ɛ Ɛ |
+| Open o | ɔ Ɔ |
+| Eng | ŋ Ŋ |
+| Gamma | ɣ Ɣ |
+| Ezh | ʒ Ʒ |
+
+
+This is a simple example. Some languages may have extensive punctuation marks, special glyphs, or use a non-Latin alphabet.
+Be thorough in your list so that you are not missing any keys when you design your keyboard.
+
+Note that Unicode contains some characters that are quite similar, so verify the Unicode values you are using.
+For example, this example uses `ɔ` (`U+0254`) "open o", not `ↄ` (`U+2184`) "reversed c".
+
+## Creating a Visual Layout
+
+Once you know what keys your keyboard will need, it is time to determine how to arrange them.
+The best way to do this varies widely depending on your language.
+If users have been typing with a certain keyboard layout and are familiar with it, that might provide a good starting point.
+Research existing keyboard layouts and build off of them where possible.
+You may want to use the keyboard layout common in the area (QWERTY in English-speaking areas, AZERTY in French-speaking areas, etc.) as a basis for your keyboard.
+
+For visual mapping, this can be done with tools as rudimentary as a pen and paper, but Keyman Developer also offers a handy visual keyboard for design purposes.
+
+Navigate to your `.kpj` file, go to the `Keyboards` tab, and open your `.kmn` file. This is where your keyboard’s information lies, as well as the code that makes it work.
+
+You can read more about the `.kmn` file type in the [official Keyman documentation](../../../reference/file-types/kmn).
+
+Inside your `.kmn` file, select the `Layout` tab on the left.
+For a new project, the `Design` tab (at the bottom) should already be selected.
+This is a visual representation of your desktop keyboard.
+Note that once you add rules using the `Code` tab (as, for example, in the Dagbani keyboard developed in the Step-by-Step tutorial),
+Keyman Developer no longer offers the `Design` tab option.
+
+By default, Keyman Developer uses a QWERTY layout, but it is very easy to remap this.
+If you are using a non-QWERTY base keyboard layout, select each key and press the corresponding key on your keyboard.
+This will automatically change the keyboard code to type the key you have selected.
+
+To access the characters needed for your language, you can paste the Unicode characters you need into the two fields at the bottom.
+`Unicode Character Value(s)` is for the Unicode value (for example, `U+0061`) of the character you would like the keyboard to type,
+while `Output character(s)` is for the character the keyboard will produce (for example, `a`).
+Typing in either field will automatically populate the other one with matching information, so it does not matter which one you use.
+
+If a key needs to produce multiple characters (for example, a key that produces `ch`), you can place multiple characters in the `Output character(s)` field.
+
+After some research, you may find that your language has more characters than there are keys on the keyboard.
+This is especially true of languages with many glyphs, combined characters, or diacritical marks on letters.
+In this case, it is especially helpful to follow a default keyboard layout for your base design,
+and plan out special keystrokes so users can type the characters that are not immediately available on the keyboard.
+Try to ensure that the most essential keys (usually the ones used to type the alphabet) are available before worrying about adding less frequent characters.
+
+## Planning Keystrokes
+
+Once you know what you want your keyboard layout to look like, you can begin planning what keystrokes will be needed.
+You can specify rules so that Keyman will transform typed keystroke combinations into the desired characters.
+
+For example, you can use the keystrokes `'` + `e` to produce the character `é` rather than dedicating a separate key to `é`.
+
+When choosing keys to use for characters you are adding to your keyboard, be careful not to block the normal function of those keys.
+In the above example, consider whether there would be a need to allow someone to type an actual apostrophe.
+
+To easily plan keystrokes, you can reference the list you made of the special characters needed for your language. Disregarding the letters and symbols already included in the base layout you designed, how many more do you need to fit onto your keyboard? You can utilize the number row, punctuation characters, deadkeys, and the Right-Alt, Shift, or Shift+Right-Alt modifier keys in your layout. Remember to make them as intuitive as possible for users. If the key combination is too complex, it will slow users down significantly when attempting to type.
+
+Remember to include capital letters in your list! Keyman treats these separately, so you will have to code uppercase and lowercase letters separately.
+
+Here’s an example of how to list your keystrokes. (This can also be reused when you document your keyboard’s layout later!) If you want to be thorough, you can also list the Unicode values for each character to avoid any confusion about which character is used.
+
+| Base | Modifier | Result |
+|------|----------|--------|
+| a | ^ | â |
+| e | ^ | ê |
+| i | ^ | î |
+| o | ^ | ô |
+| u | ^ | û |
+
+Once you have planned the visual layout of your keyboard and determined how to assign the rest of the keys on the keyboard, it’s time to begin coding.
+If your layout is simple enough that you do not need to program additional keys, you do not need to worry as much about the next section.
+In some cases, using Keyman’s visual editor is enough for a desktop keyboard.
+
+> [!NOTE]
+> Once you begin adding multi-part rules, the keyboard becomes too complex to modify with the visual layout tools, so it is best to do any visual layout work first using the `Design` tab, then add the additional rules using the `Code` tab.
+
+### Deadkeys
+
+The Step-by-Step tutorial uses `;` plus another key (`e E o O n N g G z Z`) to produce the ten additional characters (`ɛ Ɛ ɔ Ɔ ŋ Ŋ ɣ Ɣ ʒ Ʒ`).
+When the “;” is typed it appears on the screen.
+When one of the ten keys is typed directly after the “;” then the “;” is replaced by the corresponding additional characters.
+
+In contrast to this approach, the “deadkey” alternative could be used.
+A deadkey produces no display when typed, but modifies the keystroke that follows it.
+To use a deadkey approach for the Dagbani keyboard, we would use a rule to convert the `;` keystroke into a deadkey, which will not display on the screen, but will then be used to create the appropriate additional character when one of the ten characters is typed.
+Some European language keyboards (French, for example) use deadkeys, so users in French-speaking countries may already be familiar with their use.
+
+While useful in some situations, deadkeys can also confuse users.
+In this example, when the `;` key is pressed, it will not produce anything.
+If you include deadkeys in your keyboard, be sure to document them well so that users understand what is happening when they type them.
+
+For more information, see the Keyman documentation for the [`deadkey()` statement](https://help.keyman.com/developer/language/reference/deadkey).
+
+### Reassigning keys
+
+But consider the Dagbani example again.
+Suppose we don’t want to have to type two keys to obtain each of these additional characters (as if they were somehow inferior to the other twenty-six).
+We could choose to design the keyboard so that typing `[ { ] } - _ = + \ |` will produce `ɛ Ɛ ɔ Ɔ ŋ Ŋ ɣ Ɣ ʒ Ʒ`, respectively.
+That could be done with the `Design` mode using the visual layout tools, or by adding rules.
+We would then want to add rules to allow the user to type the characters that were on the ten keys that we repurposed to type the additional characters, for example type the `;` key then the `[` key to get an actual `[` character.
+
+
+[← Part 1 - Creating a Keyboard Project](01-creating-keyboard-project) [Part 3 - Creating a Desktop Layout →](03-creating-desktop-layout)
+
\ No newline at end of file
diff --git a/developer/docs/help/guides/develop/walkthrough/03-creating-desktop-layout.md b/developer/docs/help/guides/develop/walkthrough/03-creating-desktop-layout.md
new file mode 100644
index 00000000000..0e28aa51739
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/03-creating-desktop-layout.md
@@ -0,0 +1,335 @@
+---
+title: Creating a Desktop Layout
+---
+
+
+
+Part 3 of the [Keyman Developer Walkthrough](.).
+
+[← Part 2 - Designing a Desktop Layout](02-designing-desktop-layout) [Part 4 - Using the Debugger →](04-using-debugger)
+
+[← Part 2 - Designing a Desktop Layout](02-designing-desktop-layout) [Part 4 - Using the Debugger →](04-using-debugger)
+
\ No newline at end of file
diff --git a/developer/docs/help/guides/develop/walkthrough/04-using-debugger.md b/developer/docs/help/guides/develop/walkthrough/04-using-debugger.md
new file mode 100644
index 00000000000..a86917754ed
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/04-using-debugger.md
@@ -0,0 +1,39 @@
+---
+title: Using the Debugger
+---
+
+
+
+Part 4 of the [Keyman Developer Walkthrough](.).
+
+[← Part 3 - Creating a Desktop Layout](03-creating-desktop-layout) [Part 5 - Designing a Touch Layout →](05-designing-touch-layout)
+
+
+## Step-by-Step
+
+- From the `Debug` menu, select the `Start Debugging` menu item. Some extra fields will be shown.
+- Type ;. The Keystroke log will show `;`. The display to the right has two sections. The upper section shows the characters displayed on the screen. The lower section shows a table of characters and their Unicode values. Here the upper section will show `;` and the lower section will show `;` and `U+003B`. (U+003B is the Unicode value for “;”.)
+- Type e. The Keystroke log will show `;` and `E`. The display to the right will show `ɛ` in the upper section and `ɛ` and `U+025B` in the lower section. (U+025B is the Unicode value for “ɛ”.)
+- Type ; then E. The Keystroke log will show `;` `E` `;` `Shift+E`. The display to the right will show `ɛƐ` in the upper section and `ɛ` and `U+025B` then `Ɛ` and `U+0190` in the lower section.
+
+
+
+- From the `Debug` menu, select the `Stop Debugger` menu item.
+
+
+To continue the Step-by-Step tutorial move to the next page: [Part 5 - Designing a Touch Layout](05-designing-touch-layout)
+
+
+---
+
+## Running the Debugger
+
+See the [debugger documentation](../../../context/debug) for more information on running the debugger.
+
+## Interpreting Errors
+
+When compiling your Keyman code, Keyman Developer will report any errors, warnings and hints in the box at the bottom of the window. The message will give a short description of what the compiler found was wrong along with the line number of where the problem was detected. The error, warning or hint has an identifier (“KM02033” for example). This identifier is a link to a more detailed description.
+
+
+[← Part 3 - Creating a Desktop Layout](03-creating-desktop-layout) [Part 5 - Designing a Touch Layout →](05-designing-touch-layout)
+
\ No newline at end of file
diff --git a/developer/docs/help/guides/develop/walkthrough/05-designing-touch-layout.md b/developer/docs/help/guides/develop/walkthrough/05-designing-touch-layout.md
new file mode 100644
index 00000000000..acc2f9d6d53
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/05-designing-touch-layout.md
@@ -0,0 +1,62 @@
+---
+title: Designing a Touch Layout
+---
+
+
+
+Part 5 of the [Keyman Developer Walkthrough](.).
+
+[← Part 4 - Using the Debugger](04-using-debugger) [Next: Part 6 - Creating a Touch Layout →](06-creating-touch-layout)
+
+
+## Step-by-Step
+
+In the Dagbani keyboard, `;e` was selected as the way to generate the character `ɛ` , but having to type a `;` on a touch screen followed by `e` to get the `ɛ` character would be tedious. It is preferable to assign `ɛ` as a longpress key on the `e` key.
+
+For the Step-by-Step tutorial, the design decisions have been made for you. We will be adding ten longpress keys to the default touch layout.
+
+
+To continue the Step-by-Step tutorial move to the next page: [Part 6 - Creating a Touch Layout](06-creating-touch-layout)
+
+
+---
+
+## Creating a Basic Visual Layout
+
+Adding a touch keyboard layout to your keyboard project allows a user to input text on touch devices, such as tablets and phones.
+
+A desktop keyboard is dependent on the physical keyboard. With a touch layout, you will be displaying the keys on the device for the user to see and interact with.
+
+There is some flexibility in arranging keys, though adding too many keys to a row or too many rows to a layout will make the keyboard difficult to use. Additionally, there are options for activating a key:
+
+- touch, that is touch and release the key
+- longpress, that is touch and hold the key, then select a character from a popup menu
+- flick, that is touch the key and slide in one of eight directions
+- mulitap, that is rapidly touch and release the key: one tap produces the base key, two taps produces the first multi-tap key, three produces the second multi-tap key, etc.
+
+## Planning Keystrokes
+
+You’ll want to plan your touch layout just as you did for the desktop (physical keyboard) layout. There is some value in making the touch layout similar to the desktop layout, but the primary concern is making it easy to use.
+
+Another possibility, if a small number of additional characters are needed, is to give each of them their own keys. This is possible since a touch layout is displayed on the screen.
+
+If you use Keyman Developer’s New Project feature, a touch layout is added automatically.
+
+## Using the desktop layout as a basis for the touch layout
+
+There are advantages to basing the touch layout on the desktop layout.
+Users who switch between the two may benefit from the similarity.
+In addition, your touch layout may be able to take advantage of the logic in the desktop layout code you’ve already created.
+Specifically, if the `ID` field for a key in the touch layout begins with `K_` then Keyman treats the key as the same as the corresponding desktop key (as modified by the active layer of the touch layout)
+according to the rules that are in the .kmn file.
+
+If you establish the desktop keyboard layout and create the On-Screen Keyboard,
+you can switch to the Touch Editor and import from the OSK.
+This will provide a “tablet” layout, with “default” and “shift” layers.
+To switch to a “phone” layout, select the basic template, which rearranges the keys and moves some to a “numeric” layer.
+(For more details, see the next topic.)
+The result will need to be reviewed and tested, but using this approach may save you some time.
+
+
+[← Part 4 - Using the Debugger](04-using-debugger) [Part 6 - Creating a Touch Layout →](06-creating-touch-layout)
+
\ No newline at end of file
diff --git a/developer/docs/help/guides/develop/walkthrough/06-creating-touch-layout.md b/developer/docs/help/guides/develop/walkthrough/06-creating-touch-layout.md
new file mode 100644
index 00000000000..b4fab0a85c0
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/06-creating-touch-layout.md
@@ -0,0 +1,154 @@
+---
+title: Creating a Touch Layout
+---
+
+
+
+Part 6 of the [Keyman Developer Walkthrough](.).
+
+[← Part 5 - Designing a Touch Keyboard](05-designing-touch-layout) [Part 7 - Writing Keyboard Documentation Files →](07-writing-keyboard-documentation)
+
+
+## Step-by-Step
+
+- Click on the `Touch Layout` tab on the left. The touch layout is shown, with the `q` key selected and details about the selected key shown on the right. Farther to the right is the Character Map which will be used in a later step. If the Character Map is not displayed, use the `View` menu, `Character Map` menu item to turn on the display.
+
+
+
+
+
+- Click on the `e` key to select it and display its information.
+- Click on the `+` button in the `Longpress Keys` section. A new key is added (and the `+` button moved). The new key is given an arbitrary ID (`T_new_103` in this example).
+
+
+
+- Note that information about this key is placed to the right.
+
+
+
+- We’ve added this longpress key to the `e` key. Now we want to make it (1) display `ɛ` so users will see what the key will produce and (2) change the ID so that activating this longpress key will generate `ɛ`. Find the `ɛ` character in the Character Map and drag it to the `Text` field. This will put `ɛ` in the `Text` field, `U+025B` in the `Text Unicode` field and `U_025B` in the `ID` field.
+
+
+
+Note: To find the `ɛ` character in the Character Map, you can use the scroll bar on the right to scroll down to `U+025B`. Alternatively, you can type `25B` in the `Filter by` field at the bottom of the character map.
+
+- Click on the `o` key in the keyboard layout. This will select the `o` key and display its information.
+- Click on the `+` button in the `Longpress Keys` section. A new key is added (and the `+` button moved). The new key is given an arbitrary ID (`T_new_104` in this example). In addition, information about this key is placed to the right.
+- We’ve added this longpress key to the `o` key. Now we want to make it (1) display `ɔ` and (2) change the ID. We could use the same procedure as in the previous steps, but this time we’ll use a different method. Click in the `Text Unicode` field and type `U+0254` (this will also place `ɔ` in the `Text`, but will not change the `ID` field).
+- Click in the `ID` field and replace the generated ID (`T_new_104` in this example) with `U_0254`. (Note that the ID uses an underscore rather than a plus sign.)
+
+
+
+- Add three longpress keys using one of the above methods:
+ - on the `n` key, add a longpress key for `ŋ` = U+014B
+ - on the `g` key, add a longpress key for `ɣ` = U+0263
+ - on the `z` key, add a longpress key for `ʒ` = U+0292
+- You've made these five changes on the `default` layer. Now we need to switch to the `shift` layer. Select the drop-down menu under the `Layer` heading and select `shift`.
+
+
+
+- With the capital letters displayed on the keyboard, add five longpress keys using one of the above methods:
+ - on the `E` key, add a longpress key for `Ɛ` = U+0190
+ - on the `O` key, add a longpress key for `Ɔ` = U+0186
+ - on the `N` key, add a longpress key for `Ŋ` = U+014A
+ - on the `G` key, add a longpress key for `Ɣ` = U+0194
+ - on the `Z` key, add a longpress key for `Ʒ` = U+01B7
+- Select the `Build` tab on the left and then the `Compile Keyboard` button. You should see a `dagbani.kmn built successfully` message. If you don’t, examine the error messages to see where the problem lies.
+
+### Testing the touch layout
+
+Keyman Developer provides a way to test your keyboard in a web browser.
+- On the Build tab, you can select `Test Keyboard on web` followed by `Open in browser`.
+- Select the `Keyboard` drop-down menu, then select the `dagbani` keyboard. You should have a display that looks like:
+
+
+
+- The display defaults to the Windows keyboard. You can type on the computer keyboard or use your mouse to click on the keys. Enter ;e;o;g;z;n and you should have the following result.
+
+
+
+- Select the `Device` drop-down menu and select `iPhone 5S`. The display will change to show a simulated phone screen with your touch layout. You can use your mouse to click on the keys. To access the longpress keys, click and hold, then slide the mouse to select the letter on the longpress key. Try this with the five longpress keys on `e` `o` `g` `z` and `n`. (There’s a dot in the upper right corner of the key to indicate the presence of at least one longpress key.) The period (full stop) also has a longpress menu that allows various punctuation characters to be entered.
+
+
+
+- If you click on the `Shift` key, the display changes to the `shift` layer and you can enter characters from that layer.
+- When you are finished testing, you can close the browser tab.
+
+
+To continue the Step-by-Step tutorial move to the next page: [Part 7 - Writing Keyboard Documentation Files](07-writing-keyboard-documentation)
+
+
+---
+
+## Configuring a Touch Layout
+
+There are a number of items to the left of the keyboard layout that allow you to configure the touch layout and select what portions to display. If you have done the Step-by-Step tutorial for this page, you’ve seen how to choose a different layer from the drop-down menu under the “Layer” heading.
+
+### Template and Import from On Screen buttons
+
+When you are initially creating a touch layout, it may be helpful to start from the On-screen Keyboard you created for the desktop layout and/or from a template. Since using these buttons overwrites the existing touch layout, you’ll only want to use them at the beginning of your touch layout work.
+
+- `Import from On Screen` will create a `tablet` layout with `default` and `shift` layers from the On Screen keyboard for the `desktop` layout.
+- `Template`, then `template-basic` will distribute the keys for a `phone` layout with `default`, `shift` and `numeric` layers.
+- `Template`, then `template-latin` will rearrange the keys for a `phone` layout with `default`, `shift`, `numeric` and `symbol` layers. It includes longpress keys for accented Latin characters. An identical `tablet` layout is also created. See the note under `Choosing the Platform` below.
+- `Template`, then `template-traditional` will distribute the keys for a `phone` layout with `default`, `shift` and `numeric` layers, but also make a `tablet` layout based on the desktop one.
+
+### View Options
+
+By default the list of modifier-based layers is limited to the most commonly used desktop layers
+(`default`, `shift`, `rightalt`, `rightalt-shift`, `caps`).
+Selecting this option will extend that list to include layer names like `rightctrl-rightalt-shift`.
+It doesn’t add these layers to the layout, but merely adds them to the list of predefined names that you could choose to use.
+It’s likely you will never want to choose this option.
+
+You can always choose the `(custom)` option and enter any valid name (limited to A-Z, a-z, 0-9, underscore and hyphen).
+
+### Choosing the Platform
+
+ Options are “phone”, “tablet”, “desktop”
+
+- A “phone” layout typically has four rows (counting the row with the space bar) with ten or eleven keys per row. A “tablet” layout typically has five rows with thirteen or fourteen keys per row
+- Don’t include both a “phone” layout and a “tablet” layout unless those layouts are different. Keyman will use a “phone” layout on a tablet if no “tablet” layout exists and use a “tablet” layout on a phone if no “phone” layout exists. Thus it is twice the work (or more) to maintain identical “phone” and “tablet” layouts.
+- The “desktop” layout option is not currently used. It is intended for Windows touch screens but currently Windows does not make it feasible to support custom touch keyboards.
+
+### Adjusting Keyboard Layers
+
+A keyboard layout generally includes multiple layers. (See description of [Keyboard Layer](glossary) in the glossary.) The Touch Layout editor displays one layer at a time. The “default” layer is the layer that is presented when no key (such as Shift) has been used to activate another layer.
+
+In the Touch Layout editor you switch layers using the drop-down menu described below. In addition, you need to make sure that each of the layer activation keys specifies in the “Next Layer” field which layer is to be activated. For example, on the default layer, the Shift key has “shift” in the “Next Layer” field, and on the shift layer, the Shift key has “default” in the “Next Layer” field.
+
+Under the “Layer” heading you can:
+
+
+
+- choose an existing layer from the drop-down menu to display that layer
+- choose the “+” button to add a new layer (either choosing a name from the “Modifier-based layer” list, or choosing “(custom)” from that list and entering a name in the “Name” field)
+- choose the “-” button to delete the layer whose name is displayed
+- choose the “Edit” button to change the name of the current layer
+
+## Longpress, Flicks and Multitap Gestures
+
+If you completed the Step-by-Step tutorial for this topic, you added longpress keys to certain base keys in the touch layout by clicking on the “+” button in the “Longpress” section and supplying the needed information to define the longpress key.
+
+Similarly, if you wish to add a flick gesture, choose one of the eight “+” buttons in the “Flicks” section — the one that corresponds to the direction that you want to assign for this flick gesture — and click on it. Then supply the needed information to define that flick gesture.
+
+A multitap gesture is defined in a similar way. Click on the “+” button in the “Multitap” section and add the information to define the multitap key. The base key will respond as normal for a single tap, the first multitap key listed will respond to a double tap, the second multitap key to a triple tap, etc.
+
+Use care when combining different kinds of gestures as some of them may conflict.
+
+- Don’t use too many keys in a longpress menu
+- Don’t use too many flicks. For example, NE, N, and NW flicks are easily confused
+- When using north-flicks and longpress, be aware that the north-flick shortcut for the default longpress will be blocked
+- Don’t assign too many multitap keys to the same base key
+
+## Reference
+
+See [Touch layout editor documentation](../../../context/keyboard-editor#toc-touch-layout-tab) for more details.
+
+## Testing Touch Keyboards
+
+See the end of the Step-by-Step section above for a description of how to use Keyman Developer to test your touch layout in a browser window. It’s also possible to transfer the .kmp file to a touch device and install the keyboard there for testing.
+
+
+[← Part 5 - Designing a Touch Keyboard](05-designing-touch-layout) [Part 7 - Writing Keyboard Documentation Files →](07-writing-keyboard-documentation)
+
\ No newline at end of file
diff --git a/developer/docs/help/guides/develop/walkthrough/07-writing-keyboard-documentation.md b/developer/docs/help/guides/develop/walkthrough/07-writing-keyboard-documentation.md
new file mode 100644
index 00000000000..13d70cb3175
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/07-writing-keyboard-documentation.md
@@ -0,0 +1,113 @@
+---
+title: Writing Keyboard Documentation
+---
+
+
+
+Part 7 of the [Keyman Developer Walkthrough](.).
+
+[← Part 6 - Creating a Touch Layout](06-creating-touch-layout) [Part 8 - Preparing a Keyboard Package →](08-preparing-keyboard-package)
+
+
+## Step-by-Step
+
+- Click on the `dagbani.kpj` tab at the top (just under the menu and toolbar), then click on the `Distribution` tab at the bottom.
+
+
+
+- There are a number of files that provide information about the keyboard. Some are for the keyboard author and for maintainers of the Keyman keyboards repository, some are to help users of the keyboard understand how it works.
+
+
+
+- In the list of files, click on the `HISTORY.md` one to open that file. The file will open in a text editor and show you the information that you entered when setting up the keyboard project, specifically version 1.0, today’s date, and the author’s name. Since this information is correct, you can close this file by clicking on the red “X” on the righthand side of the `HISTORY.md` tab at the top of the text area.
+- Click on `LICENSE.md` to open that file. This has been filled out using the Full copyright information you provided. Close the file by clicking on the red “X”.
+- Click on `README.md` to open that file. This has been initialized for you. Close the file by clicking on the red “X”. (This file provides a place for information about the design of the keyboard that would be useful to a keyboard author wanting to update the keyboard or use it as a basis for a new keyboard. Don’t confuse it with the next item which is information for the keyboard user.)
+- Click on `source\readme.htm` to open that file. This is the information displayed to the user just before the keyboard is installed. It has the description supplied when setting up the keyboard project. Other helpful information can be added, but the file should be kept as short as possible. Close the file.
+- Click on `source\welcome.htm` to open that file. This is the help information that is packaged with the keyboard and available to the user. It should contain enough information so that the user can learn to type with the keyboard. This can be in the form of:
+ - image files referenced by the welcome.htm file, or
+ - a chart (in HTML format) showing how two keystrokes produce a character, or
+ - descriptive text in the HTML file, or
+ - some combination of the above.
+- For this tutorial, we’re going to add one line of instruction. Find the following line:
+
+```
+
+```
+
+- Instead of inserting images, we're going to copy the following HTML text and paste it into the file:
+
+`
Type ";" followed by e o n g z E O N G Z to produce ɛ ɔ ŋ ɣ ʒ Ɛ Ɔ Ŋ Ɣ Ʒ
`
+
+- Close the welcome.htm file. Click “Yes” to save the changes.
+
+
+To continue the Step-by-Step tutorial move to the next page: [Part 8 - Preparing a Keyboard Package](08-preparing-keyboard-package)
+
+
+## Editing the README.md file
+
+The `README.md` file contains information about the keyboard useful for other keyboard authors who might revise or adapt the keyboard at some future date. This information is not presented to the end user.
+
+## Editing the LICENSE.md file
+
+If you filled out all the information in the New Project dialog, the `LICENSE.md` file should have been set up correctly.
+Normally the only thing to change here would be changing the initial date into a date range (from `2026` to `2026-2027`, for example).
+Changing the date in this manner is only needed when the keyboard is updated.
+
+## Editing the readme.htm file
+
+The `readme.htm` file is displayed as the user begins to install the keyboard.
+It should contain a brief description of the keyboard with enough information to reassure the user that the right keyboard has been selected for installation.
+Instructions for using the keyboard should be reserved for the `welcome.htm` file.
+
+## Editing the welcome.htm help file
+
+The `welcome.htm` file provides the help that is packaged with the keyboard.
+This help file is displayed after the keyboard is first installed.
+The user can also ask for the help file to be displayed.
+
+This file should contain enough information that the user can discover all the features of the keyboard.
+This could be in the form of
+- keyboard images for the different layers,
+- a chart of how to type,
+- a description of how to type (such as was used in the Step-by-Step tutorial),
+- or some combination of these.
+
+One way to create keyboard images is to use the procedure in the "Exporting an On-Screen Keyboard layout" section of [Creating a Desktop Layout](03-creating-desktop-layout).
+These images can be referenced from the welcome.htm file in this fashion:
+
+```html
+
Desktop keyboard layout
+
Default (unshifted)
+
+
Shift
+
+
Right Alt (unshifted)
+
+```
+All the files to be included in the package must be specified in the Keyman package source (.kps) file.
+These files end up in a single directory in the Keyman package (.kmp) file.
+Thus it is preferable to put images referenced by welcome.htm in the same folder as the welcome.htm file in order to allow easy local testing.
+
+There are two approaches:
+1. put the welcome.htm file and all the images it references in the `source` folder, or
+2. create a `welcome` folder under the `source` folder and put the welcome.htm file and all the images it references in the `welcome` folder.
+
+Keyman Developer's `New Project` feature follows the first approach when it creates the directory structure for the new project.
+If you decide to use the second approach (which might be helpful if you have lots of images to include),
+you'll need to change the location of the welcome.htm file in the list of files in the package.
+The easiest way to do this is to remove the welcome.htm file from the list, then add it again by navigating to the new location.
+
+For either of the two approaches, all the image files that are referenced by the welcome.htm file need to be added to the list of files to be included in the package.
+
+## Editing the PHP help file
+
+When a keyboard is submitted to the Keyman keyboards repository, a PHP file is included which provides the online help available on the [keyman.com](https://keyman.com) site. (If you do not plan to submit your keyboard to the Keyman repository, you don’t need to include this PHP help file.)
+
+The Keyman keyboards repository requires that this PHP file have the name of the keyboard project plus the `.php` extension and be located in a folder named `help`, which is located in the `source` folder.
+
+The PHP help file often contains the same information as is in the welcome.htm file. See [Keyman Keyboard help document (PHP help file)](https://help.keyman.com/developer/keyboards/phphelpfile) for more details.
+
+
+[← Part 6 - Creating a Touch Layout](06-creating-touch-layout) [Part 8 - Preparing a Keyboard Package →](08-preparing-keyboard-package)
+
\ No newline at end of file
diff --git a/developer/docs/help/guides/develop/walkthrough/08-preparing-keyboard-package.md b/developer/docs/help/guides/develop/walkthrough/08-preparing-keyboard-package.md
new file mode 100644
index 00000000000..9bd0956cdb5
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/08-preparing-keyboard-package.md
@@ -0,0 +1,66 @@
+---
+title: Preparing a Keyboard Package
+---
+
+
+
+Part 8 of the [Keyman Developer Walkthrough](.).
+
+[← Part 7 - Writing Keyboard Documentation](07-writing-keyboard-documentation) [Part 9 - Distributing a Keyboard Package →](09-distributing-keyboard-package)
+
+
+## Step-by-Step
+
+- Select the `dagbani.kpj` project filename at the top (just under the menu and toolbar).
+- Select the `Packaging` tab at the bottom, then the `dagbani.kps` file. This will open the Keyboard Package Source file and display some tabs down the left side of the window that will help you manage the content. Most of the information has been set up for you when you first created the keyboard project.
+ - The `Files` tab lists the files that will be included in the package.
+ - The `Keyboards` tab lists the language codes supported by this keyboard.
+- Select the `Details` tab.
+- If the value in the `Welcome file` field is `(none)`, then select that field and select `welcome.htm` from the drop-down list.
+- Select `File` in the menu bar, then `Save` to save the changes. (The Ctrl+S shortcut also works.)
+- Select the `Build` tab, then the `Compile Package` button. A **dagbani.kps built successfully** message should be displayed.
+- Congratulations! You have successfully built and packaged a keyboard for the Dagbani language.
+
+
+To continue the Step-by-Step tutorial move to the next page: [Part 9 - Distributing a Keyboard Package](09-distributing-keyboard-package)
+
+
+---
+
+## Package Files
+
+See the [Keyman Package Editor documentation](../../../context/package-editor) if you need more details on the following items.
+
+### Files
+
+In addition to the files that are included in the package by default when you create the keyboard project with the New Project feature, you have the option of adding additional files to the package. Files that might be added:
+
+- keyboard image files referenced by the welcome.htm help file
+- fonts
+- an image file (see under Details)
+
+### Keyboards
+
+Enter a language tag (that is, a BCP 47 tag) for each language supported by the keyboard.
+
+Optionally, you can specify an example of a word the keyboard produces and the keys used to produce it.
+
+If you include fonts in the package, you can specify that Keyman use them for displaying the on-screen keyboard or the touch keyboard.
+
+### Details
+
+Here is where you can enter information for:
+
+- Package name: Initially set to the name of the keyboard, so usually won’t need to change
+- Welcome file: normally set to `welcome.htm`
+- Readme file: normally set to `readme.htm`
+- License file: normally set to `LICENSE.md`
+- Version: Recommendation is to tick the `Package version follows keyboard version` box and leave the version field blank
+- Copyright: normally established in the New Project dialog, but you can make needed changes here. Current practice is to omit the copyright year from this field (since it is in the [LICENSE.md](http://LICENSE.md) file).
+- Author, Email address, Web Site: You can include as much or as little information about the author as you wish
+- Image file: If you supply a 140 pixel wide x 250 pixel high image in JPEG or PNG format, then your custom image will be shown during installation (in place of the default Keyman image). Your image file must be added to the Files list before it will be available to be selected here.
+- Related packages: If your keyboard is part of a group of keyboards, you can specify which other keyboards are part of the group. (For example, you might have three keyboards for the same language, one based on the QWERTY layout, one AZERTY, one QWERTZ, and you could use this field to note the relationship between them.) You can also use this feature to deprecate another keyboard that your keyboard supersedes.
+
+
+[← Part 7 - Writing Keyboard Documentation](07-writing-keyboard-documentation) [Part 9 - Distributing a Keyboard Package →](09-distributing-keyboard-package)
+
\ No newline at end of file
diff --git a/developer/docs/help/guides/develop/walkthrough/09-distributing-keyboard-package.md b/developer/docs/help/guides/develop/walkthrough/09-distributing-keyboard-package.md
new file mode 100644
index 00000000000..1a38688018d
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/09-distributing-keyboard-package.md
@@ -0,0 +1,38 @@
+---
+title: Distributing a Keyboard Package
+---
+
+
+
+Part 9 of the [Keyman Developer Walkthrough](.).
+
+[← Part 8 - Preparing a Keyboard Package](08-preparing-keyboard-package) [Part 10 - Generating a Lexical Model →](10-generating-lexical-model)
+
+
+## Step-by-Step
+
+For the Step-by-Step tutorial, there’s really nothing to do for this page. This tutorial is for learning only, therefore you don't want to submit this keyboard to the Keyman keyboards repository (since it already contains a keyboard by that name). If you like, you could look at the other sections on this page before continuing the Step-by-Step tutorial (or come back to them later).
+
+
+To continue the Step-by-Step tutorial move to the next page: [Part 10 - Generating a Lexical Model](10-generating-lexical-model)
+
+
+---
+
+## Submitting a keyboard to the Keyman Keyboards Repository
+
+Follow the instructions at [Working with the Keyman Cloud Keyboard Repository](https://help.keyman.com/developer/keyboards/) to submit your keyboard to the Keyman keyboards repository. This will enable anyone with Internet access to download and use the keyboard. (Please do not submit the Dagbani keyboard used in the Step-by-Step tutorial. There is already a Dagbani keyboard in the repository.)
+
+One requirement for keyboards that are submitted to the Keyman keyboards repository is the addition of a PHP help file that provides the online help available on the keyman.com site. See the **Editing the PHP help file** section of the [Writing Keyboard Documentation](07-writing-keyboard-documentation#toc-editing-the-php-help-file) page for more details.
+
+## Other Distribution Methods
+
+A keyboard package is contained in a file with the file type `.kmp`. The package contains everything needed for any of the supported platforms to run the keyboard. If you want to test a keyboard package, it is possible to transfer the `.kmp` file to a device with Keyman installed and use Keyman on that device to install the keyboard.
+
+With Keyman Developer running, it’s possible to select `Packaging`, and the `.kps` file, then the `Build` tab, and then select the `Test package on web`. This will display a number of possible Internet addresses where the keyboard could be downloaded over a local network to a device running Keyman. There are also options that will install the package on the local machine running Keyman Developer.
+
+The Keyboard App Builder (KAB) lets you put a Keyman keyboard (and optionally a lexical model) into an app for iOS or Android, which can be distributed. More details can be found on the [Keyboard App Builder](https://software.sil.org/keyboardappbuilder/) page.
+
+
+[← Part 8 - Preparing a Keyboard Package](08-preparing-keyboard-package) [Part 10 - Generating a Lexical Model →](10-generating-lexical-model)
+
\ No newline at end of file
diff --git a/developer/docs/help/guides/develop/walkthrough/10-generating-lexical-model.md b/developer/docs/help/guides/develop/walkthrough/10-generating-lexical-model.md
new file mode 100644
index 00000000000..a946ded54f0
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/10-generating-lexical-model.md
@@ -0,0 +1,376 @@
+---
+title: Generating a Lexical Model
+---
+
+
+
+Part 10 of the [Keyman Developer Walkthrough](.).
+
+[← Part 9 - Distributing a Keyboard Package](09-distributing-keyboard-package) [Part 11 - Installing a Keyman Lexical Model →](11-installing-lexical-model)
+
+
+## Step-by-Step
+
+For the purposes of this tutorial, we'll use a very short word list (of only 25 words)
+selected from the first chapter of the gospel of Mark from the online version of Dagbani Bible
+([https://www.bible.com/bible/2264/MRK.1.DBWDB](https://www.bible.com/bible/2264/MRK.1.DBWDB)).
+The sample text is a verse from that chapter, so it is not a very realistic test!
+This is just so that you can see how the lexical model is used for predictive text.
+
+For a real project you would want thousands of words, ideally drawn from a number of sources.
+In addition, the list of words should be reviewed.
+(For details, see the discussion that follows the Step-by-Step section on this page.)
+
+- Open Keyman Developer, and select the `Project` menu and the `New Project` menu item. In the `New Project` dialog, select `Wordlist Lexcial Model`, then `OK`.
+
+
+
+- A `New Wordlist Lexical Model Project` dialog is displayed.
+- In the `Author Name` field, put `SIL Global`. This also fills in the Copyright and Full Copyright fields.
+- In the `Model Name` field, put `WL` (for `wordlist`).
+- The version number defaults to `1.0` and we will keep that value.
+- In the `Description` field, put **A test lexical model for Dagbani keyboard tutorial. Not for real use.**
+- Select the `Add` button on the right and enter `dag` in the `Language tag` field and select `OK`
+- Change the `Author ID` field from `sil_global` to `sil`.
+- Verify that the `Model ID` field now shows `sil.dag.wl`, then select `OK`.
+ - Note: If you are using Keyman Developer 17, it might display the message **This project file is in an old format. You should update it to the Keyman Developer 17.0 project format.** If so, select the `Upgrade project` button.
+
+- Select the `Models` tab at the bottom of the window, then select the `sil.dag.wl.model.ts` file.
+- Tick the `Language uses casing` checkbox (located on the `Details` tab)
+- In this tutorial, we're going to open a file, copy its contents, then paste those lines into the `wordlist.tsv` file to replace the default content. Depending on how your browser is configured, when you open the file, it may open in a new tab or it may open in the same tab as this set of instructions. In the first case you can close the tab to return here, but in the second case you'll need to use the Back feature of your browser. (You may want to read ahead to make sure you understand the next few steps since the instructions might be hidden temporarily.)
+- Click on the **dag-short-wl.txt** filename just below this paragraph to open the file (or right-click and select Open in a new tab).
+
+ * [dag-short-wl.txt](./dag-short-wl.txt)
+
+- Use Ctrl+A to select the entire contents and Ctrl+C to copy the selected text.
+- Return to these instructions, either with the browser's Back feature, or by closing the newly opened tab, as appropriate.
+- In Keyman Developer, select the `wordlist.tsv` tab on the left, then the `Code` tab at the bottom, then use Ctrl+A to select the entire contents and Ctrl+V to paste in the text that you just copied in a previous step.
+- Use `File`, `Save` (or, alternatively, the Ctrl+S shortcut) to save the modified wordlist.tsv file.
+- Select the `Build` tab on the left, then the `Compile Model` button. Verify that the **sil.dag.wl.model.ts built successfully** message is displayed.
+- To test the model, we’ll first select the keyboard that we made in an earlier step. (The following instructions assume that the default location was chosen when creating the keyboard project and the lexical model project. If you chose a different location, you’ll need to navigate there.) Select the `Browse` button and Keyman Developer will open a file navigation window. Navigate to the `Documents` folder, then the `Keyman Developer` folder, then `Projects`, then `dagbani`, then `build`, then open the `dagbani.js` file. This will fill in the `Keyboard for testing` field.
+
+
+
+- Select the `Test Lexical Model` button, then the `Open in browser` button. You should have a new browser tab that looks like:
+
+
+
+- Select the `Keyboard` button and choose the `dagbani` keyboard from the list.
+- Select the `Device` button and choose one of the `Phone Devices` from the list. (The illustrations were made with the `iPhone 5S` option.)
+- Select the `Model` button and choose the `sil_dag_wl` lexical model from the list.
+- Click in the text area (box with pale yellow background). The text we’re using as a test is **Ka bɛ daa dii chɛ bɛ lansi maa ka dol’ o.** You’ll be using the mouse to simulate the phone’s touch screen (unless your computer has a touch screen). Move your cursor to the desired key on the display, then click the mouse to “touch” the key.
+- Click the Shift key (the key on the left with an uparrow), then K, then select **Ka** from the banner.
+
+
+
+- Click b, then select **bɛ** from the banner.
+- Since **daa** is in the banner already, select it.
+- Click d, then select **dii** from the banner.
+- Click c, then select **chɛ** from the banner.
+- Click b, then select **bɛ** from the banner.
+- Click l, a, n, s, i, and the space bar.
+- Since **maa** is in the banner already, select it.
+- Since **ka** is in the banner already, select it.
+- Click d, then select **dol’** from the banner.
+- Click o and . to conclude this test.
+- Close the browser tab and return to Keyman Developer.
+- Select `sil.dag.wl.kpj` from the top of the window (under the menu bar and toolbar), then select the `Packaging` tab at the bottom, then the `sil.dag.wl.model.kps` file.
+- Select the `Details` tab on the left.
+ - If the `Welcome file` field contains `(none)`, select that field and choose `welcome.htm` from the list. Use the Ctrl+S shortcut to save the change.
+- Select the `Build` tab on the left. Then select the `Compile Package` button. Verify that you get the **sil.dag.wl.model.kps built successfully** message.
+- Congratulations! You have successfully built and packaged a lexical model for the Dagbani language.
+
+
+To continue the Step-by-Step tutorial move to the next page: [Part 11 - Installing a Keyman Lexical Model](11-installing-lexical-model)
+
+
+## Introduction
+
+A Keyman touch layout can link to a lexical model in order to suggest words to automatically finish what you are typing, based on the characters you have already entered. The currently available lexical models only predict words based on how frequently they are used in the entire language, and will not suggest next words according to context or grammatical rules. However, for languages with long words or complex character combinations, lexical models can be a valuable tool to aid users of your keyboard.
+
+## Before You Begin
+
+In order to create a lexical model for a language, you should have one or more sources of words in the language. Examples could be:
+
+- Text files written in the language of your lexical model
+- A lexicon or dictionary, from which you can export a list of words
+
+You should choose sources with open licenses (such as Creative Commons, MIT, etc). You may need to ask the source for permission to relicense the list of words under the MIT license if you submit the lexical model to the Keyman lexical models repository (which always uses the MIT license).
+
+## Creating a Lexical Model
+
+Keyman Developer allows you to create a lexical model project, which is separate from your keyboard project. The link between a keyboard and a lexical model depends on having a BCP 47 code in common. Although it may seem confusing to make a separate project for a lexical model that is intended to go with your existing keyboard, this separation allows a lexical model to be used by any keyboard that supports that language. Similarly a keyboard user might have multiple lexical models to choose from.
+
+In Keyman Developer, from the `Project` menu, select `New Project`. In the `New Project` dialog, select `Wordlist lexical model` from the list. Another dialog will appear to collect the basic information for your model.
+
+### **Author Name, Author ID and Copyright**
+
+Enter your name in the `Author Name` field. The value in this field is also used in the `Copyright`, `Full Copyright` and `Author ID` fields. If the copyright is held by an organization, adjust the name in the copyright fields. The name that appears in the copyright fields needs to be the full name of an individual or organization.
+
+The `Author ID` value is based on your name (if you are working independently) or the name of your organization. You should use the shortest feasible version of the name (initials, for example), since the `Author ID` is the first of the three parts of a lexical model project. It will also become the parent folder in Keyman’s repository for all lexical models submitted by you or your organization.
+
+### Model Name
+
+This is the third of the three parts of the complete lexical model project name. It serves to distinguish between multiple lexical models by the same author for the same BCP 47 tag.
+
+You could use:
+
+- the name of the language this lexical model will serve
+- some indication of the source of the words
+- the type of lexical model, such as “wordlist” or “wl” (since Keyman currently only supports wordlist-based models)
+
+As with the keyboard project ID, you are limited to lower case ASCII alphanumeric characters and the underscore character.
+
+### Version
+
+For a brand new model, there is no need to edit this. However, when making changes or additions to a lexical model, increment the first digit (for example, from `1.0` to `2.0`) for major changes, and the second digit (for example, from `1.0` to `1.1`) for minor changes. (As with the version number for keyboards, an optional third digit is available for revisions. Do not use more than three numbers. Don’t add zeroes to the beginning of numbers.)
+
+### Languages
+
+As with a keyboard, you must add a BCP 47 tag to your lexical model to properly identify the language it is intended for. This is the link that allows Keyman to match keyboards and lexical models. It will be used as the second of three parts of the complete lexical model project name.
+
+Select `Add` and fill in the fields accordingly. You’ll want to use the same BCP 47 tag which you used in the [Creating a Keyboard Project](01-creating-keyboard-project) step.
+
+
+
+It is best to use the simplest possible BCP 47 tag to identify your language. Only add Script and Region tags if you are specifically working with a script or region that differs from the most commonly used form of your language.
+
+### Description
+
+For the `Description` field, you can simply state that this a lexical model based on a list of words for the specific language. You might also include information about where those words were gathered. (Don’t, however, include details about how many words are included. Otherwise you’ll need to revise the description everywhere it’s used for each new version of the lexical model that changes the word count!)
+
+Note how the `Model ID` field is automatically filled in.
+The naming scheme for lexical models is `author_name`.`language-tag`.`model_name`.
+The `language-tag` value is derived from the `Primary Language` that you choose, so be sure to select the correct language.
+If your Author or Model names are excessively long, edit the `Author ID` and `Unique Name` fields respectively to give your project an abbreviated name. (For example, in the Step-by-Step section, the Author field was changed from "sil_global" to "sil".)
+
+Once you have filled out all of the fields, you are ready to create your lexical model.
+
+## Details
+
+Keyman will place you in your `.kpj` file immediately, as with a keyboard project. Navigate to your `model.ts` file. On the `Details` tab, you’ll find some options.
+
+Currently `Wordlist (trie-1.0)` is the only choice for the `Format` field.
+
+You’ll normally want to keep the `default` choice for the `Word breaker` field and the `(Space U+0020)` option for the `Insert after word` field, unless you are dealing with an orthography that doesn’t use space to separate words. For scripts such as Khmer, Thai, and Lao, which have special ways to delimit words, see the Keyman documentation on [coding a custom word breaker](../../../guides/lexical-models/advanced/word-breaker).
+
+You can specify the opening and closing quotation marks, and whether the language is using a right-to-left script (such as Arabic, Hebrew, Syriac, etc.)
+
+If your language uses a script with uppercase and lowercase (such as Latin, Cyrillic, Greek, etc.) you probably will want to enable the `Language uses casing` checkbox, so that Keyman will take casing into account when matching and suggesting words. For example, if you start typing `Rab`, Keyman will propose `Rabbit` rather than `rabbit`.
+
+The Keyman site has more details on [advanced topics](../../../guides/lexical-models/advanced/word-breaker).
+
+## Editing Wordlists
+
+On the `Details` tab, there is a field labeled `Wordlists`, where one or more wordlist files are specified. Every wordlist that you add to your lexical model will be listed in the “Wordlists” list on the “Details” tab and have its own tab below the “Details” tab.
+
+Keyman provides a default `wordlist.tsv` file for you as an example. You can replace its contents with your own data or remove it. Use the buttons on the right to add or remove wordlists.
+
+For a newly created project, the only wordlist present is `wordlist.tsv`.
+If you open that file, you'll see some sample data included as an illustration.
+
+For advanced information on Keyman wordlist file formats and exporting your own wordlist files, read the [TSV file documentation](../../../reference/file-types/tsv).
+
+### Ignored lines
+
+Any line beginning with `#` is ignored. You can write any notes or commentary on such lines.
+
+### Word Form
+
+The `Word Form` is the first column of your wordlist, and will contain every single word that you want your lexical model to suggest to users while typing. Naturally, this includes grammatical variations and other alternate forms of words used in your language.
+
+### Count
+
+The `Count` is the second column of your wordlist, and is a number indicating the relative frequency with which a word appears in your language. This is most commonly done by an automated count of words that occur in actual texts in your language, but it is possible to manually adjust the frequency count of one or more words.
+
+If the `Count` field is empty for a given word, it will be counted as one. If you omit the `Count` field for all the words in a file, they will all be considered equally likely. Your lexical model will be more useful if it can suggest words according to how common they are.
+
+Since a lexical model project can have multiple wordlist files, you could have one file with words and frequency counts derived from actual documents in the language, then add a second file extracted from a lexicon with no frequency count.
+When compiling the model, Keyman Developer will add the counts.
+In this way the lexicon will provide some less common words with a frequency count of one (and increase by one the frequency count of words in the first wordlist).
+Thus the list from the lexicon can supplement the list formed by analyzing actual documents.
+
+### Comment
+
+The `Comment` is the third column of your wordlist. This is an entirely optional column, but if you would like to leave notes for certain words, you can insert your notes into the third column of your `.tsv` file and Keyman will ignore them while processing your wordlist.
+
+### Simple Tool for Wordlist Creation
+
+PrimerPrep is a tool that will extract words from text files and create a simple .tsv file in the correct format for use in your lexical model.
+The [Generating Wordlists with PrimerPrep](#toc-generating-wordlists-with-primerprep) section at the end of this page gives a brief tutorial on how to use PrimerPrep to create a wordlist suitable for your lexical model.
+
+### Importing Wordlists into Keyman Developer
+
+In Keyman Developer, with your lexical model project open and the .model.ts file selected, select the `Details` tab to see the list of wordlist files included in this lexical model. If you have another file (perhaps one created with PrimerPrep) which you want to addd, select the `Add` button on the far right and navigate to the file to be included. You’ll see a dialog something like the following:
+
+
+
+Click `Yes` so that Keyman can make a copy of this file to include with the other source files your lexical model project.
+
+You’ll also want to `Remove` the default `wordlist.tsv` file (unless you have replaced the example content with your own data).
+
+Note that if you remove a wordlist (the default `wordlist.tsv`, for example) from the `Wordlists` list on the `Details` tab, the file itself will not be removed from your project folder.
+You will have to use a file manager to delete any unnecessary wordlist files yourself.
+If you decide not to use the default `wordlist.tsv` file, you should remove it from the list on the `Details` tab, then delete it from your project files.
+
+Once you have specified one or more wordlist files, save your project and compile it.
+You should now have a lexical model that is compatible with any keyboard that uses the same BCP 47 tag as the lexical model.
+
+## Testing Lexical Models
+
+To test your lexical model, go to the `Build` tab of your `model.ts` file and click `Test Lexical Model`. Keyman will start up a development server to let you test keyboards and models on the web.
+
+If you are working with your own keyboard and lexical model and have previously compiled your keyboard and run it on the Keyman development server, it will already be among the options for testing.
+However, you can also add your keyboard for direct testing in the `Keyboard for testing` field. Simply click the `Browse...` button and search for your keyboard’s `.js` file. It should be located inside your keyboard’s `build` folder.
+
+Once Keyman confirms that your testing server is active, you can scan the generated QR code with a mobile device to begin testing.
+
+Another testing possibility is to select the `Open in Browser` button and a new browser window (or tab) will open with three dropdown lists at the top of the page: `Keyboard`, `Model`, and `Device`.
+- Set the `Device` to one of the `Phone Devices` or `Tablet Devices` options.
+- Set `Keyboard` to the keyboard you selected.
+- Then set `Model` to the lexical model you are testing. You can then test the lexical model on the simulated keyboard.
+
+## Packaging
+
+Just like a keyboard, the lexical model must be packaged before it is ready for distribution and use with a Keyman keyboard.
+Use the `Packaging` tab at the bottom of the screen and select your .kps file.
+You can then select the `Build` tab on the left and then the `Compile Package` button to create the package (.kmp) file.
+
+## Publishing a Lexical Model
+
+You can submit your lexical model to the Keyman lexical models repository in a manner similar to submitting a keyboard to the keyboards repository.
+This makes the lexical model available to anyone with Internet access.
+See [Guide for Lexical Model Submissions](/developer/lexical-models/submission/).
+
+The [Distribute lexical modes to Keyman Applications](../../lexical-models/distribute/packages) page details other distribution possibilities.
+
+In addition, it is possible to use [Keyboard App Builder](https://software.sil.org/keyboardappbuilder/), which will allow you to build an app that includes Keyman, a specific keyboard and a specific lexical model.
+You can then distribute this app to users directly or through the platform's source of apps.
+
+## Generating Wordlists with PrimerPrep
+
+Creating a wordlist manually is a difficult task.
+Instead, wordlists are usually generated using a software tool that can process text files written in the given language,
+identify unique words and tally up how frequently they appear in the text.
+
+One tool that can do this is [PrimerPrep](https://software.sil.org/primerprep/), which is available for free on Windows and Linux. This tutorial will cover how to use PrimerPrep to generate a wordlist from preexisting texts.
+
+Before generating a wordlist with this method, you must first have one or more texts to take words from. This allows you to include relevant and commonly used words and their various grammatical forms in your lexical model, rather than attempting to select appropriate words yourself.
+
+When selecting texts to use in generating your lexical model, try to find long texts that include a variety of formats and uses of the language. This increases the likelihood that your lexical model will cover common wordforms and accurately predict the most frequently used words.
+
+Be sure to back up the original text and save your edited version under a new name. You will need to cut various unwanted words from the document before generating a wordlist from it, which is obviously undesirable if you need the full document later.
+
+For the purposes of this tutorial, we’ve provided a sample text that you can download and use to follow along with instructions. If you already have a project in mind and appropriate sample texts, feel free to use those instead.
+
+The sample text is a collection of folktales for the Fulfulde language. Right-click on the **Anduna_anndaaka.txt** link below and select `Save link as` and navigate to a folder where you can save the file and work on it. After you have deleted some unneeded words from the file you'll use PrimerPrep to create a wordlist file that you will then include in the `source` folder of your lexical model project.
+
+* [Aduna_anndaaka.txt](./Aduna_anndaaka.txt)
+
+### File Preparation
+
+Before extracting words from a document to create a wordlist, you can first remove any words that are unlikely to be needed by users. (Alternatively, you can create the wordlist first and remove unwanted words later, but that may end up being more work.)
+
+Generally, you'll want to exclude such words as:
+
+- Proper nouns (names, places, etc.)
+- Acronyms and abbreviations (e.g. D.I.Y., LHR)
+- Numerals and extra symbols
+- Anything that is not used as a regular word in the language
+
+PrimerPrep will remove any punctuation and numerals for you when it processes your document, but you will need to remove proper nouns and acronyms before using PrimerPrep. The easiest way to do this is with Regular Expressions (Regex), which allow you to quickly find specific strings of characters and remove them from your document.
+
+If you do not have a word processing app that supports Regex searches, you can download and use the free program [Notepad++](https://notepad-plus-plus.org/downloads/). Otherwise, feel free to use your Regex-compatible word processor of choice.
+
+When you open the Aduna_anndaaka.txt file you’ll notice that the title page is written in French. Delete everything that comes before the following line:
+
+```
+Aysata Aamadu Siise
+```
+
+The lines before it are either in French or contain mostly acronyms or proper nouns, which we do not want to include.
+
+In general, you will want to ensure that the text you are processing contains only text in the language for which you want to create a lexical model, so that your model won't suggest words in a different language.
+This is especially important if you are using a text that contains translations or other footnotes meant for non-native speakers.
+
+Open up the file you want to take your wordlist from in Notepad++. In our case, this is `Aduna_anndaka.txt`.
+In Notepad++, press Ctrl+H (or from the `Search` menu, select `Replace`) to open the Find and Replace dialog.
+Enable the `Regular Expression` setting at the very bottom.
+
+
+
+You will need to perform several Regular Expression (Regex) search and replace operations to remove unneeded elements from the document.
+For each Regex string, simply paste it into the `Find what:` field, and leave the `Replace with:` field blank.
+(A blank “replacement” effectively deletes what the search finds.)
+
+The regular expressions provided here are tailored for the Fulfulde language, which includes the characters `ɓɗɲŋƴ` and `ƁƊƝŊƳ`.
+You may have to dive deeper into Regex rules to filter words in languages that use different character sets.
+[Regex101](https://regex101.com/) is a great resource for building and testing regular expressions.
+Just make sure that the Regex “flavor” you use on the site matches that of your word processor.
+
+### Removing Proper Nouns
+
+```
+\b[A-ZƁƊƝŊƳ][a-zɓɗɲŋƴ]*\b
+```
+
+This Regex searches for any words that begin with an uppercase letter followed by zero or more lowercase letters.
+(The `\b` represents a word boundary. `[A-ZƁƊƝŊƳ]` represents one of 31 uppercase letters. `[a-zɓɗɲŋƴ]` represents one of 31 lowercase letters, however `*` indicates that `[a-zɓɗɲŋƴ]` should be repeated zero or more times.)
+Although it will also remove any words that begin a sentence (or words that are in titles), it will remove most unwanted names.
+The idea is that if a word is common enough, it will appear multiple times in different places, so it is acceptable to remove the few times the word happens to begin a sentence.
+
+- Make sure to activate the `Match case` option when using Regex to look for capitalized letters. Otherwise, it will match words of **any** case (and may replace your entire document)!
+
+
+
+- Copy the regular expression above and paste it into the `Find what` field.
+- Select the `Find Next` button a few times to see what Notepad++ is matching. It should be highlighting capitalized words only. (Note that Notepad++ highlights the matched word in one color and also, in a slightly different color, any other occurrences of the same word, **regardless of case**. This can be confusing.)
+- Once you’re satisfied with the results, return to the top of the file and select `Replace All`.
+
+### Removing Acronyms
+
+```
+\b([A-ZƁƊƝŊƳ][.-]?)+\b
+```
+
+This Regex will remove all words that are either in ALL CAPS, or in caps with separating punctuation (i.e. D.I.Y.).
+Note that if the acronym does have separating punctuation, there may be one last `.` left on the end.
+This is not a problem because PrimerPrep will clean up all of the punctuation for us later.
+
+- Return to the top of the file
+- Copy the regular expression above and paste it into the `Find what` field.
+- Select `Find Next`. In this case, you will likely get a `Can't find...` message, indicating that no matching acronyms were found.
+(If it is matching random words, ensure that `Match case` is checked.)
+For this text, this particular test wasn't needed. Deleting the front matter from the text removed several acronyms already.
+
+Your text should be ready for PrimerPrep now. It may look messy to a human, but PrimerPrep will ignore all of the extra spaces and punctuation and simply extract the words from the document. It will look something like this:
+
+
+
+- Save your file with a new name (`Aduna_anndaaka_lowercase.txt` for example) and place it somewhere that will be easy to find.
+
+### Generating the Wordlist
+
+- If you haven’t already, download [PrimerPrep](https://software.sil.org/primerprep/downloads/) and run it. This is the basic appearance:
+
+
+
+It may look complicated, but the wordlist generation only uses one of the functions of PrimerPrep.
+
+- Select the `Add Text(s)` button
+- Navigate to the text you just prepared
+- Double-click on the file (or select the file and then select `Open`). It should populate the window with words and frequency counts:
+
+
+
+- From the `File` menu, select `Save Word List` and save your wordlist file in an appropriate location. Be sure to rename it something that distinguishes it from any other wordlists you may generate. PrimerPrep suggests a `.txt` extension, but Keyman generally uses `.tsv`
+
+That’s all you need to do. You can now exit PrimerPrep and return to Keyman Developer. PrimerPrep will warn you about unsaved data, but you can safely ignore this because you have saved the wordlist file and don't need other functions of PrimerPrep.
+
+Note: The text provided for this tutorial is already in a `.txt` file format. For your own project, you may be working with files in other formats and you will need to convert them to a `.txt` file in UTF-8 Unicode encoding in order to import them into PrimerPrep. For example, if your files are in Microsoft Word format, the dialog for saving a `.txt` file would look something like this:
+
+
+
+
+[← Part 9 - Distributing a Keyboard Package](09-distributing-keyboard-package) [Part 11 - Installing a Keyman Lexical Model →](11-installing-lexical-model)
+
\ No newline at end of file
diff --git a/developer/docs/help/guides/develop/walkthrough/11-installing-lexical-model.md b/developer/docs/help/guides/develop/walkthrough/11-installing-lexical-model.md
new file mode 100644
index 00000000000..02d7594421a
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/11-installing-lexical-model.md
@@ -0,0 +1,37 @@
+---
+title: Installing a Keyman Lexical Model
+---
+
+
+
+Part 11 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[← Part 10 - Generating a Lexical Model](10-generating-lexical-model)
+
+
+## Step-by-Step
+
+For the Step-by-Step tutorial, there’s really nothing to do for this page.
+This tutorial is for learning only, therefore you don't want to submit this lexical model to the Keyman lexical-models repository.
+You could look at other sections on this page if you like.
+
+This concludes the walkthrough. Hopefully it has given you an overview of the entire process.
+
+---
+
+## Submitting a lexical model to the Keyman Lexical Models Repository
+
+Follow the instructions at [Working with the Keyman Cloud Lexical Models Repository](https://help.keyman.com/developer/lexical-models/) to submit your lexical model to the Keyman lexical models repository. This will enable anyone with Internet access to download and use the lexical model. (Please do not submit the Dagbani lexical model used in the Step-by-Step tutorial. It’s really not suitable for submission to the repository.)
+
+Once the lexical model has been published, any Android or iOS device with Keyman installed and access to the Internet should be able to access and load the lexical model for use with a keyboard with the same language tag (BCP 47 code) as the lexical model.
+
+## Other Distribution Methods
+
+If an Android or iOS device has access to the Keyman package file (.kmp) that contains the lexical model, the Keyman program on the device can load the model. This access could be over the Internet, over a local network or by moving the file to the device’s file storage.
+
+As mentioned earlier, the Keyboard App Builder (KAB) lets you put a Keyman keyboard along with a lexical model into an app for iOS or Android, which can be distributed.
+More details can be found on the [Keyboard App Builder](https://software.sil.org/keyboardappbuilder/) page.
+
+
+[← Part 10 - Generating a Lexical Model](10-generating-lexical-model)
+
