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..cf5d0327504
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/00-introduction.md
@@ -0,0 +1,75 @@
+---
+title: Introduction
+---
+
+[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 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.exe` file you’ve received. The numbers following “keymandeveloper” indicate which version of Keyman Developer you are installing.
+
+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 icons for Keyman Developer  and Keyman  are similar but slightly different.
+
+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 Documentation](https://help.keyman.com/developer/language/guide/)
+
+Reference for the general structure 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: NOT for help and support questions. The Keyman community forum is the best place to ask for help with 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..630c00821ce
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/01-creating-keyboard-project.md
@@ -0,0 +1,189 @@
+---
+title: Creating a Keyboard Project
+---
+
+Part 1 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[< Back: Introduction](00-introduction)
+
+[Next: Part 2 - Designing a Desktop Layout >](02-designing-desktop-layout)
+
+## Step-by-Step
+
+For the Dagbani keyboard, the keyboard planning has been done for you. Follow these steps to create the Dagbani keyboard project:
+
+- Open Keyman Developer and select `New Project` from the `Project` menu.
+- The `Keyman Keyboard` option is selected by default. Click `OK`.
+- A new dialog should pop up with fields for you to fill out:
+
+
+
+- For the Keyboard Name field, enter **Dagbani** (which will also fill in the Keyboard ID field).
+- For the Description field, enter **A keyboard for typing the Dagbani language of Ghana.**
+- For the Author field, you can put in your own name. Note that the Copyright and Full copyright fields are initialized. Since the copyright really belongs to SIL Global, we’ll change those fields for this tutorial. (When you create a real keyboard project, follow the advice in the [Author, Copyright and Full Copyright](#toc-author-copyright-and-full-copyright) section below.)
+- In the Copyright field enter **Copyright © SIL Global**
+- In the Full Copyright field enter **Copyright © 2021-2025 SIL Global** . (The date range goes from the first year that the keyboard was written to the current year. A new keyboard usually just lists a single year.)
+- The Version field defaults to **1.0** and you can accept that default version number.
+- The Target field defaults to **any** (meaning “any and all” of the listed target platforms). This is what will be used for the Dagbani keyboard.
+- The Path field defaults to “Keyman Developer\Projects\” in the user’s “Documents” folder.
+- The Keyboard ID field was initialized to **dagbani** based on the Keyboard Name entered earlier. We will keep this value. The Project filename of …**Documents\Keyman Developer\Projects\dagbani\dagbani.kpj** is displayed for information. It is the Path field plus the keyboard’s project folder (which uses the Keyboard ID field as its name) plus the keyboard project file (which uses the Keyboard ID field as the name with the .kpj file type).
+- Select the `Add` button to add a BCP 47 language tag for the language. In the dialog that comes up, enter **dag** in the `Language tag` field and verify that the Language name field shows as **Dagbani**.
+- Select `OK` to close the `Select BCP 47 tag` dialog.
+- Select `OK` to close the `New Basic Keyboard Project` dialog.
+
+To continue the Step-by-Step tutorial move to the next page: [Part 2 - Designing a Desktop Layout](02-designing-desktop-layout)
+
+---
+
+## Planning a Keyboard
+
+The first step is identifying the language or languages your keyboard will cover. Some keyboards support multiple different languages within the same region. This approach, however, has some significant drawbacks:
+
+- it is difficult to optimize a keyboard for multiple languages since a rarely used character for one language may be a common character for another.
+- it is harder for users to find the keyboard since the name of the keyboard may not relate to the particular language they are researching.
+- a separate lexical model (for predictive text) is needed for each language, so having a keyboard that handles multiple languages may make installation of a lexical model harder.
+
+Furthermore, having a keyboard specifically designed for a single language may help with community acceptance.
+
+If you do need to provide keyboard support for a number of languages in a region, consider planning the keyboards together, so that you can make them as similar as possible, but then make a separate keyboard for each language.
+
+Once you have figured out what language your keyboard will support, you will need to familiarize yourself with which characters (including punctuation) are used to write it. You will need to determine what key or key combinations are needed to produce these characters. There may be major benefits in keeping as close as possible to the standard layout for a language of wider communication. On the other hand, repurposing a key from the standard layout may make it easier to type the target language.
+
+## Understanding User Needs
+
+Once you understand what is needed to support the language, you should seek to understand the needs of its speakers.
+A few good questions to start with are:
+
+- Who will use this keyboard?
+- What devices will they use it on?
+- What are the most important keys on the keyboard?
+- What have people been using to type instead?
+
+Understanding the users is the key to designing an effective keyboard. Is it intended for fluent or basic speakers of the language? Are the users familiar with common keyboards already? Have they already learned a certain keyboard format or style of typing? (If you plan to be the primary user of this keyboard, think about how others may want to use it if it turns into a more valuable tool than you anticipated.)
+
+Be sure to look for keyboards that may exist for the language(s) you want to support before beginning work. Although they may not be perfect solutions, if there is a keyboard that your language’s speakers already have and are familiar with, building on its foundation can significantly save time. You might discover a keyboard that already does exactly what you need!
+
+Once you’ve planned the basic premise of your keyboard, you can open Keyman Developer and start filling out your project info.
+
+## Creating a Keyboard Project
+
+Open Keyman Developer and select `New Project` from the `Project` menu.
+
+The `Keyman Keyboard` option is selected by default. Click `OK`. A new dialogue should pop up with fields for you to fill out.
+
+The information that you enter will initialize several files in your keyboard project.
+Making sure that the information is correct at the beginning will avoid having to correct your files later.
+
+### Keyboard Name and Keyboard ID
+
+This is the name of your keyboard project.
+
+Make sure to name your keyboards intuitively. A good standard starts with the name of the language or language group you are developing for, followed by any necessary identifiers such as `Phonetic`, `Mnemonic`, `Latin`, `QWERTY`, etc. in case there are multiple keyboards available for the same language.
+Do not use the word “keyboard” in the name. Adding “keyboard” to the keyboard name is redundant and will not help people find it. Similarly, don’t include “Unicode” in the name.
+
+If you decide to change the name of the keyboard, you’ll need to change it in a number of files: `HISTORY.md`, `README.md`, `readme.htm`, and `welcome.htm`, as well as the `.kmn` and `.kps` files.
+
+Note that the `Keyboard ID` (near the bottom of the dialog) fills in automatically with the name you choose, but formatted like `keyboard_name` (changing uppercase characters to lowercase, and non-English characters and spaces to underscore).
+You can modify the value in this field, though you are limited to the characters a-z, the numbers 0-9 and underscore.
+This value will be used as the base filename of many of your Keyman files.
+
+If you decide to change the keyboard ID, you’ll need to change most of the files in the project.
+This is best done using Keyman Developer’s `Clone local project` feature.
+
+- From the `Project` menu, select `New Project` then `Clone local project`.
+- Use the `Browse` button to navigate to the `.kpj` file of your existing project.
+- Specify a new `project ID` (and adjust `Destination path` if desired), then select `OK`.
+
+### Description
+
+This brief description of your keyboard is included in all of your information files.
+Try to keep this short but informative, as this is what people will see when searching for your keyboard.
+It may be useful to include alternate language names, the script (Latin, Devanagari, etc)
+if the language is written in more than one script, the region where it is used, or other details about the keyboard.
+
+### Author, Copyright, and Full Copyright
+
+Enter your name in the `Author` field.
+Note that the `Copyright` and `Full Copyright` fields will automatically populate with your name as well.
+If you are developing keyboards that will be copyrighted by an organization, make sure to edit the Copyright fields accordingly.
+The Full Copyright field has the date as well as the copyright holder.
+
+The name used in the Copyright fields must be the real name of an individual or of an organization.
+Copyright cannot be assigned to a pseudonym.
+
+### Languages
+
+This table displays the [BCP 47](https://help.keyman.com/developer/current-version/reference/bcp-47) tag (or tags) associated with your keyboard.
+A BCP 47 tag identifies a language and will help users find your keyboard when they search for their language.
+If you don’t know what your language’s tag is, you can search for its name and find the corresponding tag in the [IANA Language Subtag Registry](https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry), which contains all existing BCP 47 tags, the [Glottolog](https://glottolog.org/glottolog/language) (under the ISO-639-3 column), or the [SIL Ethnologue](https://www.ethnologue.com/).
+
+The SIL Ethnologue is the most user-friendly option of the three, if you are unfamiliar with language tags.
+
+In addition to your basic BCP 47 tag, you can add
+[Script](https://help.keyman.com/developer/current-version/reference/bcp-47#toc-the-script-subtag) and
+[Region](https://help.keyman.com/developer/current-version/reference/bcp-47#toc-the-region-subtag) subtags.
+However, you should always use the simplest possible BCP 47 tag to identify your language.
+Only add Script and Region tags if your keyboard is for a script or region that differs from the most commonly used form of the language.
+
+### Version
+
+The keyboard version number allows Keyman to tell which of two copies of a keyboard is newer. This allows Keyman to offer users updated versions of keyboards.
+
+The version number consists of two or three integer numbers separated by periods. Don’t use more than three numbers. Don’t use leading zeros. If the third number is absent, it is considered to be zero. Version numbers are compared number by number, so `2.51` is a higher version number than `2.6.1` (since 51 is greater than 6).
+
+New keyboards usually start with version `1.0` (which is equivalent to `1.0.0`).
+Generally the first number is incremented for major changes to the keyboard,
+the second for minor changes, and the third for corrections or bug fixes.
+But the most important point is that the new version number be greater than the existing one (as noted above).
+
+The version number appears in the `HISTORY.md` file and the `.kmn` file.
+It should be updated in both places whenever you distribute a new version of the keyboard.
+
+### Targets
+
+This is where you choose which platforms that your keyboard will be supported on.
+As you can see, Keyman offers support for a wide variety of platforms.
+Although you can pick and choose what formats you wish to develop for, `any` is the best option, because it will automatically generate files to support all formats that Keyman offers.
+If you select `any`, you do not need to (and should not) choose any other options.
+
+It is best practice to support as many devices as possible when creating your keyboard, because it is hard to predict who will use your keyboard in the future. By making your keyboard as accessible as possible, you can help even more people.
+
+If you decide not to include a touch layout, untick the `any` option and select `desktop` and `web` which will allow the keyboard to be used on a web page as well as on Linux, macOS and Windows (the three `desktop` platforms). If you later add a touch layout, you can reverse this process and go back to selecting just `any`.
+
+### Path
+
+This is location on your computer where your keyboard project and all associated files will be stored.
+By default, your projects will be stored in a folder with the same name as the `Keyboard ID` value
+and that folder will be placed under the keyboard author's `Documents\Keyman Developer\Projects\` folder.
+
+It’s a good idea to let Keyman handle naming your files, since it uses good naming convention and will make things easier to find in the future. However, if you need to place the project somewhere else, you can click the `Browse...` button beside this field and navigate to the desired folder.
+
+Once you have filled out all of the fields,
+Keyman Developer will create your project and open it in a new window with your project’s `.kpj` (Keyman project) file displayed.
+You can read more about the `.kpj` file type in the [official Keyman documentation](https://help.keyman.com/developer/current-version/reference/file-types/kpj).
+
+## Basing a new Keyboard Project on an existing one
+
+Keyman has a well-maintained [Github repository](https://github.com/keymanapp/keyboards) for keyboards that have been published by the team or community members.
+You can download a keyboard from the repository and use it as the basis for your own project.
+The easiest way to do this is with the `Clone project from Keyman Cloud` feature of Keyman Developer (version 18 and later).
+
+Open Keyman Developer and navigate to `Project` > `New Project` in the top menu bar.
+
+Select the `Clone project from Keyman Cloud` option, then `OK`. A new dialog appears where you can:
+
+- search for a keyboard (by keyboard name, language, script, country, BCP 47 tag)
+- select a keyboard from the search results
+- specify a New project ID
+- optionally move external files into the new project folder
+- optionally navigate to a different destination folder
+
+When ready, select `OK` to download the files, adjust the filenames and open the new project in Keyman Developer.
+
+## Conclusion
+
+Now that you have your project set up, continue to the next section of the tutorial to start developing your first keyboard layout.
+
+[< Back: Introduction](00-introduction)
+
+[Next: Part 2 - Designing a Desktop Layout >](02-designing-desktop-layout)
\ No newline at end of file
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..2fc65182cdf
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/02-designing-desktop-layout.md
@@ -0,0 +1,145 @@
+---
+title: Designing a Desktop Layout
+---
+
+Part 2 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[< Back: Part 1 - Creating a Keyboard Project](01-creating-keyboard-project)
+
+[Next: 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](https://help.keyman.com/developer/current-version/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 that once you begin adding 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.
+
+
+[< Back: Part 1 - Creating a Keyboard Project](01-creating-keyboard-project)
+
+[Next: 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..090e9cb627c
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/03-creating-desktop-layout.md
@@ -0,0 +1,327 @@
+---
+title: Creating a Desktop Layout
+---
+
+Part 3 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[< Back: Part 2 - Designing a Desktop Layout](02-designing-desktop-layout)
+
+[Next: Part 4 - Using the Debugger >](04-using-debugger)
+
+## Step-by-Step
+
+On the “Creating a Keyboard Project” page, the **dagbani** keyboard project was created.
+Keyman Developer displays a tab for the project file `dagbani.kpj` (just below the menu and toolbar).
+There are tabs across the bottom for different steps in the process.
+
+
+
+- Click on the `Keyboards` tab at the bottom of the Keyman Developer window.
+- Then click on the `dagbani.kmn` filename. This will open the dagbani.kmn file (as a second tab along the top, just below the menu and the toolbar) and display a set of tabs along the left side of the Keyman Developer window. Initially the `Details` tab is displayed and you can see some of the items you entered when creating the project.
+- Click on the `Layout` tab from the set of tabs on the left.
+- By default the `Design` view is shown and you can use the Character Map to assign characters to various keys:
+
+
+
+- For this tutorial, however, we’re going to use the `Code` view. At the bottom of the Layout pane, click on the `Code` tab and the Keyman code is displayed:
+
+```keyman
+store(&VERSION) '10.0'
+store(&NAME) 'Dagbani'
+store(©RIGHT) 'Copyright © SIL Global'
+store(&KEYBOARDVERSION) '1.0'
+store(&TARGETS) 'any'
+store(&BITMAP) 'dagbani.ico'
+store(&VISUALKEYBOARD) 'dagbani.kvks'
+store(&LAYOUTFILE) 'dagbani.keyman-touch-layout'
+
+begin Unicode > use(main)
+
+group(main) using keys
+```
+
+- Choose one of the following two options (which produce equivalent results). You can type the lines or copy and paste from the tutorial. The first option lists a separate rule for each character. This may make it easier to understand what the rules do. The second option makes use of features in the Keyman language that allow more compact rules to be written.
+- Option 1: Add the following lines after the `group(main) using keys` line. Each line has the code to generate one character based on “;” and a base key.
+
+```keyman
+";" + "e" > "ɛ"
+";" + "E" > "Ɛ"
+";" + "o" > "ɔ"
+";" + "O" > "Ɔ"
+";" + "n" > "ŋ"
+";" + "N" > "Ŋ"
+";" + "g" > "ɣ"
+";" + "G" > "Ɣ"
+";" + "z" > "ʒ"
+";" + "Z" > "Ʒ"
+```
+
+- Option 2: Add the following lines after the `group(main) using keys` line. The base keys are placed in one `store` (storage area) and the characters to produce are placed in a second store. The third line has a single rule that does the equivalent of the ten rules listed above.
+
+```keyman
+store(basekey) "eongzEONGZ"
+store(output_char) "ɛɔŋɣʒƐƆŊƔƷ"
+";" + any(basekey) > index(output_char,2)
+```
+
+- Select the `Icon` tab on the left side of the window. This icon is displayed by the operating system when the keyboard is active. By default Keyman Developer creates a short abbreviation of the keyboard name (”DAG” in this case). You can use the color palette at the right to select different colors and click on squares in the grid to change their color. For this tutorial we will accept the default.
+- Select the `On-Screen` tab on the left. This is the keyboard image that is displayed when the uses asks for help. As you can see it’s currently blank, which is not so helpful.
+- Tick the `Auto-fill from underlying layout` checkbox at the bottom of the keyboard display.
+- Then select the `Fill from layout` button at the top. Keyman Developer fills in the keyboard. Since we didn’t modify any keys, the display shows up as a normal QWERTY keyboard. This is still useful, since the on-screen keyboard can also be used to enter text and typing on a blank keyboard is difficult!
+- Select the `Build` tab on the left, then the `Compile Keyboard` button. (Alternatively you can use the `Keyboard` menu, `Compile Keyboard` menu item to compile the keyboard. Or you can use the F7 function key as a shortcut.)
+- You should see messages at the bottom indicating `dagbani.kmn built successfully`. If this is not the case, you’ll need to examine the error messages to see what the error is and correct it.
+
+To continue the Step-by-Step tutorial move to the next page: [Part 4 - Using the Debugger](04-using-debugger)
+
+---
+
+## Using the Visual Editor
+
+At the end of the [Designing a Desktop Layout](02-designing-desktop-layout) topic, an alternative Dagbani keyboard design was mentioned.
+In that approach, typing the
+[ { ] } - _ = + \ |
+keys would produce `ɛ Ɛ ɔ Ɔ ŋ Ŋ ɣ Ɣ ʒ Ʒ`, respectively.
+
+If you wanted to implement such a design, Keyman Developer's Visual Editor would be very useful.
+When the `Layout` tab is selected on the left, Keyman Developer starts off in `Design` mode, displaying the keyboard.
+If the Character Map is not displayed on the right-hand side of the window,
+you can use the `View` menu and the `Character Map` menu item to show or hide it.
+(Shift+Ctrl+C is a keyboard shortcut to accomplish the same thing.)
+
+
+
+To assign the `ɛ` character to the `[` key, locate the desired character in the Character Map and drag it to the desired key.
+If you click on that key, you’ll see it change color and the information about it will be displayed below the keyboard layout.
+
+
+
+This shows:
+
+- `[` the default value from the QWERTY layout
+- `ɛ` the value displayed on this key for the On-screen Keyboard (OSK)
+- `U+025B` the Unicode value that the key will produce
+- `ɛ` the character that the key will produce (the equivalent of the Unicode value)
+
+The last two of these values are linked. If you change one, the other will change. Most of the time the second and fourth items will be the same, but sometimes it might be helpful to display something different than what is actually produced. If, for example, the character being produced is not visible, such as a no-break space or a right-to-left mark, it might be helpful to display `NBSP` or `RTL` or some symbol to remind the user what the key produces.
+
+Clicking on the `Code` tab at the bottom of the window displays the code equivalent of the work in the visual editor:
+
+```keyman
+group(main) using keys
++ [K_LBRKT] > 'ɛ'
+```
+
+Note that `[K_LBRKT]` is how Keyman Developer refers to the left square bracket key (the key just to the right of the “P” key on a QWERTY keyboard).
+It also accepts `'['` or `"["` as equivalent ways to refer to that key.
+
+If you were to continue this example, you would drag the `ɔ` character to the `]` key and repeat the process for the other three lower case characters. Then you would click on one of the two “Shift” keys and repeat the process for the five upper case characters.
+
+## Understanding Keyman Code
+
+Keyman’s Visual Editor (the `Design` tab) is helpful in assigning characters to keys in a consistent manner. For a simple keyboard, it may be all that you need. It’s likely, however, that you’ll need to use the `Code` tab to provide the logic needed for your keyboard.
+
+When you begin an new project (using the “Project” menu, “New Project” menu item), Keyman Developer initializes your `.kmn` file.
+With the `Layout` tab on the left selected, you will see two small tabs at the bottom of the window: the `Design` tab and the `Code` tab.
+When you switch to the `Code` tab, you should see something like the following. (This example is from the Step-by-Step tutorial.)
+
+```keyman
+store(&VERSION) '10.0'
+store(&NAME) 'Dagbani'
+store(©RIGHT) 'Copyright © SIL Global'
+store(&KEYBOARDVERSION) '1.0'
+store(&TARGETS) 'any'
+store(&BITMAP) 'dagbani.ico'
+store(&VISUALKEYBOARD) 'dagbani.kvks'
+store(&LAYOUTFILE) 'dagbani.keyman-touch-layout'
+
+begin Unicode > use(main)
+
+group(main) using keys
+```
+
+The `store()` statements at the top are called the “header” of your file.
+This is where the important information about your keyboard is stored.
+
+A summary of the elements of the Keyman header can be found in part of [another tutorial](https://help.keyman.com/developer/18.0/guides/develop/tutorial/step-3) and detailed information is in the official Keyman documentation:
+
+- [&version](https://help.keyman.com/developer/language/reference/version)
+- [&name](https://help.keyman.com/developer/language/reference/name)
+- [©right](https://help.keyman.com/developer/language/reference/copyright)
+- [&keyboardversion](https://help.keyman.com/developer/language/reference/keyboardversion)
+- [&targets](https://help.keyman.com/developer/language/reference/targets)
+- [&bitmap](https://help.keyman.com/developer/language/reference/bitmap)
+- [&visualkeyboard](https://help.keyman.com/developer/language/reference/visualkeyboard)
+- [&layoutfile](https://help.keyman.com/developer/language/reference/layoutfile)
+- [&mnemoniclayout](https://help.keyman.com/developer/language/reference/mnemoniclayout)
+
+
+## Writing Keyman Rules
+
+The body of your code begins after the header. This is where the bulk of your keyboard’s functionality will be.
+
+```keyman
+begin Unicode > use (main)
+```
+
+The preceeding line tells Keyman
+
+- to use Unicode encoding when typing characters, and
+- to look for the rules determining what characters should be produced in `group(main)` .
+
+```keyman
+group(main) using keys
+```
+
+is the default group for defining keyboard rules. This is where we will write code to implement the keystrokes you decided to use.
+
+For more advanced uses of the `begin` rule, like defining different rulesets based on typing context, see the [official Keyman documentation](https://help.keyman.com/developer/language/reference/begin).
+
+
+There are a few key terms that you must know when writing rules:
+
+**Context**
+
+The context specifies the conditions that will trigger a rule.
+If the character(s) to the left of the cursor match the context of a rule, the rule will be processed by Keyman.
+
+**Key**
+
+The key specifies which keystroke the rule will act upon.
+For more information on keys and keystrokes, read the [official Keyman documentation](https://help.keyman.com/developer/language/guide/virtual-keys).
+
+**Output**
+
+The output determines which characters are produced by a rule. When a rule is processed, Keyman will replace the context with the output.
+
+The Context (which may be empty) is separated from the Key by “+”.
+
+The Key is separated from the Output by “>”.
+
+You can include comments in your Keyman code by typing a plain `c` followed by a space then any text you like afterwards. (If you want the letter “c”, you must surround in in quotes like `"c"`.) This is a good way to document your code and make things easier to read later, both for yourself and others. Comments can be made at the end of a line (with a space before the `c` as well as after) or be on their own line. Any text that follows the `c` through the end of the line will be ignored when the keyboard is compiled.
+
+Writing rules in Keyman is very straightforward for simple key substitutions. Suppose we want circumflex plus “a” to produce the character “â”. The Keyman code is actually very similar:
+
+`"^" + "a" > "â"`
+
+In this example, the **context** is `^`, the **key** is `a`, and the **output** is `â`.
+Whenever Keyman finds the context (`^`) to the left of the cursor and the current keystroke is `a`, it will replace the context (and the typed character) with `â`.
+
+Characters written into Keyman code should always be surrounded by single quotes (`' '`) or double quotes (`" "`).
+Either pair will work (as long as they match).
+It is also possible to use the Unicode values of characters directly in the code.
+These are never written with quotes around them.
+
+The previous line of code, when rewritten to use Unicode values, looks like this:
+
+```keyman
+U+005E + U+0061 > U+00E2
+```
+
+While less readable to a human, using Unicode values for uncommon or easily confused characters is often a good idea.
+
+It's possible to use a comment to provide both the Unicode value and the character itself, for example rewriting the above line as:
+
+```keyman
+"^" + "a" > U+00E2 c â
+```
+
+At a glance, this tells you that a circumflex (`^`) combined with `a` will produce the Unicode character `â` (whose value is U+00E2).
+Including a comment at the end of each rule that shows the output character will make reviewing your code significantly easier while still being extremely clear about which characters are used.
+
+Below is an example of useful comments in the SIL EL Ethiopic Latin keyboard explaining a set of rules and each rule’s output:
+
+
+
+Some Keyman rules have no context, that is, a context that is empty. The following line:
+
+```keyman
++ "e" > U+025B c ɛ
+```
+
+is an example of the most basic rule possible. You may have noticed lines like these in your code after using the `Design` tab to edit your keyboard.
+
+Note that rules created when using the `Design` tab use [virtual key codes](/developer/language/guide/virtual-keys#common-virtual-key-codes) rather than the corresponding characters.
+This does not matter unless you are writing a [mnemonic layout](https://help.keyman.com/developer/language/reference/mnemoniclayout) keyboard. Keyman keyboards are positional by default, so unless you specify a mnemonic layout in your header, the following two lines of code will produce the same output:
+
+```keyman
++ "e" > U+025B
++ [K_E] > U+025B
+```
+
+### Stores
+
+Stores can be used to write concise rules that apply to a set of characters.
+For example, in the following code, the store called `basekeys` contains the keys for five vowels.
+A second group called `vowels_acute` contains the same five vowels (in corresponding order) with an acute accent.
+And the single rule combines the apostrophe with a base vowel to produce a vowel with an acute accent.
+
+```keyman
+store(basekeys) "aeiou"
+store(vowels_acute) "áéíóú"
+"'" + any(basekeys) > index(vowels_acute,2)
+```
+
+Thus the code above is equivalent to the following five rules:
+
+```keyman
+"'" + "a" > "á"
+"'" + "e" > "é"
+"'" + "i" > "í"
+"'" + "o" > "ó"
+"'" + "u" > "ú"
+```
+
+You can read more about the `store`, `index` and `any` keywords in the [Keyman language documentation](https://help.keyman.com/developer/language/reference/).
+
+### Deadkeys
+
+At the end of the previous topic, an example was given of using the “;” key as a “deadkey”. Typing the deadkey produces no output, but it potentially changes the output of the following key. Changing the first two rules from the Step-by-Step example to treat the “;” as a deadkey, would result in:
+
+```keyman
++ ";" > dk(1) c Define ";" as a deadkey
+dk(1) + "e" > "ɛ" c deadkey followed by "e" produces "ɛ"
+dk(1) + "E" > "Ɛ" c deadkey followed by "E" produces "Ɛ"
+```
+
+If you follow the instructions for the Debugger, you’ll find that the keystroke log is the same, but in the right-hand side of the display, the “;” is replaced by an indication of the deadkey.
+
+### Groups
+
+Groups can be used in several ways to make your code simpler and more efficient. There are two types of groups:
+
+- groups that process only the context
+- groups that process the context and the keystrokes
+
+You can read more about their uses in the [Keyman documentation](/developer/language/guide/groups).
+
+## Creating an On-Screen Keyboard Layout
+
+An on-screen keyboard (OSK) is a graphic representation of the desktop layout. It is displayed on the computer screen to show where keys are located. In can also be used to input text by clicking on the keys.
+
+Select the `On-Screen` tab on the left to display the layout (one layer at a time).
+You can manually create the OSK by clicking on a key and typing the character that should be displayed there.
+
+It is also possible to create an on-screen layout automatically based on what you have designed and coded on the Layout tab.
+(If you have manually created your on-screen layout information, you should be aware that the following automatic process will overwrite what you have created.)
+
+- Any key that you don’t reassign will have the function of the US English keyboard. If you are relying on this in your keyboard, you should tick the `Auto-fill underlying layout` box below the keyboard image.
+- Select the `Fill from layout` button above the keyboard image
+- Check the results.
+
+## Exporting an On-Screen Keyboard Layout
+
+One way to document a keyboard layout is to use images of the keyboard showing the different layers: default layer, Shift layer, Right-Alt layer, etc.
+Keyman Developer provides a way to export such images from the `On-Screen` tab.
+
+Once you have the layout (created either manually or automatically), you can use the `Export` button.
+Then complete the information needed:
+
+- Navigate to the folder where you want to create the files
+- Supply a base filename
+- For the `Save as type` field, select `Image (*.png)`
+- Select `Save`
+- In the `Output Bitmap Parameters` dialog, select `One file per shift state`, `Output Unicode keyboards`, and adjust the width of the image as needed, then select `OK`. Keyman Developer will create one or more files using the base filename plus letters to indicate the shift state plus `.png`. You can reference these files in your welcome.htm file.
+
+[< Back: Part 2 - Designing a Desktop Layout](02-designing-desktop-layout)
+
+[Next: 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..86fc2b6c469
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/04-using-debugger.md
@@ -0,0 +1,34 @@
+# Using the Debugger
+
+Part 4 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[< Back: Part 3 - Creating a Desktop Layout](03-creating-desktop-layout)
+
+[Next: 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 [https://help.keyman.com/developer/current-version/context/debug](https://help.keyman.com/developer/current-version/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.
+
+[< Back: Part 3 - Creating a Desktop Layout](03-creating-desktop-layout)
+
+[Next: 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..cd8fee607b0
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/05-designing-touch-layout.md
@@ -0,0 +1,58 @@
+---
+title: Designing a Touch Layout
+---
+
+Part 5 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[< Back: 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 the Keyman processes the keystroke information (as modified by the active layer of the touch layout) according to what is 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.
+
+[< Back: Part 4 - Using the Debugger](04-using-debugger)
+
+[Next: 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..e820856f7ee
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/06-creating-touch-layout.md
@@ -0,0 +1,151 @@
+---
+title: Creating a Touch Layout
+---
+
+Part 6 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[< Back: Part 5 - Designing a Touch Keyboard](05-designing-touch-layout)
+
+[Next: 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 [https://help.keyman.com/developer/current-version/context/keyboard-editor#toc-touch-layout-tab](https://help.keyman.com/developer/current-version/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.
+
+[< Back: Part 5 - Designing a Touch Keyboard](05-designing-touch-layout)
+
+[Next: 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..e64ba5163c0
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/07-writing-keyboard-documentation.md
@@ -0,0 +1,110 @@
+---
+title: Writing Keyboard Documentation
+---
+
+Part 7 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[< Back: Part 6 - Creating a Touch Layout](06-creating-touch-layout)
+
+[Next: 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.
+
+[< Back: Part 6 - Creating a Touch Layout](06-creating-touch-layout)
+
+[Next: 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..63be79445a6
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/08-preparing-keyboard-package.md
@@ -0,0 +1,63 @@
+---
+title: Preparing a Keyboard Package
+---
+
+Part 8 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[< Back: Part 7 - Writing Keyboard Documentation](07-writing-keyboard-documentation)
+
+[Next: 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](https://help.keyman.com/developer/18.0/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.
+
+[< Back: Part 7 - Writing Keyboard Documentation](07-writing-keyboard-documentation)
+
+[Next: 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..1580d9d2fd5
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/09-distributing-keyboard-package.md
@@ -0,0 +1,35 @@
+---
+title: Distributing a Keyboard Package
+---
+
+Part 9 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[< Back: Part 8 - Preparing a Keyboard Package](08-preparing-keyboard-package)
+
+[Next: 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 [https://help.keyman.com/developer/keyboards/](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) 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.
+
+[< Back: Part 8 - Preparing a Keyboard Package](08-preparing-keyboard-package)
+
+[Next: 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..8902f8dda4d
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/10-generating-lexical-model.md
@@ -0,0 +1,373 @@
+---
+title: Generating a Lexical Model
+---
+
+Part 10 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[< Back: Part 9 - Distributing a Keyboard Package](09-distributing-keyboard-package)
+
+[Next: 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](https://help.keyman.com/developer/current-version/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](https://help.keyman.com/developer/17.0/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](https://help.keyman.com/developer/17.0/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:
+
+
+
+[< Back: Part 9 - Distributing a Keyboard Package](09-distributing-keyboard-package)
+
+[Next: Part 11 - Installing a Keyman Lexical Model >](11-installing-lexical-model)
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..2531ab71e67
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/11-installing-lexical-model.md
@@ -0,0 +1,32 @@
+---
+title: Installing a Keyman Lexical Model
+---
+
+Part 11 of the [Keyman Developer Walkthrough](../walkthrough).
+
+[< Back: 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 [https://help.keyman.com/developer/lexical-models/](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.
+
+[< Back: 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/Aduna_anndaaka.txt b/developer/docs/help/guides/develop/walkthrough/Aduna_anndaaka.txt
new file mode 100644
index 00000000000..545a0a1ad27
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/Aduna_anndaaka.txt
@@ -0,0 +1,439 @@
+
+Adunaaru anndataako
+(Le monde est inconnu)
+
+Aysata Aamadu Siise
+e Haawa Amiiri Duwansa
+
+Un livre de contes, proverbes, etc.
+
+Ecrit par Aysata Aamadou Cissé
+Raconter par Hawa Amiri de Douentza
+
+
+
+
+
+
+
+
+© Tous droits réservés, 2001
+
+Dépôt :
+
+MELM, B.P. 33 Sévaré
+
+Jannde Fulfuldé, B.P. 34 Sévaré
+
+Puɗɗooɗe:
+ Miɗo winnda dewtere ndee fewtude e tokara am Ay Daado, abbam e mammam.
+ Haawa Amiiri Duwansa pillaniiɗo kam ɗii fillaaji e puri.
+ Teddungal manngal e MELM e PDI-MELM laatiiɓe sabaabu faa dewtere ndee waɗee.
+ Mi barkinii sanne Aminata Sidibe (Anne Lise), Abdullaayi Bari (Morten) e Umaru Siise (Ingvald Frøyen), hooreejo PDI-MELM Alayiɗi Bari, Bookar Ba, Mawluudu Dikko, balluɗo kam e gollidiiɓe am fuu e ley porojee oo.
+
+
+Aysata Aamadu Siise
+Hammadiyel kinkeƴuru
+ Ɗum waɗiino debbo gooto e gorum, debbo oo haamili tan gorko oo ɲawi, o wii o hulii! So o maayii, so debbo oo ana rima fuu hippa la'al kirtorgal makko ngal de o rima, so suka oo gorko duu o inndira ɗum Hammadiyel kinkeƴuru. O waɗi non. Ko suka oo mawni ɗum, o wii inniiko:
+• Ko tawu-mi abba ana golla?
+Inna oo wii:
+• Abba maa o donsanke.
+Cukalel ngel ɓami malfa abba mum, fiɗi lelli, jaawle e kulle ladde hokki inna mum faa ɓe ɲaama.
+ Amiiri wuro ngoo duu ana wiyee Hammadi Arɗo, omo jogii ndawwal, so ngal warii e boɓi fuu neɗɗo suusaa riiwde ngal faa ngal haara, so gawri maa timmi fuu timmii, walaa ko mbaaw-ɗaa, sabi riiwataake Amiiri jey ngal.
+ Ɲannde wootere ndawwal ngal wari watti hundoko mum e ley wowru inna Hammadiyel kinkeƴuru, inna oo huli, seli unde faa o wari, o wii:
+• Inne, ko saabi a riiwataa foondu nduu ana ɲaama gawri maa?
+Inna oo wii:
+• Miɗa hula, ɗum ndawwal Amiiri.
+Hammadiyel kinkeƴuru fii ndawwal, nanngi ngal, hirsi, hokki inna mum defa. Kaɲum duu ana defa tan ana henta nebbam ana watta e looɗe.
+ Hiiri ndawwal ngal wartaali, inna Hammadi Arɗo yalti ana tewta faa futoro, o yiitaayi. Nden o noddi garibaaɓe, o wii:
+• Njaa garbinowa e ley cuuɗi faa o faama homo hirsi ndawwal ɓiyiiko ngal.
+Non gariibu gooto wari ɗo Hammadiyel kinkeƴuru, inniiko wii:
+• Alla new gariibu
+Tan o wii:
+• Ko saabi?
+• Alla kaa newii, sabi mi warii ndawwal Amiiri annii tew faa heewi.
+O tacci tew, o hokki gariibu oo. Kam duu holloy inna Amiiri.
+ O warti fajiri faa o taƴora ɗum, o yehi suudu Hammadiyel kinkeƴuru o tawaay oon ton, o wii inna mum:
+• Yalla maataay nebbam ndawwal faa o watta e nowru taaniiko?
+Inna oo wii:
+• Maataay!
+O wari faa o yalta fuu o hawri e Hammadiyel, wii:
+• Ee! Inne kori jam waddi maa faa gaa.
+O wii:
+• Ɓinngel mon nowru mum naawata, de sabi a donsanke ngar-mi ndaardude ma nebbam ndawwal. Inna maa wii: Walaa!
+Hammadiyel, wii:
+• Inne war heey! Njehen faa mi hokke.
+Inna Amiiri yehi, Hammadiyel nanngi mo wari mo. O ɲowi daage o watti ɗum ton. Gujjo ana hetti e maɓɓe, o acci faa jemma hejjere o noddi gen gujjo oo, o wii:
+• War nanngu.
+o nanngi o resowi tew inna Amiiri ley faddaare faa e ley leeso.
+ Nde gorko oo wari nden, o wii:
+• Hannden kaa mi heɓaali fay huunde.
+Debbo oo wii:
+• Anndan Alla faddaare huurnde keɓu-ɗaa de a wii a heɓaali.
+Gorko oo wemmbaa, o wii debbo oo wadda ɗum, o waddi, ɓe itti, ɓe tawi inna Amiiri. Ɓe mbii ɓe mbonii! Sabi ɓe mbarete. Debbo oo wii:
+• En ɓaman ko njogi-ɗen fuu e aduna kokken Hammadiyel faa bilta en e bonnde ndee.
+Ɓe njehi ɓe kaalani mo ɓe kokki mo. O nanngi fuu, jawdi ndii e maayɗo oo.
+ Faa hiiri, futoro wari, o yehi caggal ngenndi o tawi ton ittooɓe njumndi, o waɗi daande makko hono daande debbo, o wii:
+• Jam hiiri kokkeree kam njumndi
+Ɓe mbii:
+• Aan homo?
+O wii:
+Miin inna Hammadi Arɗo.
+• Min kokkataa! Ko min kokki Amiiri ɗum fuu heƴataa faa ngaraa gaa mbeeraa min.
+O wii:
+• Miin so on kokkaay kam tan mi maayan.
+Ɓe mbii:
+• Maayu!
+Tan Hammadiyel faɗɗi inna Amiiri, hono ko o wii o maaya ɗum:
+• O maayi!
+Ɓe ngari ɓe tawi omo fukkii. Ɓe kuli, ɓe mbii:
+• So miɗen anndi a maayan, min kokkerete njumndi ndii fuu.
+Tan ɓe mbii:
+• En mbarete en fuu.
+ Gooto e maɓɓe wii:
+• Njehen to Hammadiyel kam tan waawi biltude en e ndee bonnde.
+Ɓe njehi ɓe kokki Hammadiyel ko ɓe njogii fuu e aduna faa nannga tew inna Amiiri oo e junngo maɓɓe. Hammadiyel wii wooɗi, nanngi maayɗo oo resi.
+ O yehi to Amiiri, o wii:
+• Tokara, mi nanii ndawwal maa lallii, inna maa lallii. Tokara, ɗaana ɲalooma de ndoomaa suudu maa jemma, ko maatu-ɗaa fuu piɗaa.
+O wii:
+• Wooɗi!
+Tan o waɗi non. Hammadiyel ɓami tew inna Amiiri, wari galle Amiiri ley jemma waɗi koso-koso Amiiri ɗojjini malfa mum, fiɗi ɓanni inna oo heɓi ɗum ɓecce, o fukkini ɗum, o dilli.
+ Fajiri wari, Amiiri wii:
+• Hankin mi fiɗii huunde kaa mi anndaa ko ɗum.
+Ɓe tawi inniiko, o ɓami ɗum, o irowi ɗum. Amiiri wii ɗum golle Hammadiyel, noddanee kam o wara. Hammadiyel kam wari inniiko e ndawwal makko. Hammadiyel wii:
+• Ngoonga, sabi ndawwal ngal ɲaami gawri innam, mi warii ngal, inna maa wari martude kumpa, mi warii ɗum.
+Amiiri lamndii hono o haani waɗeede. Ɓee mbii o hirsee. Ɓee mbii o hettee kusel kusel. Ɓee mbii o duppee, mo waree. Hammadiyel lamdii yalla ana waawi haalude, ɓe mbii omo waawi. O wii:
+• Maayo men ngoo, won naɗɗo e maggo so yalti abada?
+Ɓe mbii:
+• Walaa.
+O wii:
+• Amiiri, kokkaa maccuɓe maa ɓee ngaari ɓe kaɓɓa kam faa mi yoora, ɓe pukkina kam daande maggo ɓe ɲaama tew nagge oo faa ɓe kaara, ɓe kunca kam ɓe paɗɗa kam e ley maggo.
+Maccuɓe fuu mbii:
+• Ngoonga, ngoonga!
+Ɓe ngarri non. Hammadiyel ana fukkii daande maayo ngoo ana doomi.
+ Faa gorko goɗɗo feri wuro muɓɓen, sabi mawniiko laaminoo ko oon maayi ɗum omo haanunoo laamaade, kaa wuro ngoo wii Hammadi amiiri maayɗo oo ɓurani ɗum, tan o ɓerni o feri. O tawi Hammadiyel ana haɓɓaa ana fukkii. O maati koyɗe puccu gorko oo fuu, o fuɗɗi wullude, o wii:
+• Mi laamataako dee kinaa mi laamoo, mi waawaa ittude jakka, mi waawaa ittude muddi, de so mi laamaaki fuu, on paɗɗan kam e ley maayo.
+Gorko oo nani, darii, wii kam kaa ana yiɗi laamaade. Hammadiyel wii:
+• Humtan faa mi haɓɓe tan.
+Ɓe ngaɗi non.
+ Hammadiyel hooƴi puccu makko waɗɗii, wii mo:
+• So ɓe ngari fuu mbiyaa: Miɗe laamoo, tan ɓe kumtete laamowo-ɗaa wuro ngoo.
+O wii:
+• Wooɗi.
+Nde maccuɓe ɓee tilii ɲaamde ngari kunci mo, o wii:
+• Miɗo laamoo
+Ɓe nootaaki, ɓe paɗɗi mo ley maayo, ɓe mbii:
+• O haanɗii.
+ Hammadiyel hooti suudu muɓɓen ina ɲaama, ana ɲammina puccu mum, faa ɓe payi sanne. Njumndi ndi o heɓunoo ndii, o wii inniiko:
+• Moƴƴinanam jiminta maaro e jiminta gawri.
+Ɲannde wootere o pari puccu makko faa gasi, o watti jiminta oo e ley danngaaji puccu makko. O yehi suudu Amiiri. Puccu kuu fayi faa ana hulɓinii. O wii cile tati:
+• Assalaamu aleykum tokara
+Amiiri nootii, o wii ɗum:
+• Puccu kuu yo ndoontoori laakara
+O hokki ɗum jiminta maaro, o wii ɗum:
+• Oo dumo maaro
+O jiminta gawri oo, o wii:
+• Dumo mbayeeri, kaa mi heɓaali dumo gawri, sabi rewɓe cottaali gawri.
+Saaraaɓe maa ɓee ana njiɗi yiide ma.
+O wii:
+• Hono ngaɗan-mi?
+O wii:
+• Kokkaa maccuɓe maa ɓee ngaari, ɲaama, paɗɗe e ley maayo a yiidan e laakaraa a yiyan inna maa e abba maa.
+O wii:
+• Wooɗi.
+O waɗi non, ɓe paɗɗi mo e ley maayo. Tan Hammadiyel warti suudu, o wii:
+• Abada on njiyaay maayɗo so warti, nii mo warti!
+O wii:
+• Amiiri maayii. Mo jokkaay kam fuu, mi waran ɗum.
+O laatii Amiiri. O ɓamti rewɓe Amiiri, suudu Amiiri nduu o watti inniiko, o laamii wuro ngoo!
+Debbo e ɓiyum debbo
+ Waɗiino e jamaanuuji, debbo gooto e gorum ana ngondi, kaa ko debbo oo rimi fuu, gorko oo ɲaaman. Faa ɲannde wootere o rimi ɓiɗɗo debbo, o wii gorko oo:
+• Sabi Alla accanam ngel kaa, faa mi yiya engel ŋaara.
+• Haya so ngel waawi fuu, mi ɲaaman ngel.
+Worri non, faa ngel waawi ŋaarude, gorko oo wii:
+• Sarti oo yottike, mi ɲaaman ngel.
+Inniigel oo wii mo kasen:
+• Accanam mi yiya engel surbinɗina, sabi abada mi yiyaayi ɓiyam surba.
+Ɗum welaali gorko oo, kaa o hulii gite debbo oo, o wii o jaɓii.
+ Nii debbo oo haaldi e baylo sehana ɗum leggel ɗo suka oo waawi naatude. Inna oo soodi kaŋŋe, cardi e kaddule faa keewi, o watti e ley leggel ngel.
+ Ko ngel surbinɗini koo, abba oo wii:
+• So weetii fuu mi teenoya leɗɗe, de mi warta mi ɲaama cukalel am ngel.
+Debbo oo wii:
+• Mi jaɓii.
+Fajiri law gorko oo dawi teenoyde leɗɗe faa wara ɲaama ɓiyum oo.
+ Debbo oo wii ɓiyum oo naata ley leggel ngel de doga, sabi so abba mum tawii ɗum ɗoo fuu, ɲaaman ɗum.
+• Ɗo njaa-ɗaa fuu mbiyaa: «Giɗo Alla ɗo leggel ɓaaroo.»
+Suka oo wii wooɗi, o waynondiri e inniiko, o dilli faa abada.
+ Debbo oo dogi, naati ley wuro, soodi mbeewa paynga faa sanne, o hirsi nga, o defi faa ɓenndi, mukisii.
+ Nde gorko oo wartunoo teenoyde ndee tawi tampii, yolbii faa sanne. Ndeen debbo oo wii mo: Mi heppii ma, mi hirsanii ma suka oo, mi defii faa ɓenndii.
+ Ɗum weli gorko oo sabi tawii yolbii sanne, o ɲaami, kaa o wii:
+• Tew oo walaa dakam sabi suka oo ƴaanɗii.
+Kaa o annditaali ɗum tew mbeewa.
+ Suka oo caggal wittii, yehi e wuro wooto, wii:
+• Giɗo Alla ɗo leggel ɓaaroo.
+Neɗɗo gooto wii mo:
+• Ya suudu Amiiri.
+Mo yehi, mo lamndii Amiiri, o hollaa, o tawi ton inna mum, o wii noon, inna oo wii mo:
+• War, doomu faa Amiiri wara, so mo jaɓii tan gasii.
+ Ko Amiiri wari koo, inna mum haalani ɗum haala suka oo. O wii:
+• So o jaɓii, so tawii puccu am kuu ana silla fuu, mo yalta ku silla dow makko, so ɲallooɓe am ɓee ana tutta, naa ana kaartoo tutta dow makko. So mo jaɓii ɗum nii, annii, o heddoo ɗoo, so mo jaɓaali ɗum duu, mo yalta suudu am nduu.
+Leggel jaabii, wii:
+• Mi jaɓii abba.
+ Mo worri non ley galle Amiiri oo, faa ɲannde wootere, wiyaa: Kuurtungu ana waɗa e gure ɓadiiɗe ɗee, Amiiri’en cihe ɓadiiɗe ɗee fuu ngaran, kawra ton. Noon njaatigi leggel oo duu yehi.
+ Leggel wii debbo mawɗo oo ana yiɗi kaɲum duu yaade e kuurtungu oo. Debbo mawɗo oo jaabii, wii:
+• Miɗo hula, sabi so Amiiri yii ma ton fuu riiwete e galle mum oo.
+Leggel wii:
+• O yiyataa kam, sabi kanko, to fijooji e kelle ton mo tawetee, miin to unooɓe e defooɓe ton ngon-mi.
+Inna Amiiri wii mo:
+• Wooɗi, tinna pati o yiye.
+ O yehi faa mo ganndii wuro ngoo, o fanti waande, mo yalti ley leggel ngel, mo parii faa gasi, mo watti masiri makko faa mo wooɗi, mo ɓaari leggel ngel e waande ndee, nii tan mo foonndii wuro ngoo to ɲallo Amiiri’en ton jaati.
+ Nde Amiiri njaatigi makko oo soyninoo mo ndee, wii:
+• Cuggam e surba debbo garoowo ton oo.
+ Amiiri oo immii, sakkitii leggel, joƴƴini mogere mum, hirsani ɗum mbaalu payɗo, ɓe njooɗii eɓe ngaajoo, Amiiri itti hootonnde mum hokki mo, kaa annditaali yalla ɗum leggel.
+ Ɓe ngondi e ɲallo faa hiiri, surba oo wii hootan. Jamaa oo fuu ɗowti ɗum faa anndi ɓadike waande ndee, wii:
+• Njoppee kam ɗoo.
+Ɓe kokki mo koyngal tew kirsaandi makko ndii, ɓe mbaynii mo, ɓe mbaylitii.
+ Nde leggel seli yiide ɓe ndee, naati ley leggel mum, dogi faa e debbo mawɗo oo, wii:
+• Hee yimɓe ton ɓee ana caahii faa sanne! Sabi mi wallii ɓe defude tan, ɓe kokki kam koyngal mbaalu.
+ Debbo mawɗo oo, ɗum weli ɗum faa sanne, wii:
+• Gasii. Kaa kori Amiiri yihaali ma?
+O jaabii, o wii:
+• Mi yaltaali ley kaatane gila njaa-mi.
+ Ko Amiiri warti koo, puccu mum kuu wari faa silla, Amiiri heddii ana duka:
+• Hoto leggel woni? Puccu kuu annii silla, a yaltataa naa?
+Leggel dogi warde faa puccu kuu silla dow mum. Inna Amiiri defi tew oo, kaa o haalani Amiiri taakallemme makko hokki mo tew oo, sabi mbaalu mum waati.
+ Ko ɓe ɲaami koo, Amiiri wii:
+• Inna, dawol hewtike kam, ngaɗanaa kam cobbal so weetii, mi jahoowo caggal maayo.
+Inna uni gawri faa waɗa cobbal tame. Nde mo tamata ndee, leggel wii:
+• Accu miin duu mi tama fay so gootel.
+ Inna oo jaɓaali, kaa o siini. Nde inna oo hokkunoo mo ndee, mo tami ɓooɗel gootel, mo tamdi ngel e hootonnde nde Amiiri hokkunoo mo ndee.
+ Caggal weetii, Amiiri oo e jamaa mum ndawi caggal maayo. Fade maɓɓe lummbude maayo ngoo, Amiiri oo wii ɓe:
+• Taƴen kooƴol de lummben.
+ Amiiri hokki homo fuu ɓoodde, gootel tusukel keddiingel ngel woni ngel leggel tamidi e hootonnde ndee, ɗum laatii ngeɗu Amiiri. Nde mo fecci ngel ndee, mo yii hootonnde ndee, mo ƴeewi faa gasi, mo tawi ɗum hootonnde makko nde mo hokki surba debbo oo jaati ndee. O wii jamaa oo:
+• Accanon kam hakke, mbirfo-ɗen wuro, sabi hoore am ana naawa kam sanne, mi waawaa yaade.
+ Ɓe coƴƴii. Mo yaafii jamaa oo, o wii inniiko:
+• Homo tami cobbal ngal?
+Inna oo huli faa sanne, wii:
+• Miin jaati tami.
+O holli ɗum Alla, haala ngoonga; inna oo wii:
+• Wallaahi mi fenataa ɗum.
+Ndeen inna oo wii:
+• Leggel tamii.
+Amiiri oo wii:
+• Inna, mi ɓaman Leggel.
+inna oo yowi junngo mum dow hoore mum ana wulla, ana wiha:
+• Hammadi am haanɗii. Sabi wii ɓaman Leggel.
+ Amiiri yehi e debbo mawɗo faa lamndoo ɗum hono watta so surba oo yalta ley leggel ngel. Debbo mawɗo oo jaabii, wii:
+• O waalataa ley maggel. Horu mo, so mo yaltii fuu, kakkilaa, jawdi mawndi ana ley leggel ngel, mbaylaa ndi faa ndi laaɓa, de cumaa leggel ngel.
+ Nde jemma warnoo ndee, Amiiri acci faa Leggel yalti ley leggel ngel fukkii, ɗaanii. Mo warri no debbo mawɗo wiiri mo nii. Surba oo nde ɗemƴii ndee tawi jawdi mum fuu dow daago, leggel ngel sumaama; mo anndi ɗum yo golle Amiiri.
+ Nde weetunoo ndee, inna yii surba e jawdi ndii, o darii omo woma, omo wiya:
+• Hammadi am huurtinii kaŋŋe, hammadi am huurtinii cardi.
+Nii Amiiri huurtiniri mo ley galle mum.
+
+
+Sukaaɓe rewɓe taton
+ Ɗum waɗiino, sukaaɓe rewɓe taton: Diko, Kummbo e Penndo. Eɓe kiira jemma faa Diko oo wii:
+• Miin kaa, Alla wan mi laatoo gen moƴƴinoowo buuru Amiiri oo.
+Kummbo oo duu wii:
+• Miin kaa, mi laatoo gen Amiiri oo jaati ɓurani kam.
+Penndo oo duu jaabii:
+• Miin duu, mi laatoo gen duppoowo tew makko tan, mi ɲaama tew faa mi haara.
+ Amiiri wuro oo duu jemma fuu ana yiiloo ley wuro faa nana ko yimɓe wuro kaalata e mum. Tan o nani ko sukaaɓe rewɓe taton ɓee kaali. Nde weeti nden, o neli maccuɗo makko nodda ɓe ngara. Ɓe ngari, o wii ɓe pilloo ko homo fuu haalnoo. Nden o warri non: Diko oo ɓamaa jom buuru. Penndo oo duppoowo tew, Kummbo oo, Amiiri oo jaati.
+ Ɓe ngorri non faa Kummbo inne ɓami reedu. Nde o maati ndimu nden, o neli e Diko inne wara. Nde o warata nden, o saawi ley saaya makko ɓinngel bilel baatungel.
+ Diko inne wii:
+• Kummbo inne, mummu gite maa, sabi so neɗɗo ana rima fuu uddan gite mum.
+Kummbo inne warri non. Nde o rimi nden, Diko inne suumi suka oo pati ewa, o faɗɗi ley doginirgol, o lelni ɓinngel bilel baatungel. Kummbo inne mettaa sanne, kaa faamaali ko mawnum oo waɗi ɗum.
+ Ko ɓami reedu ɗiɗaɓurdu nden duu, o warri non. Kaa nden, ɓinngel ŋusuwel baatungel o waddi. Nde tataɓurdu nden duu, hayre o saawi, o waddi.
+ Deeɗi tati ɗi Kummbo inne rimi ɗii fuu wo ɓiɓɓe worɓe: Hammadi, Sammbo e Yero. Nde Diko inne faɗɗi ɓiɓɓe ɓee fuu, ndegoroo doginirgol ngol faa naatawa ley sardiŋe gorko mawɗo e genndum, ɓe ndimaali abada. Aranndeejo oo nde ɓe koocci ɗum ɓe kuyi ɓe mbii:
+• Alla yurmike en, neldi en ɓiɗɗo.
+Ɗiɗaɓo oo e tataɓo oo fuu, non ɓe miili.
+ Nii non ɓiɓɓe taton ɓee keddii e junngo gorko mawɗo e debbo mawɗo faa ɓe mawni, ɓe laatii jokolɓe, faa mawɓe ɓee maayi, ɓe keddii e nokku maɓɓe.
+ Ɲannde wootere, hammadiijo oo hooƴi malfa mum yehi lowangal.
+ Amiiri wuro ngoo, ɗum woni abbiiɓe jaati, oon duu yehi lowangal. Homo fuu yii lella ngaa, homo fuu enndi nga, felli nga faa homo e maɓɓe fuu sikki kaɲum tan felli nga. Nde lella ngaa saami nden, hammadiijo oo yehi faa ɓama nga, Amiiri oo duu neli maccuɗo mum hoccawa lella ngaa. Nden homo fuu wii: «Miin fiɗi nga.» Nde Amiiri oo wari yii suka jokolle oo yiɗi mo ley yonki mum sanne, kaa anndaa mo. Nde ɓe kaaldi nden, Amiiri oo wii o hooƴa lella ngaa, hokki mo nga. Ɗum weli mo sanne. Kanko duu o wii:
+• Faa mi yoɓe ngal teddeengal, ngaraa ɲallanaa kam alan garoowo nokku am ley ladde.
+Ɗum weli Amiiri, jaɓani mo teddeengal ngal.
+ Homo fuu hooti suudu mum. Hammadiijo oo narriino gorko mawɗo oo e nguurndam mum ana haala ndiyam kaaloojam e foondu haalooru. O wii sanaa o waddana Amiiri oo huunde teentiliinde nde oon woowaa yiide. Sabi teddinɗo mo warata suudu makko.
+ Dow sifa gorko mawɗo oo, o jokki laawol omo yaha faa o tawi: Annii ley ladde ndee ginnaaji. O wii faa o welloo fuu, ɗi keddii eɗi paɗɗa mo kaaƴe, o nootaaki. Omo yaha faa o tawi kasen goɗɗi ana njala mo, o nootaaki. Faa o yehi o ɲeɗi ndiyam kaaloojam ɗam, o nanngi foondu haalooru nduu. Ginnaaji ɗii ummii ana caaƴa sanne faa kulɓina mo. Kaa o hulaali fey, faa o warti. O lalindii faa gasi, kanko e miɲiraaɓe makko, jaɓɓaade Amiiri maɓɓe. Kaa ɓe anndaa salla abbiiɓe.
+ Nde Amiiri oo wardi e yimɓe mum, ɓe njaɓɓitii mo ɓe ngaajii sanne, ɓe ɲaami faa ɓe kaari o holli ɓe nokku makko, sardiŋe makko e foondu nduu e ndiyam kaaloojam ɗam. Ko foondu nduu yii ɓe ɗum, wii:
+• Amiiri, ɓiɓɓe ɓee ɓiɓɓe maa!
+Tan o fillorii gila nde sukaaɓe rewɓe taton ɓee mawniri, faa e lella ngaa. Tan, ɓe fuu ɓe kaaynaa, ɓe njurŋinii, ɓe mboyi, ɓe ƴeewondiri, ɓe nanngondiri juuɗe. Amiiri oo wii:
+• Ngaree faa kooten.
+Hammadiijo oo haalani miɲiraaɓe mum, ɓe njaɓi. Kaa Hammadi wii:
+• Faa horra foondu nduu e ndiyam ɗam to tawi ton tafon.
+O warri non.
+ O warti, o yaadi e abbiiko e miɲiraaɓe makko to inniiɓe, kam duu, ko haalanaa ɗum seyii sanne. Kaa Diko inne, nesi mum taƴi laatii waande.
+
+
+Taali
+Mi yehii wuro, baabam hokki kam lonngere ndonku-mi timminde.
+Mi yehii wuro baabam, taw-mi ɓiɓɓe am ɓee fuu woɗeeɓe.
+Njoƴƴin-mi jommbaajo am dow laawol, bellotooɗo fuu wiyan kuyuuja.
+Leelewal ley leeso.
+Mbana yahataa, mbana warataa, yawooɓe ndaɗataa mbana.
+Ɓiɓɓe am ɓee fuu wo sukuɲaaɓe.
+Teketol mbuubu heewi ganure (loonde mawnde).
+Kaatane ley ndiyam.
+Mi lummba maayo, mi lummbita maayo, mi tappa paɗe am colla ana runnda.
+Getogel ɓalewel ley toggere ɓaleere.
+Jabaabu
+1. Kaata
+2. Gelleeje
+3. Njaaɓi
+4. Ɓoccooɗe
+5. Laawol
+6. Padakaaje
+7. Tuundi ley yitere
+8. Gangariije
+9. Ɓoye
+10. Tennga ley hoore
+
+
+Amiiri wuro lobbo ŋari sanne
+ Dum waɗiino, amiiri wuro wooto, o ŋarɗi faa sanne faa omo hoolii hoore makko. O wii so wanaa debbo ɓurɗo mo ŋari fuu, o ɓamataa ɗum. Yimɓe ana tewta faa ɓe njii e wuro wooto, ɓe tawi suka debbo lobbo sanne faa ana ɓuri amiiri oo ŋarɗude. Nii ɓe kaalani ɗum. Nde weeti nden, o humi puccu makko yaade ton. O tawi no wiiraa noon worri. O ɓami suka oo to abba mum, o wii o hokkan abba oo muddiije kaŋŋe sappo. Abba oo wii ɗum heɓataa ɓiyum. Amiiri oo ana terma faa o wii:
+• Mi hokkete muddiije teemedere.
+O jaabii:
+• Heɓataa.
+O wii:
+• Ndeennoo ko heɓata ɓiya oo?
+Abba oo jaabii, wii:
+• Amaana heɓata ɓiyam oo. Miɗo ndaarde pati o tampa, pati o heyɗa, pati o ɲaanoo faa abada.
+Amiiri oo wii:
+• Nanii, jaɓii.
+Hokki mo aadi faa abada o jippataako sooro, o yihataa naange.
+ Amiiri oo huurtini mo, yaadi e makko wuro mum. Faa ɗum waɗi lebbi, tan suka oo wokkiti, nii fuɗɗi wullude. Jom suudu makko lamndii mo ko o woyata, maa ko ɲakani mo e aduna. O jaabii, o wii o yeewaa. Gorko oo lamndii ko yeewtinta mo. O wii omo yiɗi tiimtorgal kaŋŋe ngal o tiimtoroo, ana yeewtina mo.
+ Hono naanen, wayluɓe noddaa, tafi tiimtorgal ngal, ngal ŋeɲaa kulle ladde faa ngal heewi. Ɓe ngorri noon faa ɲannde wootere, gorko oo yalti fajiri law, tan suka jokolle lobbo ŋari sanne, kaa o gariibu o walaa fay huunde. O garbinii debbo oo, hokka mo sabi Alla ko ɓuri fuu yidde e adunaaru nduu. Debbo oo jaabii:
+• Ko ɓur-mi yidde e adunaaru nduu kaa yo ɓiɗɗo, kaa mi walaa. Kaa miɗo jogii tiimtorgal kaŋŋe ngal njiɗu-mi sanne, ngal goram tafani kam faa mi yeewtira.
+Hono ngal, hokki mo ngal saabi Alla mo o inndi oo.
+ Gariibu oo yehi wuro mum`en, ana tacca seeɗa seeɗa e kaŋŋe, ana sootta, ana laatoo jom jawdi faa gasi. Omo warra ko Alla, wuro ngoo hoolii mo, hokki mo laamu.
+ Caggal debbo oo hokkii gariibu oo tiimtorgal ngal, gorko oo wayri yiide debbo oo ana tiimtoo. O lamndii ɗum no tiimtorgal ngal waɗi, debbo oo haalani mo no waddi e gariibu oo, gorko oo bilaa sanne faa mo wii:
+• Hollam junngo ngo kokkir-ɗaa gariibu oo tiimtorgal ngal
+O holli junngo makko ɲaamo, gorko oo nanngi ngo tacci ngo, seeri debbo oo, riiwii mo, mo yalta e galle mum.
+ Debbo oo woowaa naange, mo tampi sanne fade makko jippaade sooro ngoo, o fonndii wuro maɓɓe. Ɲalooma fuu, mo suulta ley leɗɗe kaa jemma fuu mo yahan, faa mo tampi, mo daali.
+ Sukaaɓe jokolɓe ɗiɗon tawi mo ley ladde, ɓe njurmii mo, ɓe lamndii mo ko foti waddude mo ɗoo, o fillanii ɓe. Ɓeen mballi mo faa mo yottoyii abbiiko. Abba oo barkini sukaaɓe jokolɓe ɓee sanne.
+ Gariibu mo mo sakkii tiimtorgal kaŋŋe ngal oo ana tewta debbo faa yimɓe kaalani ɗum haala debbo oo. Kaa mo anndaa salla ɗum gen kaananke cakkuɗo mo oon noon. O ƴami, o hokkaa ɗum, o huurtini ɗum. Kaa no debbo oo foti woodde, o taykaaki salla junngo mum ko taccaa. Nde kuurtungu oo dammbitii nden, gorko oo se’ini laana faa ɓe njaha wuro maɓɓe.
+ Debbo oo sulli sanne, sabi junngo mum yo tayngo, mo ɲaagii Alla suura mo pati yimɓe anndita mo guddo.
+ Saabi Alla mo gariibu oo wardi e makko oo so mo hokki ɗum tiimtorgal ngal, nde saabanii mo junngo tayngo ngoo.
+ Debbo oo fukkii ley jemma, o fini e baawɗe Alla, o tawi junngo ngoo dobii.
+ Debbo oo yettiri Laamɗo ko waɗani ɗum koo. O wondi e goriiko faa Alla hokki ɓe ɓinngel gorel, gorko oo ana horsini ngel sanne. Gorii debbo oo aranndeejo oo, taccuɗo junngo makko oo, ana yaara caggal fajiri fuu, gilla nde mo tacci junngo debbo oo ndee, faa o timmini jawdi makko, faa omo garbinoo. Wuro ngoo ittii mo e amiiraaku. Omo yaha, omo garbinoo faa mo nani haala Amiiri wuro jom jawdi oo. Fajiri law, o wari e gen amiiri oo, tawi gorko oo yaltidi e ɓinngel mum gorel ngel faa ɓe njiildoo e ley wuro fade naange wulde.
+ Amiiri talkinɗinɗo faa laatii gariibu oo, wari e debbo oo, wii:
+• Fii sabiilillahi! Hokkam ko ɓur-ɗaa yiɗude e adunaaru nduu fuu.
+Debbo oo jaabii, wii:
+• Subahaanahuu! Ko ɓur-mi fuu yiɗude e adunaaru nduu, yo ɓinngel am gorel, ngel nee abba mum yaltidii e mum, kaa miɗo jogii goje kaŋŋe ɗe goram tafani kam faa mi yeewtira, miɗo yiɗi ɗe sanne.
+Debbo oo hooƴi ɗe, hokki mo. Nde mo wari faa mo jippoo sooro ngoo ndee, o hawri e gorko oo. Oon wii mo:
+• Yaa yoppoy ko kooƴu-ɗaa ɗum, a gujjo.
+Debbo oo jaabii:
+• A wihaay miin hokku maa naa?
+Ndeen o fillanii gorko oo no ɓe ngaddi. Ɗum welaali gorko oo sanne, kaa mo miccitii no mo sakkiraa tiimtorgal kaŋŋe ngal nii e junngo gen kaananke oo. O yamiri hoorɓe loota mo, kokka mo kaddule kaɲum e ko mo ɲaama, kanko kaa mo yalti.
+ Gorko koɗo oo ana ɲaama, ana ƴeewa debbo oo, laatii hono annditii ɗum nii, kaa omo anndi oon junngo mum ko taccaa.
+ Mo lamndii debbo oo yalla ana anndi debbo mo junngo mum taccaa, gen amiiri kiiɗɗo naa? Debbo oo duu wii:
+• Aɗa nanndani kam e goram aranndeejo, kaa oon kaa wanaa gariibu, o kaananke wuro.
+Gorko jaabii, wii:
+• Miin noon
+Debbo oo duu wii kaɲum noon! Kaa Alla dobii junngo mum ngoo.
+ Ɓe ɗiɗon fuu ɓe kaayɗinaa, ɓe mbemmbaa, ɓe tawi ɗum Alla fodi. Ko goriiko oo warti koo, mo fillanii ɗum no ɗum laatirii. Gorko oo wii mo: Miin duu, miin woni gariibu mo cakku-ɗaa tiimtorgal kaŋŋe oo. Homo fuu annditi banndum, simtiri, anndi Alla waawi.
+ Ndeen amiiri gorii debbo oo, wii o ɲiɓanee sooro hono ngo mum ngoo, o naati. Wii o suɓoo debbo mo o yiɗi ley wuro ngoo fuu, ɓamani mo, ɓe ngondi faa abada.
+
+Puri
+11. Mi hawrii e pooli: wooturu nduu ana ardii ɗiɗi, wooturu nduu ana hetti caggal ɗiɗi, wooturu nduu ana tummbii hakkunde ɗiɗi. Hono foti ɗii pooli?
+Miɗe yaha luumo, pantu-mi esam, o neldi kam buuɗi makko teemedere, o wii: Mi soodana mo daabaaji: bey, baali e nay faa daabaaji ɗii kiɓɓa teemedere. Njaa-mi luumo, taw-mi nagge fuu buuɗi joy, mbaalu fuu mbuuɗu, bey joy fuu mbuuɗu. Hono ngaɗan-mi faa teemedere ndee heɓa daabaaji teemedere, pati mbuuɗu fuu heddoo?
+
+Jabaabu:
+12. Pooli ɗii yo tati
+Mi soodan nay sappo, laatoo buuɗi debe e sappo, baali debe laatoo buuɗi debe, bey debe e sappo laatoo buuɗi sappo.
+No debbo gooto foti yiɗude adunaaru
+ Waɗiino e jamaanuuji debbo gooto, wii so rimi ɓiɗɗo ɓurɗo ɗum ŋarɗude fuu o faɗɗayan ɓinngel ngel ladde. Alla waɗi o rimi ɓiɗɗo debbo, yimɓe fuu mbii ɓiɗɗo oo ana ɓuri inna oo ŋarɗude. Inna oo acci faa suka oo ƴoƴi. Ɲannde wootere omo yaha teenoyde, o naɓi cukalel ngel ladde. Caggal o tilike teenude o joƴƴini cukalel ngel ley lekki bannge waande, o wii ngel dooma mo, jooni o waran. Nii o hooti cuuɗi, o yoppi ngel ton.
+ Cukalel ngel doomi faa tampi engel wulla. Gorko gooto ana waɗɗii ngeelooba, wari tawi cukalel ngel ana wulla, o lamndii ngel, ko saabi so engel wulla? Ngel wii mo:
+• A yiyanaali kam ton innam naa?
+Gorko oo wii ngel:
+• Hoto inna maa jeyaa?
+Ngel jaabii gorko oo:
+• Mi anndaa!
+ Ngel yurminii gorko oo faa sanne, nii o ɓami ngel, o waɗɗini ngel dow ngeelooba makko. Tawi suka oo inna mum haɓɓaniino ɗum ceede tati e keeci mum. Suka oo ɗo waɗɗii dow ngeelooba ngaa, hunti ceede mum ɗee haɓɓi e samme ngeelooba gorko oo, eɓe njaha faa ɓe njottii ngenndi ngootiri, o naɓi suka oo to Amiiri ngenndi ndii, gorko oo fillanii yimɓe ngenndi ndii no o hoocciri suka oo ley ladde. Nde gorko oo wii faa witta nden: Suka oo heddii ana wulla, wii kaɲum jey ngeelooba ngaa. Haala kaa laatanii yimɓe ngenndi ɓee wemmbere. Ɗum laatii sariya hakkunde maɓɓe. Yimɓe ngenndi ɓee mbii suka oo holla maande mum. Suka oo wii:
+• Ceede tati ana kaɓɓii e samme ngeelooba ngaa, miin jey nga.
+Gorko oo hunii waatii so ceede tati tawaama e samme ngeelooba ngaa fuu, o harminii nga faa yeeso Alla. Nde yimɓe ngenndi ɓee ƴeewunoo nden, tawi ceede tati ana kaɓɓii e samme magga. Yimɓe ɓee mbii:
+• Suka oo ngoongoto, kaɲum jey ngeelooba ngaa.
+Nii gorko oo jippii hokki suka oo ngeelooba ngaa, wittiri koyɗe ɓole ɓernde mum ana woya.
+ Suka heddii e junngo Amiiri faa o laatii surba debbo, sakiraaɓe makko anndaaka. Amiiri ngenndi ndii huurtini suka oo, sabi kaɲum duu ɓooyii heɓaali ɓiɗɗo. Ko o ɓami suka oo koo kaɲum duu ɓooyi rimaali, kaa ana jogii korɗo mum debbo kaamilɗo, o wii ɗum so rimii fuu hokka mo ɓinngel mum ngel, de ko yiɗi fuu waɗa ley galle ton - korɗo debbo oo jaɓani mo. Kanko suka oo lewru fuu o ɓama licce o watta ley reedu makko faa korɗo debbo oo maati ndimu mum. Yehi rimoy to suka debbo oo, o lootii faa o laaɓi. Suka debbo oo jooɗii ley ƴiiƴam ɗam gere ɓinngel ngel, o neli Amiiri haalanee o rimii o heɓii ɓiɗɗo gorko.
+ Amiiri e jamaa mum fuu kuyi faa sanne, sabu abada o heɓaali ɓiɗɗo. Ɲannde wootere omo womina ɓinngel ngel fuu, o wii:
+• Coo wajjere, coo wajarde, inna maa waawi bonnde teetii joom ngeelooba mum, teetii ma aan duu inna maa.
+Tawi jokko Amiiri gooto warii faa yara ndiyam, nani haala kaa tan, wii debbo oo:
+• Eyyo! Ɓiɗɗo oo wanaa ɓiya naa?
+ Debbo oo jaabii, wii mo:
+• Gilla Amiiri laatii giɗo maa a yarii cobbal makko njumndi ngal na?
+ Gorko oo gila nani haala cobbal ngal tan, yeggiti haala ɓinngel ngel. O wii:
+• Abada o yaraali ngal cobbal.
+Debbo oo naati ley suudu yaltini hokki mo, o yari. Debbo oo wii mo o loota hunduko makko pati Amiiri oo anndita. O looti hunduko makko, debbo oo wii:
+• Laaɓaali. Sabu ɗemngal maa ngal ana oolɗi, waddu mi heefene faa laaɓa pati Amiiri anndita.
+ Nii o ɓattii debbo oo nanngi ɗemngal ngal tacci. Ƴiiƴam heddii ana jooroo. Gorko oo fonndii bolongal Amiiri, nde o yottii ndee, yimɓe ngonnooɓe ɗoon ɓee fuu immii cakkitii o faa lamndoo mo, nii o sappii debbo Amiiri oon. Debbo oo lamndaa, jaabii ɓe, wii kaɲum kaa yiino omo dardii e jom`en pucci, kaa anndaa ko ɓe kaaldi, tawan ɓeen tacci ɗemngal makko so ndilli. Wakkati oon fuu Amiiri wii:
+• Pucci kumee, pucci kumaa.
+Wii ɓe tewɲa jom`en pucci ɓee.
+ Jamaa oo tewɲi henndu, njiiloyii faa tampi ɓe njiyaali fay huunde, nii ɓe ngarti.
+
+
+
+Taali tacciti:
+13. Debbo lobbo mo ɓamataake
+Ɓiɓɓe am ɓee fuu ɓe kumitirngol gootol
+Kaɓɓu-mi puccu am ley suudu laaci makku ana yalti sella
+Mi yehii wuro baabam, taw-mi yimɓe fuu ana njala.
+Jabaabu:
+14. Leelewal
+Piisirɗi
+
+
+Curki
+Liyeewa pernga (haabu)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/developer/docs/help/guides/develop/walkthrough/dag-short-wl.txt b/developer/docs/help/guides/develop/walkthrough/dag-short-wl.txt
new file mode 100644
index 00000000000..53968e2c8ba
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/dag-short-wl.txt
@@ -0,0 +1,25 @@
+ka 93
+o 63
+ni 55
+daa 51
+maa 28
+ti 23
+n 17
+a 16
+bɛ 14
+nti 12
+di 12
+dii 10
+yi 9
+ba 9
+so 8
+na 7
+m 7
+la 7
+jɔn 7
+chɛ 7
+pam 6
+kpe 6
+be 6
+ŋɔ 5
+dol’ 2
diff --git a/developer/docs/help/guides/develop/walkthrough/glossary.md b/developer/docs/help/guides/develop/walkthrough/glossary.md
new file mode 100644
index 00000000000..66375d0152f
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/glossary.md
@@ -0,0 +1,203 @@
+---
+title: Glossary of Key Terms
+---
+
+## Core Software & Tools
+
+### Keyman Developer
+
+Keyman Developer is a powerful tool you can use to create custom keyboards optimized to type in any language you choose. Keyboards created with Keyman Developer can be used on Windows, macOS, Linux, iOS, Android, and the web. The Keyman Developer IDE (integrated development environment) is currently Windows-only, however the command line tools it uses can run on other platforms (such as Linux and macOS).
+
+### Keyman
+
+The application that allows users to actually use keyboards created with Keyman Developer. Available on Windows, macOS, Linux, iOS, Android, and the web. Distinguished from Keyman Developer by its regular (not faded) app icon.
+
+### Keyboard Editor
+
+The primary tool within Keyman Developer used to design and program keyboard layouts, accessible through both drag-and-drop visual design and direct source code editing.
+
+### Package Editor
+
+A tool within Keyman Developer used to bundle keyboard files, fonts, documentation, and other resources into a distributable package file (.kmp).
+
+### Debugger
+
+An interactive tool in Keyman Developer that allows keyboard authors to test keyboard rules, step through complex logic, inspect store contents, and examine context, deadkey state, and output at each point during keyboard operation.
+
+## Keyboard Components & Concepts
+
+### Keyboard Project
+
+A complete project containing all files and resources needed to develop, test, and distribute a keyboard. Organized through a .kpj project file.
+
+### Keyboard Layout
+
+An arrangement of keys (either physical keys on a physical keyboard or key images on the screen of a touch device) allowing a set of characters to be typed. A layout is composed of one or more layers, which are accessed by modifier keys (such as Shift or Alt).
+
+### Keyboard Layer
+
+A subset of the keys in a keyboard layout. This subset is accessed by a modifier key. For example, holding down the Shift key on a physical keyboard gives you access to the Shift layer. Similarly, tapping the “!#1” key on a touch layout presents the Numeric layer.
+
+### Desktop Layout
+
+A keyboard layout designed for use on desktop/laptop computers with physical keyboards (Windows, macOS, Linux). It is also used when a physical keyboard is attached to a touch device. Stored in .kmn files.
+
+### Visual Keyboard / On Screen Keyboard
+
+A graphical representation of the keyboard layout that shows users which keys produce which characters. Files with .kvks extension.
+
+### Touch Layout
+
+A keyboard layout designed for use on touchscreen devices like smartphones and tablets (iOS and Android). Created using the touch layout editor and stored in .keyman-touch-layout files.
+
+### Keyboard Package
+
+A bundled distribution file (.kmp) that contains one or more keyboards along with fonts, documentation, and on-screen keyboard files, ready for installation on user devices.
+
+### Lexical Model Package
+
+A bundled distribution file (.kmp) that contains a lexical model, ready for installation on user devices.
+
+### Keyboard Authors
+
+Individuals or organizations who create custom keyboard layouts using Keyman Developer.
+
+## Lexical Models & Predictive Text
+
+### Lexical Model
+
+A language model that powers predictive text and autocorrect functionality for a keyboard. Also called a “dictionary” in Keyman apps. It uses word lists to suggest completions, corrections, and properly accented variants as a user types.
+
+### Wordlist
+
+A list of words in a language, typically stored in a tab-separated values (.tsv) file, used as the foundation for creating a lexical model. To be effective as a source for suggesting words, each word should have a number indicating its relative frequency in normal usage. This is often accomplished by counting words in a large text sample.
+
+## Programming Concepts
+
+### Deadkey
+
+An invisible placeholder character used in keyboard programming that doesn't appear on screen but can be matched by future rules. Deadkeys allow complex input sequences, such as distinguishing between typing an apostrophe twice for a quote versus once before a vowel for an accent. Keyman supports up to 65,534 unique deadkeys per keyboard.
+
+### Context
+
+The text or characters that precede the current cursor position, which keyboard rules can examine to determine appropriate output.
+
+### Rule
+
+A programming statement in Keyman keyboard language that transforms inputs to outputs, following the pattern: context + keystroke > output.
+
+### Store
+
+A named variable in Keyman keyboard language that holds a set of characters or deadkeys for use in keyboard rules.
+
+### Group
+
+A collection of related keyboard rules organized together for processing keystrokes or manipulating context.
+
+## Language & Encoding
+
+### BCP 47 Tags
+
+Language identification codes following the Best Current Practice 47 standard (e.g., "en" for English, "str-Latn" for Straits Salish in Latin script). These tags consist of:
+
+- **Language subtag**: ISO 639-1 (2-letter) or ISO 639-3 (3-letter) code
+- **Script subtag** (optional): ISO 15924 4-letter code for writing system (e.g., "Latn" for Latin, "Cans" for Canadian Aboriginal Syllabics)
+- **Region subtag** (optional): ISO 3166-1 alpha-2 country code or UN M49 region code
+
+Keyman uses BCP 47 tags to provide language metadata, facilitate keyboard searches, and associate keyboards with operating system language settings.
+
+### Unicode
+
+The universal character encoding standard that Keyman keyboards fully support, allowing access to characters from any writing system.
+
+## File Types
+
+### .kpj (Keyman Project)
+
+The main project file that contains references to all components: keyboards, models, and packages. Used to organize and manage the entire keyboard development project.
+
+### .kmn (Keyman Source)
+
+A plain text keyboard source file that contains all the code and rules for a Keyman keyboard. This is the human-readable programming file that keyboard authors edit.
+
+### .kvks (Keyman Visual Keyboard Source)
+
+The source file for an on-screen keyboard, created in Keyman Developer's visual keyboard editor.
+
+### .keyman-touch-layout
+
+A JSON format file that describes a keyboard layout specifically for touch devices (phones and tablets).
+
+### .model.ts (Model TypeScript)
+
+A TypeScript source file that defines a lexical model, specifying the format, word-breaking rules, and source files (wordlists) to use for predictive text.
+
+### .tsv (Tab-Separated Values)
+
+A text file containing a list of words, one per line, with an optional tab-separated frequency count, used as source data for creating a lexical model.
+
+### .kps (Keyman Package Source)
+
+A package source file created in the Package Editor that specifies which files (keyboards, fonts, documentation) should be included in a distributable keyboard package or which lexical model files should be included in a distributable lexical model package.
+
+### .kmx (Keyman Compiled Keyboard)
+
+A compiled binary keyboard file created from a .kmn source file. Used by Keyman on Windows, macOS, and Linux. This is the file used by the Keyman program on the user’s computer to provide keyboard functionality on physical keyboards.
+
+### .kvk (Compiled Keyman Visual Keyboard)
+
+A compiled on-screen keyboard file that shows the visual layout of a keyboard.
+
+### .js (Compiled Keyboard JavaScript)
+
+A JavaScript file created from a .keyman-touch-layout source file, used by Keyman apps on touch devices to provide touch keyboard functionality.
+
+### .model.js (Model JavaScript)
+
+The compiled JavaScript file created from a .model.ts source file, used by Keyman apps to provide predictive text functionality.
+
+### .kmp (Keyman Package)
+
+A compiled, distributable package file that bundles keyboards, fonts, documentation, and other resources into a single installer. This is what end users download and install.
+
+## Distribution & Community
+
+### Keyman Community Forum
+
+An online forum ([community.software.sil.org/c/keyman](http://community.software.sil.org/c/keyman)) where keyboard authors can ask questions, share knowledge, and get support from other developers.
+
+### Keyman GitHub Repository
+
+The open-source code repository ([github.com/keymanapp](http://github.com/keymanapp)) where Keyman software is developed and where users can contribute keyboards, report bugs, and submit improvements.
+
+[**help.keyman.com**](https://help.keyman.com)
+
+The comprehensive online documentation site for Keyman Developer, containing language references, tutorials, guides, and API documentation.
+
+## Advanced Concepts
+
+### Base Layout
+
+The keyboard layout of the system when Keyman is not active. For example, the base layout might be the QWERTY (US English) layout, the AZERTY (French) layout, or a Thai layout, depending on the settings of the device.
+
+### Mnemonic Layout
+
+A keyboard layout where keys are identified by the character produced after the [base layout](#toc-base-layout) is applied, rather than by their physical position. For example, on a US English (QWERTY) keyboard the “A” key is directly to the right of the Caps Lock key and the “Q” key is above it, but on a French (AZERTY) keyboard the “Q” key is directly to the right of the Caps Lock key and the “A” key is above it. If a Keyman keyboard has `&mnemoniclayout` enabled, the rules for “A” will take the base layout into account and respond to the “A” key, even though it is a different physical key on the two keyboards.
+
+Note that some keyboards in the Keyman keyboards repository use the term “mnemonic” in the title or description to indicate that the characters (usually of a non-Latin script) are assigned to keys according to their correspondence with the US English (QWERTY) layout. For example, the Arabic “beh” character might be assigned to the location of the “B” on the QWERTY keyboard.
+
+### Positional Layout
+
+A keyboard layout where keys are identified by their physical position on the keyboard rather than the character displayed on the keycap. For example, the "Z" position on a US keyboard corresponds to the "Y" position on a German keyboard.
+
+### Transient Language Profiles
+
+Custom language profiles in Windows (limited to 4) for languages that Windows doesn't have built-in support for, automatically managed when installing keyboards with custom BCP 47 tags.
+
+### Word Breaker
+
+An algorithm that determines where word boundaries occur in running text, essential for lexical models. Different languages require different word-breaking rules (e.g., space-separated vs. no obvious breaks in East Asian scripts).
+
+---
+
+*This glossary is based on the Keyman Developer General Tutorial and official Keyman documentation. For the most current information, visit [help.keyman.com](http://help.keyman.com).*
\ No newline at end of file
diff --git a/developer/docs/help/guides/develop/walkthrough/images/add-language.png b/developer/docs/help/guides/develop/walkthrough/images/add-language.png
new file mode 100644
index 00000000000..c2f1c888032
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/add-language.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/add-longpress.png b/developer/docs/help/guides/develop/walkthrough/images/add-longpress.png
new file mode 100644
index 00000000000..2043fbbbb7b
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/add-longpress.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/characters-in-comments.png b/developer/docs/help/guides/develop/walkthrough/images/characters-in-comments.png
new file mode 100644
index 00000000000..2e538631928
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/characters-in-comments.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/charmap-to-text.png b/developer/docs/help/guides/develop/walkthrough/images/charmap-to-text.png
new file mode 100644
index 00000000000..7bab7d60548
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/charmap-to-text.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/charmap.png b/developer/docs/help/guides/develop/walkthrough/images/charmap.png
new file mode 100644
index 00000000000..15c9ca91697
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/charmap.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/code-tab.png b/developer/docs/help/guides/develop/walkthrough/images/code-tab.png
new file mode 100644
index 00000000000..9e55f71e17c
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/code-tab.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/copy-wordlist.png b/developer/docs/help/guides/develop/walkthrough/images/copy-wordlist.png
new file mode 100644
index 00000000000..bfbc99e76f3
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/copy-wordlist.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/debugger-output.png b/developer/docs/help/guides/develop/walkthrough/images/debugger-output.png
new file mode 100644
index 00000000000..be565e0b5ec
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/debugger-output.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/distribution-tab.png b/developer/docs/help/guides/develop/walkthrough/images/distribution-tab.png
new file mode 100644
index 00000000000..2b796a612cf
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/distribution-tab.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/history-md-file.png b/developer/docs/help/guides/develop/walkthrough/images/history-md-file.png
new file mode 100644
index 00000000000..5e5bc029fb3
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/history-md-file.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/keyboard-model-device.png b/developer/docs/help/guides/develop/walkthrough/images/keyboard-model-device.png
new file mode 100644
index 00000000000..ed6b5807e36
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/keyboard-model-device.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/keyboards-tab.png b/developer/docs/help/guides/develop/walkthrough/images/keyboards-tab.png
new file mode 100644
index 00000000000..d36945796b2
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/keyboards-tab.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/keyman-developer-icon.png b/developer/docs/help/guides/develop/walkthrough/images/keyman-developer-icon.png
new file mode 100644
index 00000000000..29801e83c37
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/keyman-developer-icon.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/keyman-icon.png b/developer/docs/help/guides/develop/walkthrough/images/keyman-icon.png
new file mode 100644
index 00000000000..88ecb27608a
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/keyman-icon.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/layer-selection.png b/developer/docs/help/guides/develop/walkthrough/images/layer-selection.png
new file mode 100644
index 00000000000..2ec89966f3f
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/layer-selection.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/longpress-fields.png b/developer/docs/help/guides/develop/walkthrough/images/longpress-fields.png
new file mode 100644
index 00000000000..9fb0271df91
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/longpress-fields.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/new-lexical-model.png b/developer/docs/help/guides/develop/walkthrough/images/new-lexical-model.png
new file mode 100644
index 00000000000..a9590c624d6
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/new-lexical-model.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/new-longpress-key.png b/developer/docs/help/guides/develop/walkthrough/images/new-longpress-key.png
new file mode 100644
index 00000000000..a1bd60dbed7
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/new-longpress-key.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/new-project-dialog.png b/developer/docs/help/guides/develop/walkthrough/images/new-project-dialog.png
new file mode 100644
index 00000000000..5bd61d2e5ba
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/new-project-dialog.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/notepadpp-case.png b/developer/docs/help/guides/develop/walkthrough/images/notepadpp-case.png
new file mode 100644
index 00000000000..b891a0637b0
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/notepadpp-case.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/notepadpp-regex.png b/developer/docs/help/guides/develop/walkthrough/images/notepadpp-regex.png
new file mode 100644
index 00000000000..e5b62d01801
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/notepadpp-regex.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/primerprep-input.png b/developer/docs/help/guides/develop/walkthrough/images/primerprep-input.png
new file mode 100644
index 00000000000..ef46c91e90b
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/primerprep-input.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/primerprep-start.png b/developer/docs/help/guides/develop/walkthrough/images/primerprep-start.png
new file mode 100644
index 00000000000..3564f38df92
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/primerprep-start.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/primerprep-with-words.png b/developer/docs/help/guides/develop/walkthrough/images/primerprep-with-words.png
new file mode 100644
index 00000000000..ce7e75cc6fe
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/primerprep-with-words.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/shift-layer.png b/developer/docs/help/guides/develop/walkthrough/images/shift-layer.png
new file mode 100644
index 00000000000..b8c86ff08ac
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/shift-layer.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/test-keyboard-browser-display.png b/developer/docs/help/guides/develop/walkthrough/images/test-keyboard-browser-display.png
new file mode 100644
index 00000000000..5243a8939b6
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/test-keyboard-browser-display.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/test-keyboard-browser.png b/developer/docs/help/guides/develop/walkthrough/images/test-keyboard-browser.png
new file mode 100644
index 00000000000..2925a710869
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/test-keyboard-browser.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/test-lexical-model-k.png b/developer/docs/help/guides/develop/walkthrough/images/test-lexical-model-k.png
new file mode 100644
index 00000000000..99aa345043a
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/test-lexical-model-k.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/test-lexical-model-setup.png b/developer/docs/help/guides/develop/walkthrough/images/test-lexical-model-setup.png
new file mode 100644
index 00000000000..645e44398d6
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/test-lexical-model-setup.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/test-longpress.png b/developer/docs/help/guides/develop/walkthrough/images/test-longpress.png
new file mode 100644
index 00000000000..c9a8126d7b3
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/test-longpress.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/u-0254.png b/developer/docs/help/guides/develop/walkthrough/images/u-0254.png
new file mode 100644
index 00000000000..6c9f5342395
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/u-0254.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/unicode-character-value.png b/developer/docs/help/guides/develop/walkthrough/images/unicode-character-value.png
new file mode 100644
index 00000000000..fc3c96b3c6f
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/unicode-character-value.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/images/windows-save-txt.png b/developer/docs/help/guides/develop/walkthrough/images/windows-save-txt.png
new file mode 100644
index 00000000000..975733e3726
Binary files /dev/null and b/developer/docs/help/guides/develop/walkthrough/images/windows-save-txt.png differ
diff --git a/developer/docs/help/guides/develop/walkthrough/index.md b/developer/docs/help/guides/develop/walkthrough/index.md
new file mode 100644
index 00000000000..20095f23f5d
--- /dev/null
+++ b/developer/docs/help/guides/develop/walkthrough/index.md
@@ -0,0 +1,47 @@
+---
+title: Keyman Developer Walkthrough
+---
+
+## Overview
+
+This walkthrough will give you a basic overview of Keyman Developer’s keyboard development and packaging features.
+
+Some tutorials seek to give the reader detailed step-by-step instructions to produce a specific result. The focus is on learning the tool and how to use it. All decisions about what to do with the tool are provided by the tutorial.
+
+Other tutorials seek to present a series of topics and then invite readers to consider how these apply to their own data.
+
+This walkthrough attempts to provide both tutorial approaches. For each topic in the [Table of Contents](#toc-table-of-contents), the first section of that topic will provide a step-by-step guide to producing a keyboard for the Dagbani language. Subsequent sections under that topic will give other examples and discuss alternative approaches that readers can consider for their own data.
+
+
+To begin the "Step-by-Step" tutorial, start with the [Introduction](00-introduction).
+
+## Table of Contents
+
+
+[Introduction](00-introduction)
+
+[Creating a Keyboard Project](01-creating-keyboard-project)
+
+[Designing a Desktop Layout](02-designing-desktop-layout)
+
+[Creating a Desktop Layout](03-creating-desktop-layout)
+
+[Using the Debugger](04-using-debugger)
+
+[Designing a Touch Layout](05-designing-touch-layout)
+
+[Creating a Touch Layout](06-creating-touch-layout)
+
+[Writing Keyboard Documentation](07-writing-keyboard-documentation)
+
+[Preparing a Keyboard Package](08-preparing-keyboard-package)
+
+[Distributing a Keyboard Package](09-distributing-keyboard-package)
+
+[Generating a Lexical Model](10-generating-lexical-model)
+
+[Installing a Keyman Lexical Model](11-installing-lexical-model)
+
+[Glossary of Key Terms](glossary)
+
+