Copyright © 2017 SIL International')};a.resizeBar=function(){var b=g._CreateElement("DIV");b.className="kmw-footer";b.onmousedown=a._CancelMouse; +var d=g._CreateElement("DIV");d.className="kmw-footer-caption";d.innerHTML='KeymanWeb';d.id="keymanweb-osk-footer-caption";g.attachDOMEvent(d,"dblclick",function(b){b&&b.shiftKey&&a.showBuild()},!1);"onselectstart"in d&&(d.onselectstart=g.selectStartHandler);b.appendChild(d);d=g._CreateElement("DIV");d.className="kmw-footer-resize";d.onmousedown=a._VResizeMouseDown;d.onmouseover=d.onmouseout=a._VResizeMouseOut;b.appendChild(d);a.resizeIcon=d;return b}; +a._VKbdMouseOver=function(a){b.uiManager.setActivatingUI(!0)};a._VKbdMouseOut=function(a){b.uiManager.setActivatingUI(!1)};a._VResizeMouseOver=a._VResizeMouseOut=function(c){c=b._GetEventObject(c);if(!c)return!1;c&&c.preventDefault&&c.preventDefault();var d=a.getRect();a.width=d.width;a.height=d.height;c.cancelBubble=!0;return!1};a._VResizeMouseDown=function(c){b.uiManager.justActivated=!0;c=b._GetEventObject(c);if(!c)return!0;a.resizing=1;if(c.pageX){var d=c.pageX;var f=c.pageY}else c.clientX&&(d= +c.clientX+document.body.scrollLeft,f=c.clientY+document.body.scrollTop);a._ResizeMouseX=d;a._ResizeMouseY=f;document.onmousemove!=a._VResizeMouseMove&&document.onmousemove!=a._VMoveMouseMove&&(a._VPreviousMouseMove=document.onmousemove,a._VPreviousMouseUp=document.onmouseup);a._VPreviousCursor=document.body.style.cursor;a._VPreviousMouseButton="undefined"==typeof c.which?c.button:c.which;a._VOriginalWidth=a._DivVKbd.offsetWidth;a._VOriginalHeight=a._DivVKbd.offsetHeight;document.onmousemove=a._VResizeMouseMove; +document.onmouseup=a._VResizeMoveMouseUp;document.body.style.cursor&&(document.body.style.cursor="se-resize");c&&c.preventDefault&&c.preventDefault();c.cancelBubble=!0;return!1};a._VResizeMouseMove=function(c){c=b._GetEventObject(c);if(!c)return!0;a.resizing=1;if(a._VPreviousMouseButton!=("undefined"==typeof c.which?c.button:c.which))return a._VResizeMoveMouseUp(c);if(c.pageX){var d=c.pageX;var f=c.pageY}else c.clientX&&(d=c.clientX+document.body.scrollLeft,f=c.clientY+document.body.scrollTop);d= +a._VOriginalWidth+d-a._ResizeMouseX;f=a._VOriginalHeight+f-a._ResizeMouseY;d<.2*screen.width&&(d=.2*screen.width);f<.1*screen.height&&(f=.1*screen.height);d>.9*screen.width&&(d=.9*screen.width);f>.5*screen.height&&(d=.5*screen.height);a._DivVKbd.style.width=d+"px";a._DivVKbd.style.height=f+"px";a._DivVKbd.style.fontSize=f/8+"px";c&&c.preventDefault&&c.preventDefault();c.cancelBubble=!0;return!1};a._VMoveMouseDown=function(c){b.uiManager.justActivated=!0;c=b._GetEventObject(c);if(!c)return!0;a.resizing= +1;if(c.pageX){var d=c.pageX;var f=c.pageY}else c.clientX&&(d=c.clientX+document.body.scrollLeft,f=c.clientY+document.body.scrollTop);document.onmousemove!=a._VResizeMouseMove&&document.onmousemove!=a._VMoveMouseMove&&(a._VPreviousMouseMove=document.onmousemove,a._VPreviousMouseUp=document.onmouseup);a._VPreviousCursor=document.body.style.cursor;a._VPreviousMouseButton="undefined"==typeof c.which?c.button:c.which;a._VMoveX=d-a._Box.offsetLeft;a._VMoveY=f-a._Box.offsetTop;b.keyboardManager.isCJK()&& +(a.pinImg.style.left="15px");document.onmousemove=a._VMoveMouseMove;document.onmouseup=a._VResizeMoveMouseUp;document.body.style.cursor&&(document.body.style.cursor="move");c&&c.preventDefault&&c.preventDefault();c.cancelBubble=!0;return!1};a._VMoveMouseMove=function(c){c=b._GetEventObject(c);if(!c||a.noDrag)return!0;a.resizing=1;a.userPositioned=!0;a.pinImg.style.display="block";if(a._VPreviousMouseButton!=("undefined"==typeof c.which?c.button:c.which))return a._VResizeMoveMouseUp(c);if(c.pageX){var d= +c.pageX;var f=c.pageY}else c.clientX&&(d=c.clientX+document.body.scrollLeft,f=c.clientY+document.body.scrollTop);a._Box.style.left=d-a._VMoveX+"px";a._Box.style.top=f-a._VMoveY+"px";c&&c.preventDefault&&c.preventDefault();d=a.getRect();a.width=d.width;a.height=d.height;c.cancelBubble=!0;return!1};a._VResizeMoveMouseUp=function(c){c=b._GetEventObject(c);if(!c)return!0;a.resizing=0;a.currentKey=null;document.onmousemove=a._VPreviousMouseMove;document.onmouseup=a._VPreviousMouseUp;document.body.style.cursor&& +(document.body.style.cursor=a._VPreviousCursor);b.domManager.focusLastActiveElement();c&&c.preventDefault&&c.preventDefault();b.uiManager.justActivated=!1;b.uiManager.setActivatingUI(!1);a._DivVKbd&&(a._VOriginalWidth=a._DivVKbd.offsetWidth,a._VOriginalHeight=a._DivVKbd.offsetHeight);a.doResizeMove();c.cancelBubble=!0;a.saveCookie();return!1};a.userLocated=function(){return a.userPositioned};a.show=function(b){0
+```
+
+## API References
+
+On programmatically setting the keyboard:
+- [`keyman.setActiveKeyboard()`](../../reference/core/setActiveKeyboard).
+
+On managing the visibility of the OSK:
+- [`keyman.osk.hide()`](../../reference/osk/hide)
+- [`keyman.osk.show()`](../../reference/osk/show).
+
+------------------------------------------------------------------------
+
+[On to Full Manual Control Example](full-manual-control)
diff --git a/web/docs/engine/guide/get-started.md b/web/docs/engine/guide/get-started.md
new file mode 100644
index 0000000000..4089f6712d
--- /dev/null
+++ b/web/docs/engine/guide/get-started.md
@@ -0,0 +1,53 @@
+---
+title: Getting Started With KeymanWeb
+---
+
+## Prerequisite
+
+- First, if you have not yet obtained a copy of KeymanWeb, please visit [the KeymanWeb Developer Home](https://keyman.com/developer/keymanweb/). A link to the "https minified" version of the code will be used here.
+
+## Demo
+
+To setup a basic first page with KeymanWeb, only two lines of code are necessary, but a few more lines will be shown here. Open [an example page](examples/__first-example.html).
+
+The source code for the page may be seen below.
+
+```html
+
+
+
+
+ Click me and type:
+ + +``` + +## The Breakdown + +- The `` loads the Keyman Engine for Web script for the page. + +- `(function() { keyman.init(); });` serves to initialize the web engine with default settings. By adding the object `{attachType:'auto'}` as a parameter to our `keyman.init()` call, the KeymanWeb engine will then link into any detected input elements automatically, regardless of browser or device, as part of its initialization. + +- The other ``, creates the language menu seen on non-mobile devices and the on-screen keyboard toggle button. For other options, see our [User Interface Design](user-interface-design) page. + +- The calls to `keyman.addKeyboards()` in the source above link in the two example Keyman keyboards used in this demo from our CDN server. For more info on how to include keyboards in your KeymanWeb installation, check the [Adding Keyboards](adding-keyboards) page. + +## API References + +- On initialization: [`keyman.init()`](../reference/core/init). + +- On including keyboards: [`keyman.addKeyboards()`](../reference/core/addKeyboards). diff --git a/web/docs/engine/guide/index.md b/web/docs/engine/guide/index.md new file mode 100644 index 0000000000..26e2e42b47 --- /dev/null +++ b/web/docs/engine/guide/index.md @@ -0,0 +1,13 @@ +--- +title: KeymanWeb 18.0 - The Guide +--- + +Welcome to the guide for using KeymanWeb 18.0. + +- [Getting Started with Keyman Web](get-started) +- [User Interface Design](user-interface-design) +- [What is a Keyboard?](what-is-a-keyboard) +- [Installing Keyboards](adding-keyboards) +- [Additional Examples](examples/) + +[Return to the main KeymanWeb 18.0 page](../) \ No newline at end of file diff --git a/web/docs/engine/guide/user-interface-design.md b/web/docs/engine/guide/user-interface-design.md new file mode 100644 index 0000000000..9f56ac214e --- /dev/null +++ b/web/docs/engine/guide/user-interface-design.md @@ -0,0 +1,103 @@ +--- +title: User Interface Design +--- + +This page displays all the different KeymanWeb user interface options +available for non-mobile consumption. Use whichever one best complements +your website. Depending on the number of keyboards you are using and the +way your website is designed, the various interfaces will be more or +less suitable. + +The Button Interface |
+ |
|
+
+
+
+ Display: Fixed Element +No of Keyboards: up to 20 +HTML: Header & Control + |
+
+ For an interface which fits unobtrusively into your website while maintaining full functionality, try the Button Interface. All KeymanWeb's functions are displayed in a menu appearing whenever the user hovers over the button, which can be placed anywhere on the website. +To keep this interface as compact as possible, it is controlled through a single menu. While there is technically no limit to the number of keyboards that can be used, the Button interface works best on sites using up to 20 different keyboards, which are listed alphabetically. +The include for this interface is To select where the interface will be displayed on your page, add the following element where desired: The property For information on how your site users will interact with the Button Interface, click here. + |
+
The Floating Interface |
+ |
|
+
+
+
+ Display: Floating Element +No of Keyboards: up to 20 +HTML: Header Only + |
+
+ The Floating Interface provides a clear, menu-based approach to selecting from a list of keyboards. This interface can be incorporated without changing the layout of your existing site, as it automatically appears when users click in a a supported control (such as a textbox) and disappears again when they click outside. You can choose to have the interface float below (DefaultBelow) or to the right of (DefaultRight) the active control. +This interface is simple to use, and with its single alphabetical list of keyboards, works most effectively on sites supporting up to around 20 keyboards. +The include for this interface is For information on how your site users will interact with the Floating Interface, click here. + |
+
The Toggle Interface |
+ |
|
+
+
+
+ Display: Floating Element +No of Keyboards: 1 +HTML: Header Only + |
+
+ For a website incorporating KeymanWeb to support a single keyboard, the Toggle is the ideal solution. The interface floats at the right of the active control, and is hidden when the mouse is clicked outside, which means that no changes have to be made to your site design. A simple on-off interface makes it easy for users to switch between their default language and the supported keyboard. +The include for this interface is For information on how your site users will interact with the Toggle Interface, click here. + |
+
The Toolbar Interface |
+ |
|
+
+
+
+ Display: Fixed Element +No of Keyboards: unlimited +HTML: Header & Control + |
+
+ The standard interface for many sites incorporating KeymanWeb is the Toolbar. This interface, which can be positioned anywhere on a website by inserting the HTML code provided, provides an instant visual indication that the site allows users to type in a range of languages. +The Toolbar's map-based menu, displayed whenever a user clicks on the Keyboards button, works particularly well with multilingual sites integrating languages from all over the world. The most recently-used keyboard is remembered in a cookie, making it as easy to switch between English and another language as the Toggle interface, while maintaining full functionality and support for an essentially unlimited number of keyboards. +The include for this interface is To select where the interface will be displayed on your page, add the following element where desired: A live example of the KeymanWeb Toolbar Interface is available on the KeymanWeb Demo Site. For information on how your site users will interact with the Toolbar Interface, click here. + + |
+
+ 
+ 
+ 
+ ` element with the complete structure
+of the specified layer of an on-screen keyboard (OSK) that the user can
+then utilize for documentation or other purposes.
diff --git a/web/docs/engine/reference/core/activatingUI.md b/web/docs/engine/reference/core/activatingUI.md
new file mode 100644
index 0000000000..a5837f6b48
--- /dev/null
+++ b/web/docs/engine/reference/core/activatingUI.md
@@ -0,0 +1,29 @@
+---
+title: activatingUI
+---
+
+## Summary
+
+Sets an internal flag to notify KeymanWeb of change in UI activation state.
+
+## Syntax
+
+```c
+keyman.activatingUI(state);
+```
+
+### Parameters
+
+`state`
+: Type: `boolean|number`
+: Used to signify if the user is interacting with KeymanWeb UI elements.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+This function is used by the various non-mobile UI implementations to aid the KeymanWeb engine with internal bookkeeping. In particular, it is necessary for accurately tracking effects related to the active control when interacting with UI elements.
+
+As a result, this function should only ever be utilized within custom UI code.
diff --git a/web/docs/engine/reference/core/addEventListener.md b/web/docs/engine/reference/core/addEventListener.md
new file mode 100644
index 0000000000..10a7318260
--- /dev/null
+++ b/web/docs/engine/reference/core/addEventListener.md
@@ -0,0 +1,46 @@
+---
+title: addEventListener
+---
+
+## Summary
+
+Adds an event listener for user-handling of KeymanWeb events.
+
+## Syntax
+
+```c
+keyman.addEventListener(event, func);
+```
+
+### Parameters
+
+`event`
+: Type: `string`
+: The name of an event to be generated by the `keyman` object. Please see the [Events section](../events) for more details and examples.
+
+`func`
+: Type: `function`
+: A function to be called when the event is raised. This function should expect a single parameter, which will be set to the originally-generated event object.
+
+### Return Value
+
+`boolean`
+: Returns `true` if successful, otherwise `false`.
+
+## Description
+
+---
+**Note:** Standard HTML element events for the KeymanWeb element (focus,
+blur, keydown, keypress, etc.) may be intercepted and used to modify the
+user interface as necessary. User-defined event handlers should normally
+return true to allow other event handling to be processed normally.
+
+---
+
+## Example
+
+```c
+keyman.addEventListener('focus', function(e) {
+ console.log("Now handling input for control " + e.target "!");
+});
+```
diff --git a/web/docs/engine/reference/core/addHotKey.md b/web/docs/engine/reference/core/addHotKey.md
new file mode 100644
index 0000000000..67be15c65c
--- /dev/null
+++ b/web/docs/engine/reference/core/addHotKey.md
@@ -0,0 +1,35 @@
+---
+title: addHotKey
+---
+
+## Summary
+
+Add hot key handler to array of document-level hotkeys triggered by key-up event.
+
+## Syntax
+
+```c
+keyman.addHotKey(keyCode, shiftState, handler);
+```
+
+### Parameters
+
+`keyCode`
+: Type: `number`
+: The base key of the hotkey
+
+`shiftState`
+: Type: `number`
+: `shiftState` is a bitwise combination of SHIFT (0x10), CTRL (0x20) and ALT (0x40).
+
+`handler`
+: Type: `function`
+: The function to be called when the hotkey is triggered. It should not expect any parameters.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+Used to support custom hotkeys within a web document. Only one handler function may exist per hotkey combination.
diff --git a/web/docs/engine/reference/core/addKeyboards.md b/web/docs/engine/reference/core/addKeyboards.md
new file mode 100644
index 0000000000..4a2dc77f5d
--- /dev/null
+++ b/web/docs/engine/reference/core/addKeyboards.md
@@ -0,0 +1,179 @@
+---
+title: addKeyboards function
+---
+
+## Summary
+
+Adds keyboards to KeymanWeb.
+
+## Syntax
+
+```js
+keyman.addKeyboards(spec[, spec...])
+```
+
+### Parameters
+
+`spec`
+
+: Type: `string|Object`
+
+ keyboard name string or keyboard metadata JSON object
+
+### Return Value
+
+`Promise`: A [JavaScript Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+fulfilled upon adding keyboards.
+
+The promise is an array containing a combination of the following:
+* successfully registered keyboard objects which define some or all of these [properties](../keyboard_properties)
+* [ErrorStub](../keyboard_registration_errors) objects for keyboards that failed to register
+
+## Description
+
+The keyboard spec can be a string or an object. Multiple keyboard specs can be
+specified in a single call, which can reduce the round-trip cost of multiple
+calls to Keyman Cloud servers (when using Keyman Cloud).
+
+For general information and example uses of this method, please see the [Adding Keyboards](../../guide/adding-keyboards) page from the guide section.
+
+### Using a `string`
+
+When keyboard spec is a string, the Keyman Cloud is used to source the keyboard
+file. Keymanweb will load webfonts and keyboard file automatically on demand.
+The string format is one of the following:
+
+* `'keyboardID'`: Adds a specific keyboard, linking it to the default language for the keyboard
+* `'@languageID'`: Adds the default keyboard for the specified BCP 47 language code
+* `'keyboardID@languageID'`: Loads a specific keyboard + language combination
+
+The keyboard catalogue is online at
+[http://keyman.com/developer/keymanweb/keyboards](http://keyman.com/developer/keymanweb/keyboards).
+
+### Using an `object`
+
+When keyboard spec is an object, then more parameters can be specified,
+including sourcing the keyboard from locations other than the Keyman Cloud. The
+specification of the object is related to the Keyman Cloud JSON API (formerly
+known as KeymanWeb Server Data API):
+
+The `spec` object contains the following members:
+
+
+`name`
+
+: `string`
+
+ Name of the keyboard.
+
+`id`
+
+: `string`
+
+ ID (internal name) of keyboard, together with version always matches the
+ filename of the keyboard
+
+`filename`
+
+: `string`
+
+ url of keyboard *.js file, relative (to page) or absolute
+
+`languages`
+
+: `array|object`
+
+ An array of objects (see definition below) or single object linked to the
+ keyboard.
+
+`rtl`
+
+: `boolean` optional
+
+ `true` if the keyboard targets a right-to-left script. May be set to `false`
+ or left `undefined` otherwise.
+
+`version`
+
+: `string` optional
+
+ Version of keyboard *.js file
+
+`displayName`
+
+: `string` optional
+
+ A name to display in the spacebar of the keyboard; if omitted, use the
+ default [`spacebarText` option](init#init_options).
+
+---
+
+The `spec.languages` object contains the following members:
+
+`name`
+
+: `string`
+
+ Name of the language.
+
+`id`
+
+: `string`
+
+ BCP 47 language code.
+
+`region`
+
+: `string` optional
+
+ _Required_ when using the Toolbar UI. May be set with one of the following
+ region names:
+
+ * `'World'` (`'un'`)
+ * `'Africa'` (`'af'`)
+ * `'Asia'` (`'as'`)
+ * `'Europe'` (`'eu'`)
+ * `'South America'` (`'sa'`)
+ * `'North America'` (`'na'`)
+ * `'Oceania'` (`'oc'`)
+ * `'Central America'` (`'ca'`)
+ * `'Middle East'` (`'me'`)
+
+`font`
+
+: `array|object` optional
+
+ An array of Font objects (see definition below) or single object describing
+ fonts for input fields and the OSK (if `oskFont` is not present.)
+
+`oskFont`
+
+: `array|object` optional
+
+ An array of Font objects (see `font` definition below) or single object
+ describing fonts for the OSK.
+
+---
+
+The `spec.languages.font` object contains the following members:
+
+`family`
+
+: `string`
+
+ Font family that KeymanWeb will provide for this font.
+
+`filename`
+
+: `array`
+
+ Array of URLs where font resources can be accessed, relative to the [`fonts`
+ initialization property](init). Multiple font resources can be specified as
+ platform font format support varies and KeymanWeb will pick the most
+ appropriate for the platform.
+
+`size`
+
+: `string` optional
+
+ Font size (in CSS dimensions). If not specified, then `1em` is used.
diff --git a/web/docs/engine/reference/core/addKeyboardsForLanguage.md b/web/docs/engine/reference/core/addKeyboardsForLanguage.md
new file mode 100644
index 0000000000..d06ce2ede2
--- /dev/null
+++ b/web/docs/engine/reference/core/addKeyboardsForLanguage.md
@@ -0,0 +1,44 @@
+---
+title: addKeyboardsForLanguage function
+---
+
+## Summary
+
+Add default or all keyboards for a given language to KeymanWeb.
+
+## Syntax
+
+```js
+keyman.addKeyboardsForLanguage(spec[, spec...])
+```
+
+### Parameters
+
+`spec`
+
+: Type: `string`
+
+ Language name string. Appending `$` to the language name will cause all available keyboards for that language to be loaded rather than the default keyboard.
+
+### Return Value
+
+`Promise`: A [JavaScript Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+fulfilled upon adding keyboards.
+
+The promise is an array containing the following:
+* successfully registered keyboard objects which define some or all of these [properties](../keyboard_properties)
+
+## Description
+
+The language spec is a string. Multiple language specs can also be
+specified in a single call, which can reduce the round-trip cost of multiple
+calls to Keyman Cloud servers (when using Keyman Cloud).
+
+The first call to `addKeyboardsForLanguage()` makes an additional call to the Keyman API to load the current list of keyboard/language associations. This determines the default keyboards that are added for the language.
+
+For general information and example uses of this method, please see the [Adding Keyboards](../../guide/adding-keyboards) page from the guide section.
+
+### Using a `string`
+
+For the given language specs, the Keyman Cloud is used to source the keyboard
+file.
diff --git a/web/docs/engine/reference/core/attachToControl.md b/web/docs/engine/reference/core/attachToControl.md
new file mode 100644
index 0000000000..30f6a57a82
--- /dev/null
+++ b/web/docs/engine/reference/core/attachToControl.md
@@ -0,0 +1,48 @@
+---
+title: attachToControl
+---
+
+## Summary
+
+Attach KeymanWeb to HTML element (or IFrame).
+
+## Syntax
+
+```c
+keyman.attachToControl(Pelem)
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: Element to which KeymanWeb will be attached.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+There are two steps involved in enabling input handling with KeymanWeb
+for any given control: *attachment* and *enablement*. The attachment
+process validates a control's compatibility with KeymanWeb and
+establishes special metadata within the system. This data is released if
+the control is ever detached. The control will not receive special input
+handling until the control is enabled within KeymanWeb.
+
+If `attachToControl()` is called on an element with the `'kmw-disabled'`
+class property, it will only establish KeymanWeb's metadata for the
+control and initialize the control in a disabled state. A later call to
+`enableControl()` may be used to initialize input handling for it.
+Otherwise, the control will be both attached and enabled.
+
+When the [initialization property `attachType`](init) is set to
+`'auto'`, this function is called automatically for every control on the
+page, even those dynamically added. However, when `attachType` is set to
+`'manual'`, `attachToControl` must be explicitly called for each control
+in need of KeymanWeb's input handling.
+
+## See also:
+- [`keyman.detachFromControl()`](detachFromControl)
+- [`keyman.enableControl()`](enableControl)
diff --git a/web/docs/engine/reference/core/build.md b/web/docs/engine/reference/core/build.md
new file mode 100644
index 0000000000..75824dd48d
--- /dev/null
+++ b/web/docs/engine/reference/core/build.md
@@ -0,0 +1,29 @@
+---
+title: build
+---
+
+## Summary
+
+Denotes the release-version .patch component for the loaded KeymanWeb instance.
+
+## Syntax
+
+```c
+keyman.build
+```
+
+## Type
+
+string
+
+### Access
+
+Read only
+
+### Return Value
+
+(for example) `14.0.1`
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/core/detachFromControl.md b/web/docs/engine/reference/core/detachFromControl.md
new file mode 100644
index 0000000000..fbb50299c7
--- /dev/null
+++ b/web/docs/engine/reference/core/detachFromControl.md
@@ -0,0 +1,34 @@
+---
+title: detachFromControl
+---
+
+## Summary
+
+Detach KeymanWeb from HTML element (or IFrame).
+
+## Syntax
+
+```c
+keyman.detachFromControl(Pelem);
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: Element for KeymanWeb to detach from, no longer handling input.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+This function entirely detaches KeymanWeb from the specified control,
+removing all specialized input handling and data tracking for the
+element. As such, detaching effectively 'resets' the control's state
+entirely, save for any previously-input text.
+
+For more information about attachment, see [`keyman.attachToControl()`](attachToControl).
+
+Contrast with [`keyman.disableControl()`](disableControl).
diff --git a/web/docs/engine/reference/core/disableControl.md b/web/docs/engine/reference/core/disableControl.md
new file mode 100644
index 0000000000..0be0d43649
--- /dev/null
+++ b/web/docs/engine/reference/core/disableControl.md
@@ -0,0 +1,41 @@
+---
+title: disableControl
+---
+
+## Summary
+
+Disables KeymanWeb input handling for the specified control.
+
+## Syntax
+
+```c
+keyman.disableControl(Pelem)
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: Element to become KeymanWeb-disabled.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+This function is used to explicitly disable KeymanWeb input handling for
+a previously-attached control, adding the class `'kmw-disabled'`
+property to the element as necessary. It will not, however, detach
+KeymanWeb from the control, and any KeymanWeb-specific metadata will
+persist until KeymanWeb is explicitly detached from the element.
+
+If `'kmw-disabled'` is added to the control via other means,
+`disableControl()` will be called upon it automatically and
+non-recursively.
+
+If called on an element in an unattached state, the `'kmw-disabled'` tag will be added to the element.
+
+## See also:
+- [`keyman.detachFromControl()`](detachFromControl)
+- [`keyman.enableControl()`](enableControl)
diff --git a/web/docs/engine/reference/core/enableControl.md b/web/docs/engine/reference/core/enableControl.md
new file mode 100644
index 0000000000..2ca4664462
--- /dev/null
+++ b/web/docs/engine/reference/core/enableControl.md
@@ -0,0 +1,45 @@
+---
+title: enableControl
+---
+
+## Summary
+
+Enables KeymanWeb input handling for the specified control.
+
+## Syntax
+
+```c
+keyman.enableControl(Pelem)
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: Element to become KeymanWeb-enabled.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+There are two steps involved in enabling input handling with KeymanWeb
+for any given control: *attachment* and *enablement*. The attachment
+process validates a control's compatibility with KeymanWeb and
+establishes special metadata within the system. This data is released if
+the control is ever detached. The control will not receive special input
+handling unless the control is enabled within KeymanWeb.
+
+This function is used to explicitly enable KeymanWeb input handling for
+a previously-attached control, removing the class `'kmw-disabled'`
+property from the element as necessary. It will not, however, attach
+KeymanWeb to the control.
+
+If `'kmw-disabled'` is removed from the control via other means, `enableControl()` will be called upon it automatically and non-recursively.
+
+If called on an element in an unattached state, the `'kmw-disabled'` tag will be removed from the element.
+
+## See also
+- [`keyman.attachToControl()`](attachToControl)
+- [`keyman.disableControl()`](disableControl)
diff --git a/web/docs/engine/reference/core/focusLastActiveElement.md b/web/docs/engine/reference/core/focusLastActiveElement.md
new file mode 100644
index 0000000000..54deb07f10
--- /dev/null
+++ b/web/docs/engine/reference/core/focusLastActiveElement.md
@@ -0,0 +1,25 @@
+---
+title: focusLastActiveElement
+---
+
+## Summary
+
+Restore the focus to the element active before input was moved to KeymanWeb.
+
+## Syntax
+
+```c
+keyman.focusLastActiveElement()
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/core/getActiveKeyboard.md b/web/docs/engine/reference/core/getActiveKeyboard.md
new file mode 100644
index 0000000000..900aa09f47
--- /dev/null
+++ b/web/docs/engine/reference/core/getActiveKeyboard.md
@@ -0,0 +1,22 @@
+---
+title: getActiveKeyboard
+---
+
+## Summary
+
+Get the internal name of the currently active keyboard.
+
+## Syntax
+
+```c
+keyman.getActiveKeyboard()
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`string`
+: The ID (internal name) of the currently-active keyboard.
diff --git a/web/docs/engine/reference/core/getActiveLanguage.md b/web/docs/engine/reference/core/getActiveLanguage.md
new file mode 100644
index 0000000000..588ce805dd
--- /dev/null
+++ b/web/docs/engine/reference/core/getActiveLanguage.md
@@ -0,0 +1,26 @@
+---
+title: getActiveLanguage
+---
+
+## Summary
+
+Get the language code for the currently selected language.
+
+## Syntax
+
+```c
+keyman.getActiveLanguage()
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`string`
+: The active language's BCP 47 language code.
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/core/getKeyboard.md b/web/docs/engine/reference/core/getKeyboard.md
new file mode 100644
index 0000000000..0d6f8eb52e
--- /dev/null
+++ b/web/docs/engine/reference/core/getKeyboard.md
@@ -0,0 +1,79 @@
+---
+title: getKeyboard
+---
+
+## Summary
+
+Get keyboard meta data for the selected keyboard and language.
+
+## Syntax
+
+```c
+keyman.getKeyboard(keyboardName, languageCode)
+```
+
+### Parameters
+
+`keyboardName`
+: Type: `string`
+: The ID (internal name) of the keyboard.
+
+`languageCode`
+: Type: `string` *optional*
+: The BCP 47 language code.
+
+### Return Value
+
+`Object`
+: An object with metadata corresponding to the requested keyboard.
+
+## Description
+
+The `keyboard` object contains the following members:
+
+`Name`
+: `string`
+: User-friendly name of the keyboard.
+
+`InternalName`
+: `string`
+: Internal name of the keyboard.
+
+`LanguageName`
+: `string`
+: User-friendly name of the language actively tied to the keyboard.
+
+`LanguageCode`
+: `string`
+: The three-letter code used to internally represent the language.
+
+`RegionName`
+: `string`
+: The user-friendly name of the region of the world within which the language is predominantly found.
+
+`RegionCode`
+: `string`
+: The three-letter code representing the region.
+
+`CountryName`
+: `string` *optional*
+: The user-friendly name of the country in which the language is spoken.
+
+`CountryCode`
+: `string` *optional*
+: A three-letter code corresponding to the country.
+
+`KeyboardID`
+: `string` *optional*
+: *Deprecated.* A unique identifier for the keyboard. (Use 'InternalName' instead.)
+
+`Font`
+: `string` *optional*
+: The font packaged with the keyboard to support its use.
+
+`OskFont`
+: `string` *optional*
+: The font packaged with the keyboard to properly display specialized OSK characters.
+
+## See also
+- [keyman.addKeyboards()](addKeyboards) and its documentation about keyboard specification objects.
diff --git a/web/docs/engine/reference/core/getKeyboardForControl.md b/web/docs/engine/reference/core/getKeyboardForControl.md
new file mode 100644
index 0000000000..e2b2049e5b
--- /dev/null
+++ b/web/docs/engine/reference/core/getKeyboardForControl.md
@@ -0,0 +1,34 @@
+---
+title: getKeyboardForControl
+---
+
+## Summary
+
+Obtain the keyboard set for a specific control, if it exists.
+
+## Syntax
+
+```c
+keyman.getKeyboardForControl(Pelem);
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: An HTML input control.
+
+### Return Value
+
+`string|null`
+: If the control has independent keyboard settings, returns the ID (internal name) of a keyboard. Otherwise, returns `null`.
+
+## Description
+
+This function is useful for determining when a control has
+independently-managed keyboard settings within KeymanWeb. **Note** that it
+will return `null` otherwise, even if there is an active keyboard within
+KeymanWeb.
+
+## See also
+- [`keyman.setKeyboardForControl()`](setKeyboardForControl) contrast with [`keyman.getActiveKeyboard()`](getActiveKeyboard)
diff --git a/web/docs/engine/reference/core/getKeyboards.md b/web/docs/engine/reference/core/getKeyboards.md
new file mode 100644
index 0000000000..8d84521b31
--- /dev/null
+++ b/web/docs/engine/reference/core/getKeyboards.md
@@ -0,0 +1,29 @@
+---
+title: getKeyboards
+---
+
+## Summary
+
+Get details of currently installed keyboards.
+
+## Syntax
+
+```c
+keyman.getKeyboards()
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`Array`
+: An array of specifications for the currently-installed keyboards.
+
+## Description
+
+See [keyman.getKeyboard()](getKeyboard) for detail on the returned keyboard specification objects.
+
+## See also
+- [keyman.addKeyboards()](addKeyboards)
diff --git a/web/docs/engine/reference/core/getLastActiveElement.md b/web/docs/engine/reference/core/getLastActiveElement.md
new file mode 100644
index 0000000000..d34fc7ffa5
--- /dev/null
+++ b/web/docs/engine/reference/core/getLastActiveElement.md
@@ -0,0 +1,26 @@
+---
+title: getLastActiveElement
+---
+
+## Summary
+
+Return the last element activated before input was moved to KeymanWeb.
+
+## Syntax
+
+```c
+keyman.getLastActiveElement();
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`Element`
+: The last element activated before KeymanWeb activated.
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/core/getSavedKeyboard.md b/web/docs/engine/reference/core/getSavedKeyboard.md
new file mode 100644
index 0000000000..dfffe2121b
--- /dev/null
+++ b/web/docs/engine/reference/core/getSavedKeyboard.md
@@ -0,0 +1,26 @@
+---
+title: getSavedKeyboard
+---
+
+## Summary
+
+Get the (internal) keyboard name and language code of the most recently active keyboard, as stored in KeymanWeb's cookie management system.
+
+## Syntax
+
+```c
+keyman.getSavedKeyboard();
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`string`
+: Format: `Internal-Name:Language-Code`
+
+## Description
+
+This function is used to automatically restore the last keyboard selected by a user in order to restore it upon a new visit to the page KeymanWeb is embedded within.
diff --git a/web/docs/engine/reference/core/getUIState.md b/web/docs/engine/reference/core/getUIState.md
new file mode 100644
index 0000000000..402e482413
--- /dev/null
+++ b/web/docs/engine/reference/core/getUIState.md
@@ -0,0 +1,34 @@
+---
+title: getUIState
+---
+
+## Summary
+
+Get the KeymanWeb user interface activation state.
+
+## Syntax
+
+```c
+keyman.getUIState()
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`Object`
+: A '`ui_state`' object specifying the UI's current activation state. Please see below for more details.
+
+## Description
+
+The `ui_state` object contains the following members:
+
+`activationPending`
+: `boolean`
+: Indicates that the KeymanWeb UI is being activated.
+
+`activated`
+: `boolean`
+: Indicates that the KeymanUI is presently active.
diff --git a/web/docs/engine/reference/core/helpURL.md b/web/docs/engine/reference/core/helpURL.md
new file mode 100644
index 0000000000..16f86eb3ca
--- /dev/null
+++ b/web/docs/engine/reference/core/helpURL.md
@@ -0,0 +1,29 @@
+---
+title: helpURL
+---
+
+## Summary
+
+URL for keyboard help site (set by site developer).
+
+## Syntax
+
+```keyman
+keyman.helpURL
+```
+
+### Type
+
+`string`
+
+### Access
+
+Read only
+
+### Return Value
+
+Presently set to [`"http://help.keymanweb.com/go"`]().
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/core/index.md b/web/docs/engine/reference/core/index.md
new file mode 100644
index 0000000000..8ce45877fd
--- /dev/null
+++ b/web/docs/engine/reference/core/index.md
@@ -0,0 +1,133 @@
+---
+title: Core Module
+---
+
+The KeymanWeb core module is exposed to the developer as `window.keyman`.
+
+[`build` Property](build)
+: The release build of KeymanWeb.
+
+
+[`version` Property](version)
+: The version of KeymanWeb.
+
+
+[`initialized` Property](initialized)
+: Keymanweb core module initialization state.
+
+
+[`activatingUI` Function](activatingUI)
+: Set an internal flag to notify KeymanWeb of change in UI activation state.
+
+
+[`addEventListener` Function](addEventListener)
+: Adds an event listener for user-handling of keymanweb events.
+
+
+[`addHotKey` Function](addHotKey)
+: Add hot key handler to array of document-level hotkeys triggered by key-up event.
+
+
+[`addKeyboards` Function](addKeyboards)
+: Adds keyboards to keymanweb.
+
+
+[`addKeyboardsForLanguage` Function](addKeyboardsForLanguage)
+: Adds default or all keyboards for a given language to keymanweb.
+
+
+[`attachToControl` Function](attachToControl)
+: Attach KeymanWeb to HTML element (or IFrame).
+
+
+[ `BuildVisualKeyboard` Function](BuildVisualKeyboard)
+: Create a copy of the OSK for embedding in documentation or help page.
+
+
+[`detachFromControl` Function](detachFromControl)
+: Detach KeymanWeb from HTML element (or IFrame).
+
+
+[`disableControl` Function](disableControl)
+: Disables KeymanWeb input handling for the specified control.
+
+
+[`enableControl` Function](enableControl)
+: Enables KeymanWeb input handling for the specified control.
+
+
+[`focusLastActiveElement` Function](focusLastActiveElement)
+: Restore the focus to the element active before input was moved to KeymanWeb.
+
+
+[`getActiveKeyboard` Function](getActiveKeyboard)
+: Get the ID (internal name) of the currently active keyboard.
+
+
+[`getActiveLanguage` Function](getActiveLanguage)
+: Get the language code for the currently selected language.
+
+
+[`getKeyboard` Function](getKeyboard)
+: Get keyboard meta data for the selected keyboard and language.
+
+
+[`getKeyboardForControl` Function](getKeyboardForControl)
+: Obtain the keyboard set for a specific control, if it exists.
+
+
+[`getKeyboards` Function](getKeyboards)
+: Get details of currently installed keyboards.
+
+
+[`getLastActiveElement` Function](getLastActiveElement)
+: Return the last element activated before input was moved to KeymanWeb.
+
+
+[`getSavedKeyboard` Function](getSavedKeyboard)
+: Get the (internal) keyboard name and language code of the most recently active
+ keyboard.
+
+
+[`getUIState` Function](getUIState)
+: Get the KeymanWeb user interface activation state.
+
+
+[`init` Function](init)
+: Sets license key, selects user interface, and other KeymanWeb Options.
+
+
+[`isChiral` Function](isChiral)
+: Test if a given keyboard recognizes chiral modifier data, such as left-control vs right-control.
+
+
+[`isCJK` Function](isCJK)
+: Test if a given keyboard or keyboard stub (or the current keyboard) is for Chinese, Japanese, or Korean.
+
+
+[`moveToElement` Function](moveToElement)
+: Move input focus to user specified element.
+
+
+[`removeEventListener` Function](removeEventListener)
+: Removes a user-defined event handler.
+
+
+[`removeHotKey` Function](removeHotKey)
+: Remove hotkey handler from document's list of hotkey handlers.
+
+
+[`removeKeyboards` Function](removeKeyboards)
+: Removes keyboards (by ID) from KeymanWeb.
+
+
+[`resetContext` Function](resetContext)
+: Revert OSK to default layer and clear any deadkeys and modifiers
+
+
+[`setActiveKeyboard` Function](setActiveKeyboard)
+: Change the currently active keyboard.
+
+
+[`setKeyboardForControl` Function](setKeyboardForControl)
+: Associate control with independent keyboard settings initialized to a specific keyboard.
diff --git a/web/docs/engine/reference/core/init.md b/web/docs/engine/reference/core/init.md
new file mode 100644
index 0000000000..9f18301f8c
--- /dev/null
+++ b/web/docs/engine/reference/core/init.md
@@ -0,0 +1,146 @@
+---
+title: init function
+---
+
+## Summary
+
+Initializes KeymanWeb and configures KeymanWeb Options.
+
+Note that this is an asynchronous operation.
+
+`keyman.init()` is automatically called after the page loads, with default
+options, if it has not already been called by scripts on the page. It is safe to
+call `keyman.init()` once more in this situation, in order to set additional
+options.
+
+The [`keyman.initialized` property](initialized) may be checked to determine the
+current initialization state of Keyman Engine for Web.
+
+You should not call functions other than `keyman.init()` until Keyman
+initialization is complete. As `keyman.init()` returns a Promise, the Promise
+fulfilment callback is the appropriate place to perform post-init steps.
+
+## Syntax
+
+```js
+keyman.init(initOptions);
+```
+
+### Parameters
+
+`initOptions`
+
+: Type: `Object`.
+
+ See the Description section below for the necessary object specification.
+
+### Return Value
+
+`Promise`: A [JavaScript Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+fulfilled upon full initialization.
+
+## Initialization Options
+
+The `initOptions` object may contain the following members:
+
+`ui`
+
+: `string|object` optional
+
+ The user interface to be used on desktop devices. Default value: `'float'`.
+ Please see below for the specification of this parameter if using an object
+ value.
+
+`root`
+
+: `string` optional
+
+ The folder KeymanWeb should consider root. Default value: `undefined`, which
+ sets `root` to the base folder where keymanweb.js is located.
+
+`resources`
+
+: `string` optional
+
+ The image folder URL for UI resources. Default value: `[root]/resources`.
+
+`keyboards`
+
+: `string` optional
+
+ The folder containing local keyboard resources if utilized. Default value:
+ `[root]/keyboards`.
+
+`fonts`
+
+: `string` optional
+
+ Folder containing any embedded fonts required for keyboards or the OSK.
+ Default value: `[root]`.
+
+`attachType`
+
+: `string` optional
+
+ Must be `undefined`, `'auto'`, or `'manual'`. Specifies the default behavior
+ for attaching KeymanWeb to any input elements on the webpage.
+
+ * If `undefined`, KeymanWeb will default to 'manual' for mobile devices and
+ 'auto' for other devices.
+ * If `'auto'`, KeymanWeb will automatically attach to every non-disabled
+ control, even those added after page initialization.
+ * If `'manual'`, KeymanWeb must be instructed to attached manually to each
+ control it should handle input for.
+
+`setActiveOnRegister`
+
+: `boolean` optional
+
+ Specifies whether KeymanWeb will set the newly registered keyboard as active. Default value `true`.
+
+ * If `true`, KeymanWeb will automatically activate a keyboard when registered.
+ * If `false`, KeymanWeb will not activate a keyboard when registered.
+
+ **Note:** Changed from `string` type to `boolean` type in KeymanWeb 17.0 ([#8458](https://github.com/keymanapp/keyman/pull/8458)).
+
+`useAlerts`
+
+: `boolean` optional
+
+ Specifies whether KeymanWeb's alert feedback should be enabled. Default value `true`.
+
+ * If `true`, KeymanWeb will display its default alerts.
+ * If `false`, KeymanWeb will not display its default alerts. Choose this if you wish to disable them or would prefer to customize your site's error feedback.
+ * In either case, any calls your page makes to `keyman.util.alert()` will not be blocked. This only affects calls built into KeymanWeb itself.
+
+`spacebarText`
+
+: `com.keyman.SpacebarText` optional
+
+ If present, must be one of the following four constants:
+ * `KEYBOARD /*'keyboard'*/` - show the keyboard name in the spacebar
+ * `LANGUAGE /*'language'*/` - show the language name in the spacebar
+ * `LANGUAGE_KEYBOARD /*'languageKeyboard'*/` - show both language and
+ keyboard name in the spacebar, separated by hyphen
+ * `BLANK /*'blank'*/` - keep the spacebar blank
+
+ Note that this may be overridden on a per-keyboard basis with the registration
+ property `displayName`.
+
+ Default value: `LANGUAGE_KEYBOARD`.
+
+---
+
+If setting `initOptions.ui` with an object value, it should be specified as
+follows:
+
+`name`
+
+: `string`
+: The name of the ui to utilize for non-mobile devices.
+
+
+`right`
+
+: `boolean` optional
+: A Float-UI-only option. Sets right-alignment of the UI. Defaults to false.
diff --git a/web/docs/engine/reference/core/initialized.md b/web/docs/engine/reference/core/initialized.md
new file mode 100644
index 0000000000..dd4dc8214b
--- /dev/null
+++ b/web/docs/engine/reference/core/initialized.md
@@ -0,0 +1,40 @@
+---
+title: keyman.initialized
+---
+
+### Summary
+
+Keymanweb core module initialization state flag.
+
+### Syntax
+
+```js
+ keyman.initialized
+```
+
+### Type
+
+Integer
+
+### Access
+
+Read only
+
+### Return Value
+
+* `0`, if Keyman Engine for Web is not initialized
+* `1`, if Keyman Engine for Web has started initialization
+* `2`, if Keyman Engine for Web is completely initialized
+
+### Description
+
+The [`keyman.init()` function](init) is used to initialize Keyman. You can check
+this flag to see what the current initialization status is. You should not call
+functions other than `keyman.init()` until Keyman initialization is complete. As
+`keyman.init()` returns a Promise, the Promise fulfilment callback is the
+appropriate place to perform post-init steps.
+
+### History
+
+* 2.0: Keyman Engine for Web supports values `0`, `1`, or `2`.
+* 16.0: Documentation updated to match implementation.
diff --git a/web/docs/engine/reference/core/isCJK.md b/web/docs/engine/reference/core/isCJK.md
new file mode 100644
index 0000000000..820bdcc135
--- /dev/null
+++ b/web/docs/engine/reference/core/isCJK.md
@@ -0,0 +1,28 @@
+---
+title: isCJK
+---
+
+## Summary
+
+Test if a given keyboard or keyboard stub (or the current keyboard) is for Chinese, Japanese, or Korean.
+
+## Syntax
+
+```c
+keyman.isCJK(keyboard);
+```
+
+### Parameters
+
+`keyboard`
+: Type: `object` *optional*
+: A loaded keyboard. Defaults to the currently-active keyboard if not specified.
+
+### Return Value
+
+`boolean`
+: `true` if the keyboard uses a pick list, as with the keyboards mentioned before, `false` if not.
+
+## Description
+
+East Asian keyboards (and some others) may use an IME with a "pick list" of characters, requiring special handling.
diff --git a/web/docs/engine/reference/core/isChiral.md b/web/docs/engine/reference/core/isChiral.md
new file mode 100644
index 0000000000..9605a0f9bd
--- /dev/null
+++ b/web/docs/engine/reference/core/isChiral.md
@@ -0,0 +1,41 @@
+---
+title: isChiral
+---
+
+## Summary
+
+Test if a given keyboard recognizes chiral modifier data, such as
+left-control vs right-control.
+
+## Syntax
+
+```c
+keyman.isChiral(keyboard);
+```
+
+### Parameters
+
+`keyboard`
+: Type: `string` *optional*
+: The id (identifying name) of a keyboard. Defaults to the currently-active keyboard if not specified.
+
+### Return Value
+
+`boolean`
+: `true` if the keyboard accepts chiral (left-vs-right) variants of CTRL and ALT, `false` if not.
+
+## Description
+
+The specified keyboard must have been fully loaded at some point for
+this information to be accessible; otherwise it will return `false`
+(non-chiral). It is always accurate for the currently-active keyboard.
+
+With the present system architecture, this is a bit complicated in that
+a keyboard is only set to 'active' after the
+[`keyboardloaded`](../events/keyman/keyboardloaded) event completes and
+after the [`keyboardchange`](../events/keyman/keyboardchange) event has
+completed for the first activation of a keyboard. However, both events
+return the name of the keyboard involved in the event, and this can be
+passed as an argument to `isChiral` from the
+[`keyboardloaded`](../events/keyman/keyboardloaded) event's handler to
+obtain the correct keyboard chirality information.
diff --git a/web/docs/engine/reference/core/moveToElement.md b/web/docs/engine/reference/core/moveToElement.md
new file mode 100644
index 0000000000..f850c03401
--- /dev/null
+++ b/web/docs/engine/reference/core/moveToElement.md
@@ -0,0 +1,30 @@
+---
+title: moveToElement
+---
+
+## Summary
+
+Move input focus to user specified element.
+
+## Syntax
+
+```c
+keyman.moveToElement(Pelem);
+```
+
+### Parameters
+
+`Pelem`
+: Type: `string|Element`
+: Moves focus to the user-specified element, finding it by element id if necessary.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+Touch-based input works through simulated input fields in KeymanWeb
+rather than the original controls of the page. As a result, this
+function should be used in place of the default `Pelem.focus()` method.
+It is used internally to allow OSK-based iteration through controls.
diff --git a/web/docs/engine/reference/core/removeEventListener.md b/web/docs/engine/reference/core/removeEventListener.md
new file mode 100644
index 0000000000..a7e37a7b70
--- /dev/null
+++ b/web/docs/engine/reference/core/removeEventListener.md
@@ -0,0 +1,33 @@
+---
+title: removeEventListener
+---
+
+## Summary
+
+Removes a user-defined event handler.
+
+## Syntax
+
+```c
+keyman.removeEventListener(event, func);
+```
+
+### Parameters
+
+`event`
+: Type: `string`
+: The name of an event generated by the `keyman` object.
+
+`func`
+: Type: `function`
+: A function currently set to handle that event when it is raised.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+See also [`keyman.addEventListener()`](addEventListener).
+
+To be implemented.
\ No newline at end of file
diff --git a/web/docs/engine/reference/core/removeHotKey.md b/web/docs/engine/reference/core/removeHotKey.md
new file mode 100644
index 0000000000..3c0a9d0afa
--- /dev/null
+++ b/web/docs/engine/reference/core/removeHotKey.md
@@ -0,0 +1,31 @@
+---
+title: removeHotKey
+---
+
+## Summary
+
+Remove the hotkey handler from document's list of hotkey handlers.
+
+## Syntax
+
+```c
+keyman.removeHotkey(keyCode, shiftState);
+```
+
+### Parameters
+
+`keyCode`
+: Type: `number`
+: The base key code for the hotkey.
+
+`shiftState`
+: Type: `number`
+: The modifier values corresponding to ALT, CTRL, and SHIFT for the hotkey.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+See also [`keyman.addHotKey()`](addHotKey).
diff --git a/web/docs/engine/reference/core/removeKeyboards.md b/web/docs/engine/reference/core/removeKeyboards.md
new file mode 100644
index 0000000000..03a14d5e24
--- /dev/null
+++ b/web/docs/engine/reference/core/removeKeyboards.md
@@ -0,0 +1,30 @@
+---
+title: removeKeyboards
+---
+
+## Summary
+
+Removes keyboards (by ID) from KeymanWeb.
+
+## Syntax
+
+```c
+keyman.removeKeyboards(id[, id2, ...])
+```
+
+### Parameters
+
+`id`
+: Type: `string`
+: keyboard name string
+
+### Return Value
+
+`boolean`
+: `true` if all keyboards were successfully removed, otherwise `false`.
+
+## Description
+
+Allows a web page designer to dynamically remove keyboards from KeymanWeb by their ID(s).
+
+If the value `false` is returned, it is most likely that at least one specified keyboard was not actively loaded in KeymanWeb at the time of the call.
diff --git a/web/docs/engine/reference/core/resetContext.md b/web/docs/engine/reference/core/resetContext.md
new file mode 100644
index 0000000000..4d81dbd0db
--- /dev/null
+++ b/web/docs/engine/reference/core/resetContext.md
@@ -0,0 +1,25 @@
+---
+title: resetContext
+---
+
+## Summary
+
+Revert OSK to default layer and clear any deadkeys and modifiers.
+
+## Syntax
+
+```c
+keyman.resetContext();
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/core/setActiveKeyboard.md b/web/docs/engine/reference/core/setActiveKeyboard.md
new file mode 100644
index 0000000000..bdd33b0509
--- /dev/null
+++ b/web/docs/engine/reference/core/setActiveKeyboard.md
@@ -0,0 +1,34 @@
+---
+title: setActiveKeyboard
+---
+
+## Summary
+
+Change the currently active keyboard.
+
+## Syntax
+
+```c
+keyman.setActiveKeyboard(keyboardName, languageCode);
+```
+
+### Parameters
+
+`keyboardName`
+: Type: `string`
+: The ID (internal name) of the keyboard to be set as active.
+
+`languageCode`
+: Type: `string` *optional*
+: The BCP 47 code for the keyboard's language.
+
+### Return Value
+
+`Promise`
+: A [JavaScript Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) fulfilled upon successfully linking and activating the keyboard.
+
+## Description
+
+Calls to `setActiveKeyboard` are asynchronous for keyboards not previously set as active.
+
+Use the `internalName` and `languageCode` keyboard variables. If `languageCode` is defaulted, `setActiveKeyboard` will select the language code for the first matching keyboard stub.
diff --git a/web/docs/engine/reference/core/setKeyboardForControl.md b/web/docs/engine/reference/core/setKeyboardForControl.md
new file mode 100644
index 0000000000..e1243d97cd
--- /dev/null
+++ b/web/docs/engine/reference/core/setKeyboardForControl.md
@@ -0,0 +1,47 @@
+---
+title: setKeyboardForControl
+---
+
+## Summary
+
+Associate control with independent keyboard settings initialized to a specific keyboard.
+
+## Syntax
+
+```c
+keyman.setDefaultKeyboardForControl(Pelem, keyboard, languageCode);
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: The control element to be managed manually.
+
+`keyboard`
+: Type: `string` *optional*
+: The ID (internal name) of a keyboard.
+
+`languageCode`
+: Type: `string` *optional*
+: The three-letter language code for the keyboard.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+This function establishes the control with separately-managed keyboard
+settings from other, non-specialized controls on the page. This may be
+undone by setting both `keyboard` and `languageCode` to null, reverting
+the control back to default keyboard-management behavior.
+
+Note that either **both** parameters should be set or **neither**. In
+particular, if `languageCode` is specified but not `keyboard`, this
+method will not automatically select an appropriate keyboard, even if
+one has previously been registered with that language code.
+
+Due to system limitations, this function will fail if called on an IFRAME element.
+
+See also [Control-by-Control Example (guide)](../../guide/examples/control-by-control)
diff --git a/web/docs/engine/reference/core/version.md b/web/docs/engine/reference/core/version.md
new file mode 100644
index 0000000000..7df0978ac8
--- /dev/null
+++ b/web/docs/engine/reference/core/version.md
@@ -0,0 +1,29 @@
+---
+title: version
+---
+
+## Summary
+
+The version number of the loaded KeymanWeb instance.
+
+## Syntax
+
+```c
+keyman.version
+```
+
+### Type
+
+string
+
+### Access
+
+Read only
+
+### Return Value
+
+`'18.0'` (for KeymanWeb 18.0)
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/events/index.md b/web/docs/engine/reference/events/index.md
new file mode 100644
index 0000000000..df7538c2c1
--- /dev/null
+++ b/web/docs/engine/reference/events/index.md
@@ -0,0 +1,110 @@
+---
+title: Events - Keyman Engine for Web
+---
+
+A number of events are exposed to allow the designer of a user
+interface to control the appearance and behavior of user interface
+elements. Standard event-processing requires all arguments to be passed
+as an array (object) with named member variables.
+
+Two components of Keyman Engine for Web specify events:
+* `keyman` object -- the main component
+* `keyman.osk` object -- the on-screen keyboard component
+
+Object events are handled in user code by passing the handler entry to
+the object, using *addEventListener()*.
+
+---
+
+### `keyman` events
+
+[`beforekeyboardchange`](keyman/beforekeyboardchange)
+: Called when keyboard input language about to change.
+
+
+
+[`controlblurred`](keyman/controlblurred)
+: Called when input element loses focus.
+
+
+
+[`controlfocused`](keyman/controlfocused)
+: Called when input element receives focus.
+
+
+
+[`keyboardchange`](keyman/keyboardchange)
+: Called when keyboard input language changed.
+
+
+
+[`keyboardloaded`](keyman/keyboardloaded)
+: Called when keyboard code loaded.
+
+
+[`keyboardregistered`](keyman/keyboardregistered)
+: Called when keyboard 'stub' processed (for listing as available
+ keyboard).
+
+
+
+[`loaduserinterface`](keyman/loaduserinterface)
+: Called when allow ui initialization.
+
+
+
+[`unloaduserinterface`](keyman/unloaduserinterface)
+: Called when allow ui clean-up.
+
+For example, to define a user function to handle the KeymanWeb
+`keyboardchange` event, include:
+
+``` typescript
+keyman.addEventListener('keyboardchange',
+ function(p)
+ {
+ ui.updateMenu(p.internalName,p.languageCode);
+ });
+
+```
+
+---
+
+### `keyman.osk` On Screen Keyboard events
+
+[`configclick`](osk/configclick)
+: Called when allows the UI to present KeymanWeb configuration
+ options.
+
+
+
+[`helpclick`](osk/helpclick)
+: Called when allows the UI to present a help page.
+
+
+
+[`hide`](osk/hide)
+: Called when OSK hidden.
+
+
+
+[`resizemove`](osk/resizemove)
+: Called when OSK resized or moved on desktop.
+
+
+
+[`show`](osk/show)
+: Called when OSK displayed.
+
+
+For example, to add an event handler that modifies the user interface when the on-screen
+keyboard is displayed:
+
+``` typescript
+keyman.osk.addEventListener('show',
+ function(p)
+ {
+ ui.updateUI(p.x, p.y, p.userLocated);
+ });
+
+```
diff --git a/web/docs/engine/reference/events/keyman/beforekeyboardchange.md b/web/docs/engine/reference/events/keyman/beforekeyboardchange.md
new file mode 100644
index 0000000000..6fad014400
--- /dev/null
+++ b/web/docs/engine/reference/events/keyman/beforekeyboardchange.md
@@ -0,0 +1,36 @@
+---
+title: keyman.beforekeyboardchange Event
+---
+
+## Summary
+
+Called when keyboard input language is about to change.
+
+## Syntax
+
+```
+keyman.addEventListener('beforekeyboardchange', function(keyboardProperties) {
+ ...
+});
+```
+
+### Parameters
+
+`keyboardProperties`
+: Type: `object`
+: An object with the following properties:
+
+: - `internalName` - the keyboard's name
+
+: - `languageCode` - its BCP 47 language code.
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+This event is designed to be used with UI modules.
diff --git a/web/docs/engine/reference/events/keyman/controlblurred.md b/web/docs/engine/reference/events/keyman/controlblurred.md
new file mode 100644
index 0000000000..bb42a2b548
--- /dev/null
+++ b/web/docs/engine/reference/events/keyman/controlblurred.md
@@ -0,0 +1,38 @@
+---
+title: keyman.controlblurred Event
+---
+
+## Summary
+
+Called when an input element loses focus.
+
+## Syntax
+
+```
+keyman.addEventListener('controlblurred', function(eventProperties) {
+ ...
+});
+```
+
+### Parameters
+
+`eventProperties`
+: Type: `object`
+: An object with the following properties:
+
+: - `target` - the element losing focus
+
+: - `event` - the original event object generated by the web page.
+
+: - `isActivating` - the activation state of the UI element(s).
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+This event is used by various KeymanWeb UI elements.
diff --git a/web/docs/engine/reference/events/keyman/controlfocused.md b/web/docs/engine/reference/events/keyman/controlfocused.md
new file mode 100644
index 0000000000..34525f0fed
--- /dev/null
+++ b/web/docs/engine/reference/events/keyman/controlfocused.md
@@ -0,0 +1,36 @@
+---
+title: keyman.controlfocused Event
+---
+
+## Summary
+
+Called when an input element receives focus.
+
+## Syntax
+
+```
+keyman.addEventListener('controlfocused', function(eventProperties) {
+ ...
+});
+```
+
+### Parameters
+
+`eventProperties`
+: Type: `object`
+: An object with the following properties:
+
+: - `target` - the element gaining focus
+
+: - `event` - the currently active control.
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+This event is used by various KeymanWeb UI elements.
diff --git a/web/docs/engine/reference/events/keyman/index.md b/web/docs/engine/reference/events/keyman/index.md
new file mode 100644
index 0000000000..953956f130
--- /dev/null
+++ b/web/docs/engine/reference/events/keyman/index.md
@@ -0,0 +1,43 @@
+---
+title: keyman events
+---
+
+[`beforekeyboardchange`](beforekeyboardchange)
+: Called when keyboard input language about to change.
+
+
+
+[`controlblurred`](controlblurred)
+: Called when input element loses focus.
+
+
+
+[`controlfocused`](controlfocused)
+: Called when input element receives focus.
+
+
+
+[`keyboardchange`](keyboardchange)
+: Called when keyboard input language changed.
+
+
+
+[`keyboardloaded`](keyboardloaded)
+: Called when keyboard code loaded.
+
+
+[`keyboardregistered`](keyboardregistered)
+: Called when keyboard 'stub' processed (for listing as available
+ keyboard).
+
+
+
+[`loaduserinterface`](loaduserinterface)
+: Called when allow ui initialization.
+
+
+
+[`unloaduserinterface`](unloaduserinterface)
+: Called when allow ui clean-up.
+
+[Return to main `events` index](..)
\ No newline at end of file
diff --git a/web/docs/engine/reference/events/keyman/keyboardchange.md b/web/docs/engine/reference/events/keyman/keyboardchange.md
new file mode 100644
index 0000000000..0d4570257f
--- /dev/null
+++ b/web/docs/engine/reference/events/keyman/keyboardchange.md
@@ -0,0 +1,37 @@
+---
+title: keyman.keyboardchange Event
+---
+
+## Summary
+
+Called when keyboard input language changed.
+
+## Syntax
+
+```
+keyman.addEventListener('keyboardchange', function(keyboardProperties) {
+ ...
+});
+```
+
+### Parameters
+
+`keyboardProperties`
+: Type: `object`
+: An object with the following properties:
+
+: - `internalName` - the keyboard's name
+
+: - `languageCode` - its BCP 47 language code.
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+This event is utilized by the various non-mobile UI elements included
+with KeymanWeb.
diff --git a/web/docs/engine/reference/events/keyman/keyboardloaded.md b/web/docs/engine/reference/events/keyman/keyboardloaded.md
new file mode 100644
index 0000000000..7b0a65b882
--- /dev/null
+++ b/web/docs/engine/reference/events/keyman/keyboardloaded.md
@@ -0,0 +1,35 @@
+---
+title: keyman.keyboardloaded Event
+---
+
+## Summary
+
+Called when keyboard code loaded.
+
+## Syntax
+
+```
+keyman.addEventListener('keyboardloaded', function(keyboardProperties) {
+ ...
+});
+```
+
+### Parameters
+
+`keyboardProperties`
+: Type: `object`
+: An object with the following property:
+
+: - `keyboardName` - the keyboard's name.
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+This event is only raised once a keyboard has been fully loaded and
+processed, ready for active use.
diff --git a/web/docs/engine/reference/events/keyman/keyboardregistered.md b/web/docs/engine/reference/events/keyman/keyboardregistered.md
new file mode 100644
index 0000000000..b92ca767d9
--- /dev/null
+++ b/web/docs/engine/reference/events/keyman/keyboardregistered.md
@@ -0,0 +1,43 @@
+---
+title: keyman.keyboardregistered Event
+---
+
+## Summary
+
+Called when a keyboard 'stub' is processed (for listing as available
+keyboard).
+
+## Syntax
+
+```
+keyman.addEventListener('keyboardregistered', function(keyboardProperties) {
+ ...
+});
+```
+
+### Parameters
+
+`keyboardProperties`
+: Type: `object`
+: An object with the following properties:
+
+: - `internalName` - the keyboard's id
+
+: - `language` - its corresponding language.
+
+: - `keyboardName` - the keyboard's name
+
+: - `languageCode` - its BCP 47 language code.
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+This event is used by all the UI elements in order to update the list of
+available keyboards as soon as a new keyboard stub has been registered,
+before any attempt to load it has been made.
diff --git a/web/docs/engine/reference/events/keyman/loaduserinterface.md b/web/docs/engine/reference/events/keyman/loaduserinterface.md
new file mode 100644
index 0000000000..094df102e5
--- /dev/null
+++ b/web/docs/engine/reference/events/keyman/loaduserinterface.md
@@ -0,0 +1,30 @@
+---
+title: keyman.loaduserinterface Event
+---
+
+## Summary
+
+Called to initiate the ui initialization process.
+
+## Syntax
+
+```
+keyman.addEventListener('loaduserinterface', function() {
+ ...
+});
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/events/keyman/unloaduserinterface.md b/web/docs/engine/reference/events/keyman/unloaduserinterface.md
new file mode 100644
index 0000000000..db44244b5b
--- /dev/null
+++ b/web/docs/engine/reference/events/keyman/unloaduserinterface.md
@@ -0,0 +1,31 @@
+---
+title: keyman.unloaduserinterface Event
+---
+
+## Summary
+
+Called when allow ui clean-up.
+
+## Syntax
+
+```
+keyman.addEventListener('unloaduserinterface', function() {
+ ...
+});
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+Called when the ui is to be unloaded, allowing cleanup of resources if
+necessary.
diff --git a/web/docs/engine/reference/events/osk/configclick.md b/web/docs/engine/reference/events/osk/configclick.md
new file mode 100644
index 0000000000..a4ccba9446
--- /dev/null
+++ b/web/docs/engine/reference/events/osk/configclick.md
@@ -0,0 +1,32 @@
+---
+title: osk.configclick Event
+---
+
+## Summary
+
+Called upon user request for the UI to present KeymanWeb configuration
+options.
+
+## Syntax
+
+```
+keyman.osk.addEventListener('configclick', function() {
+ ...
+});
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+This event is raised when the user wishes to access configuration
+options.
diff --git a/web/docs/engine/reference/events/osk/helpclick.md b/web/docs/engine/reference/events/osk/helpclick.md
new file mode 100644
index 0000000000..7e7a27d242
--- /dev/null
+++ b/web/docs/engine/reference/events/osk/helpclick.md
@@ -0,0 +1,31 @@
+---
+title: osk.helpclick Event
+---
+
+## Summary
+
+Called upon user request for the UI to present a help page.
+
+## Syntax
+
+```
+keyman.osk.addEventListener('helpclick', function() {
+ ...
+});
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+This event is raised whenever the user wishes to access help
+information.
diff --git a/web/docs/engine/reference/events/osk/hide.md b/web/docs/engine/reference/events/osk/hide.md
new file mode 100644
index 0000000000..77af0b65d1
--- /dev/null
+++ b/web/docs/engine/reference/events/osk/hide.md
@@ -0,0 +1,33 @@
+---
+title: osk.hide Event
+---
+
+## Summary
+
+Called when the OSK is hidden.
+
+## Syntax
+
+```
+keyman.osk.addEventListener('hide', function(param) {
+ ...
+});
+```
+
+### Parameters
+
+`param`
+: Type: `Object`
+: An object with field HiddenByUser, a `boolean` which indicates if
+ the OSK was hidden directly by the user's actions.
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/events/osk/index.md b/web/docs/engine/reference/events/osk/index.md
new file mode 100644
index 0000000000..7edeef819d
--- /dev/null
+++ b/web/docs/engine/reference/events/osk/index.md
@@ -0,0 +1,29 @@
+---
+title: OSK events
+---
+
+[`configclick`](configclick)
+: Called when allows the UI to present KeymanWeb configuration
+ options.
+
+
+
+[`helpclick`](helpclick)
+: Called when allows the UI to present a help page.
+
+
+
+[`hide`](hide)
+: Called when OSK hidden.
+
+
+
+[`resizemove`](resizemove)
+: Called when OSK resized or moved on desktop.
+
+
+
+[`show`](show)
+: Called when OSK displayed.
+
+[Return to main `events` index](..)
\ No newline at end of file
diff --git a/web/docs/engine/reference/events/osk/resizemove.md b/web/docs/engine/reference/events/osk/resizemove.md
new file mode 100644
index 0000000000..c6211a3200
--- /dev/null
+++ b/web/docs/engine/reference/events/osk/resizemove.md
@@ -0,0 +1,30 @@
+---
+title: osk.resizemove Event
+---
+
+## Summary
+
+Called when OSK resized or moved on desktop.
+
+## Syntax
+
+```
+keyman.osk.addEventListener('resizemove', function() {
+ ...
+});
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+This event is raised whenever the OSK is moved.
diff --git a/web/docs/engine/reference/events/osk/show.md b/web/docs/engine/reference/events/osk/show.md
new file mode 100644
index 0000000000..3d2e67b4f3
--- /dev/null
+++ b/web/docs/engine/reference/events/osk/show.md
@@ -0,0 +1,50 @@
+---
+title: osk.show Event
+---
+
+## Summary
+
+Called when the OSK is displayed.
+
+## Syntax
+
+```
+keyman.osk.addEventListener('show', function(obj) {
+ ...
+});
+```
+
+### Parameters
+
+`obj`
+: Type: `object`
+: An object specifying the osk's display state information.
+
+Available display state information:
+
+
+
+`obj.x`
+: `Number`
+: The x-coordinate of the left side of the OSK.
+
+`obj.y`
+: `Number`
+: The y-coordinate of the top of the OSK.
+
+`obj.userLocated`
+: `boolean`
+: `true` if the OSK has been directly placed by the user.
+
+
+
+### Return Value
+
+`boolean`
+: `true` if the event should continue processing, `false` if it should
+ not. Your event handler should return `true` aside from exceptional
+ circumstances.
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/index.md b/web/docs/engine/reference/index.md
new file mode 100644
index 0000000000..74d83c3931
--- /dev/null
+++ b/web/docs/engine/reference/index.md
@@ -0,0 +1,42 @@
+---
+title: KeymanWeb 18.0 Reference
+---
+
+[KeymanWeb Overview](overview)
+: KeymanWeb is a cross-browser JavaScript input method solution.
+
+[KeymanWeb Core Module](core)
+: The KeymanWeb core module is exposed to the developer as `window.keyman`.
+
+[On-Screen Keyboard Module](osk)
+: The On-Screen Keyboard module is exposed to the developer as `window.keyman.osk`.
+
+[KeymanWeb Utility Module](util)
+: The KeymanWeb Utility Function module is exposed to the developer as `window.keyman.util`.
+
+[KeymanWeb Output Functions](interface)
+: KeymanWeb exposes its keyboard interface object through `window.keyman.interface`, providing a number of functions for low-level processing of input, context and output.
+
+[KeymanWeb Compatibility Functions](compatibility)
+: The following KeymanWeb core functions have been retained for compatibility with existing custom keyboards, but should not be used in any new keyboards or user interfaces. Equivalent new function calls are indicated.
+
+[Desktop User Interfaces](ui)
+: Four different KeymanWeb user interfaces for desktop browsers are included, allowing users to select and enable keyboard mapping from a list of installed keyboards, and to control the visibility of the On-Screen Keyboard.
+
+[KeymanWeb Initialization Options](core/init#init_options)
+: The following options can be defined by the site designer in the initialization call to KeymanWeb.
+
+[KeymanWeb Events](events)
+: A number of KeymanWeb events are exposed to allow the designer of a user interface to control the appearance and behavior of user interface elements. Standard event-processing requires all arguments to be passed as an array (object) with named member variables.
+
+[KeymanWeb Keyboard Properties](keyboard_properties)
+: Most keyboards are generated automatically from the Keyman keyboard source by Keyman Developer and contain properties used by KeymanWeb during keyboard mapping.
+
+[KeymanWeb Layout Designer](layouts)
+: One of the main features of KeymanWeb is its ability to support distinct, user-customizable layouts for touch-screen keyboards on phones and tablets.
+
+[KeymanWeb Layout Specifications](layoutspec)
+: Touch-screen layouts for KeymanWeb are specified as JSON objects containing a member object for each specified device type.
+
+[KeymanWeb Keyboard Development Reference](/developer/language/guide/multi-platform)
+: Information on how to explicitly support KeymanWeb in custom keyboards.
diff --git a/web/docs/engine/reference/interface/_nul.md b/web/docs/engine/reference/interface/_nul.md
new file mode 100644
index 0000000000..4d20af049c
--- /dev/null
+++ b/web/docs/engine/reference/interface/_nul.md
@@ -0,0 +1,42 @@
+---
+title: nul (KN)
+---
+
+## Summary
+
+[`nul`](/developer/language/reference/nul) context check: Returns `true` if the length of the [`context`](/developer/language/reference/context) is less than or equal to `n` characters.
+
+## Syntax
+
+```c
+keyman.interface.nul(n, Pelem);
+```
+
+or
+
+```c
+KeymanWeb.KN(n, Pelem); // Shorthand
+```
+
+### Parameters
+
+`n`
+: Type: `number`
+: The length of `context` to check.
+
+`Pelem`
+: Type: `Element`
+: The element whose `context` is being examined.
+
+### Return Value
+
+`boolean`
+: `true` if the context is not longer than `n` characters, otherwise `false`.
+
+## Description
+
+This is of particular use in handling the [Developer rule `nul`](/developer/language/reference/nul) and is subject to the caveats listed therein.
+
+## See also
+
+- [`keyman.interface.context()`](context)
diff --git a/web/docs/engine/reference/interface/any.md b/web/docs/engine/reference/interface/any.md
new file mode 100644
index 0000000000..1bcc704046
--- /dev/null
+++ b/web/docs/engine/reference/interface/any.md
@@ -0,0 +1,62 @@
+---
+title: any (KA) (Deprecated)
+---
+
+## Summary
+
+(Deprecated) Returns whether or not the char `ch` is found within the [`any`](/developer/language/reference/any)([`store`](/developer/language/reference/store)) string, setting the internally-tracked index 'n' accordingly.
+
+## Syntax
+
+```c
+keyman.interface.any(index, ch, storeText);
+```
+
+or
+
+```c
+KeymanWeb.KA(index, ch, storeText); // Shorthand
+```
+
+### Parameters
+
+`index`
+: Type: `number`
+: The index id (starting from zero) at which the detected character will be internally tracked.
+
+`ch`
+: Type: `string`
+: The input character to find in the text store.
+
+`storeText`
+: Type: `string`
+: The contents of the specified text `store`.
+
+### Return Value
+
+`boolean`
+: `true` if the input character has a match in the text store, otherwise `false`.
+
+## Description
+
+This function corresponds most directly to the keyboard language command [`any`](/developer/language/reference/any), which operates upon text [`store`](/developer/language/reference/store)s to allow for array-based input-output text matching. For example,
+
+```keyman
+store(keys) 'abcde'
+store(output) 'αβγδε'
++ any(keys) > index(output,1)
+```
+
+facilitates mapping the characters `'abcde'` to their respective entry in the output store `'αβγδε'`. `keyman.interface.any()`'s role in this process is usually optimized out into individual mappings for performance reasons, though it is often involved when `any` is involved as part of a rule's `context`, rather than upon the triggering keystroke itself.
+
+In order to check if the character `'a'` has a match in the `keys` store above, the code
+
+```c
+keyman.interface.any(0, 'a', 'abcde')
+```
+
+would suffice, setting an internally-tracked index (id=0) to hold the index value 0. Note that the internally-tracked index (id=0) is decremented relative to the index appearing in the `index` call in the keyboard source above; the corresponding [`keyman.interface.indexOutput()`](indexOutput) call increments the id by 1 due to Keyman's keyboard language rules.
+
+## See also
+
+- [`keyman.interface.indexOutput()`](indexOutput)
diff --git a/web/docs/engine/reference/interface/beep.md b/web/docs/engine/reference/interface/beep.md
new file mode 100644
index 0000000000..b5f067c30f
--- /dev/null
+++ b/web/docs/engine/reference/interface/beep.md
@@ -0,0 +1,33 @@
+---
+title: beep (KB)
+---
+
+## Summary
+
+Flash body or element as substitute for an audible feedback [`beep`](/developer/language/reference/beep).
+
+## Syntax
+
+```c
+keyman.interface.beep(Pelem);
+```
+
+or
+
+```c
+KeymanWeb.KB(Pelem); // Shorthand
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: The page element to be temporarily set flashing.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+This function is designed to implement feedback for erroneous input sequences, as with the keyboard language [`beep`](/developer/language/reference/beep) command. The flashing feedback should last approximately 1/20 of a second.
diff --git a/web/docs/engine/reference/interface/beepReset.md b/web/docs/engine/reference/interface/beepReset.md
new file mode 100644
index 0000000000..dd840ce8e5
--- /dev/null
+++ b/web/docs/engine/reference/interface/beepReset.md
@@ -0,0 +1,31 @@
+---
+title: beepReset (KBR)
+---
+
+## Summary
+
+Cancels previous feedback [`beep`](/developer/language/reference/beep) operations across the page.
+
+## Syntax
+
+```c
+keyman.interface.beepReset();
+```
+
+or
+
+```c
+KeymanWeb.KBR(); // Shorthand
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+The `keyman.interface.beepReset()` function is automatically called by [`keyman.interface.beep()`](beep) after a short interval (approximately 1/20 of a second) and should not need to be called manually.
diff --git a/web/docs/engine/reference/interface/context.md b/web/docs/engine/reference/interface/context.md
new file mode 100644
index 0000000000..982d19d538
--- /dev/null
+++ b/web/docs/engine/reference/interface/context.md
@@ -0,0 +1,60 @@
+---
+title: context (KC) (Deprecated)
+---
+
+## Summary
+
+(Deprecated) Gets [`context`](/developer/language/reference/context) for an ongoing keyboard operation relative to the caret's present position.
+
+## Syntax
+
+```c
+keyman.interface.context(n, ln, Pelem);
+```
+
+or
+
+```c
+KeymanWeb.KC(n, ln, Pelem); // Shorthand
+```
+
+### Parameters
+
+`n`
+: Type: `number`
+: Relative position of the caret for the context retrieval operation.
+
+`ln`
+: Type: `number`
+: Number of characters of text context to retrieve.
+
+`Pelem`
+: Type: `Element`
+: The element being operated upon.
+
+### Return Value
+
+`string`
+: The requested [`context`](/developer/language/reference/context) text.
+
+## Description
+
+For an example from [Developer 'rules'](/developer/language/guide/rules), a keyboard might implement the following rule
+
+```keyman
+"abc" + "d" > context(2) "D"
+```
+
+by first checking that the initial context (`"abc"`) matches and then using the following to fulfill the rule:
+
+```keyman
+keyman.interface.output(3, Pelem, keyman.interface.context(2, 1, Pelem));
+keyman.interface.output(0, Pelem, "D");
+```
+
+This operates by first replacing the original context `"abc"` with the requested subset of `context(2)`, then outputting the character (`"D"`) corresponding to the new keystroke.
+
+## See also
+
+- [`keyman.interface.contextMatch()`](contextMatch)
+- [`keyman.interface.output()`](output)
diff --git a/web/docs/engine/reference/interface/contextExOutput.md b/web/docs/engine/reference/interface/contextExOutput.md
new file mode 100644
index 0000000000..35a1801088
--- /dev/null
+++ b/web/docs/engine/reference/interface/contextExOutput.md
@@ -0,0 +1,52 @@
+---
+title: contextExOutput (KCXO)
+---
+
+## Summary
+
+`contextExOutput` function emits the character or object at `contextOffset` from the
+current matched rule's context. Introduced in Keyman 14.0, in order to resolve a
+gap between desktop and web core functionality for `context(n)` matching on `notany()`.
+
+## Syntax
+
+```js
+ keyman.interface.contextExOutput(dn, outputTarget, contextLength, contextOffset);
+```
+
+or
+
+```js
+ KeymanWeb.KCXO(dn, outputTarget, contextLength, contextOffset); // Shorthand
+```
+
+## Parameters
+
+`dn`
+: Type: `number`
+: number of characters to delete left of cursor
+
+`outputTarget`
+: Type: `OutputTarget`
+: target to output to
+
+`contextLength`
+: Type: `number`
+: length of current rule context to retrieve
+
+`contextOffset`
+: Type: `number`
+: offset from start of current rule context, 1-based
+
+## Returns
+
+`void`
+
+## See also
+
+* [`keyman.interface.output()`](output)
+* [`keyman.interface.indexOutput()`](indexOutput)
+
+## History
+
+* Introduced in Keyman 14.0
diff --git a/web/docs/engine/reference/interface/contextMatch.md b/web/docs/engine/reference/interface/contextMatch.md
new file mode 100644
index 0000000000..84a5641864
--- /dev/null
+++ b/web/docs/engine/reference/interface/contextMatch.md
@@ -0,0 +1,67 @@
+---
+title: contextMatch (KCM) (Deprecated)
+---
+
+## Summary
+
+(Deprecated) Context matching: Returns `true` if `context(n,ln,elem) == val`.
+
+## Syntax
+
+```keyman
+keyman.interface.contextMatch(n, Pelem, val, ln);
+```
+
+or
+
+```keyman
+KeymanWeb.KCM(n, Pelem, val, ln); // Shorthand
+```
+
+### Parameters
+
+`n`
+: Type: `number`
+: Relative position of the caret for the context match attempt.
+
+`Pelem`
+: Type: `Element`
+: The element being operated upon.
+
+`val`
+: Type: `string`
+: The desired text value for context to match.
+
+`ln`
+: Type: `number`
+: Number of characters of text context to match.
+
+### Return Value
+
+`boolean`
+: `true` if the context matches the specified value `val`, otherwise `false`.
+
+## Description
+
+This is a core element of keyboard input management within KeymanWeb in versions prior to 10.0, typically called automatically during keystroke processing events. For comparison with [Developer 'rules'](/developer/language/guide/rules) from keyboard source code, in the rule
+
+```keyman
+"a" + "'" > "á"
+```
+
+a keyboard would check that the initial context (`"a"`) matches by using
+
+```keyman
+keyman.interface.contextMatch(1, Pelem, "a", 1)
+```
+
+which checks, starting at the first character to the left of the caret, a single character to see if it matches the value "a".
+
+For versions 10.0 and later, please consider use of [`fullContextMatch()`](fullContextMatch) instead.
+
+## See also
+
+- [`fullContextMatch()`](fullContextMatch)
+- [`keyman.interface.context()`](context)
+- [`keyman.interface.output()`](output)
+- [`keyman.interface.keyMatch()`](keyMatch)
diff --git a/web/docs/engine/reference/interface/deadkeyMatch.md b/web/docs/engine/reference/interface/deadkeyMatch.md
new file mode 100644
index 0000000000..1307a82e96
--- /dev/null
+++ b/web/docs/engine/reference/interface/deadkeyMatch.md
@@ -0,0 +1,71 @@
+---
+title: deadkeyMatch (KDM) (Deprecated)
+---
+
+## Summary
+
+(Deprecated)Deadkey matching: Seeks to match the [`deadkey`](/developer/language/reference/deadkey) state `dk` at the relative caret position `n`.
+
+## Syntax
+
+```c
+keyman.interface.deadkeyMatch(n, Pelem, dk);
+```
+
+or
+
+```c
+KeymanWeb.KDM(n, Pelem, dk); // Shorthand
+```
+
+### Parameters
+
+`n`
+: Type: `number`
+: The position to match, relative to the caret's present position.
+
+`Pelem`
+: Type: `Element`
+: The HTML element receiving input.
+
+`dk`
+: Type: `number`
+: The deadkey id.
+
+### Return Value
+
+`boolean`
+: `true` if the specified deadkey exists at the specified input location, otherwise `false`.
+
+## Description
+
+Deadkeys are useful for tracking hidden state information used to modify future keystrokes. For example, rather than using
+
+```keyman
+"`" + "a" = "à"
+```
+
+to combine two visible characters, certain applications may desire to keep the `` "`" `` character hidden with a rule such as
+
+```keyman
++ '`' > dk(backquote)
+
+...
+
+dk(backquote) + "a" > "à"
+```
+
+The Developer compiler then generates a unique id for the deadkey state - say, `0`, and in order to detect the deadkey associated with the `` '`' `` character, compiles the `dk(backquote)` check to
+
+```c
+keyman.interface.deadkeyMatch(0, Pelem, 0)
+```
+
+which detects the existing deadkey (the second zero above) at the caret's present position (the first zero above).
+
+For versions 10.0 and later, please consider use of [`fullContextMatch()`](fullContextMatch) instead.
+
+## See also
+
+- [`keyman.interface.deadkeyOutput()`](deadkeyOutput)
+- [Wikipedia article on deadkeys](https://en.wikipedia.org/wiki/Dead_key)
diff --git a/web/docs/engine/reference/interface/deadkeyOutput.md b/web/docs/engine/reference/interface/deadkeyOutput.md
new file mode 100644
index 0000000000..36c6de624d
--- /dev/null
+++ b/web/docs/engine/reference/interface/deadkeyOutput.md
@@ -0,0 +1,66 @@
+---
+title: deadkeyOutput (KDO)
+---
+
+## Summary
+
+Deadkey output: Associates the [`deadkey`](/developer/language/reference/deadkey) state `dk` with the element at the current caret position, after overwriting `nd` characters.
+
+## Syntax
+
+```c
+keyman.interface.deadkeyOutput(nd, Pelem, dk);
+```
+
+or
+
+```c
+KeymanWeb.KDO(nd, Pelem, dk); // Shorthand
+```
+
+### Parameters
+
+`nd`
+: Type: `number`
+: The number of characters to overwrite (delete). May be set to `-1` or `0` to prevent overwrites.
+
+`Pelem`
+: Type: `Element`
+: The element receiving output.
+
+`dk`
+: Type: `number`
+: The deadkey id.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+Deadkeys are useful for tracking hidden state information used to modify future keystrokes. For example, rather than using
+
+```keyman
+"`" + "a" = "à"
+```
+
+to combine two visible characters, certain applications may desire to keep the `` "`" `` character hidden with a rule such as
+
+```keyman
++ '`' > dk(backquote)
+
+...
+
+dk(backquote) + "a" > "à"
+```
+
+The Developer compiler then generates a unique id for the deadkey state - say, `0`, and upon detecting input of the `` '`' `` character with the [`keyman.interface.deadkeyMatch()`](deadkeyMatch) function, compiles the deadkey generation to
+
+```c
+keyman.interface.deadkeyOutput(0, Pelem, 0);
+```
+
+## See also
+
+- [`keyman.interface.deadkeyMatch()`](deadkeyMatch)
+- [Wikipedia article on deadkeys](https://en.wikipedia.org/wiki/Dead_key)
diff --git a/web/docs/engine/reference/interface/deleteContext.md b/web/docs/engine/reference/interface/deleteContext.md
new file mode 100644
index 0000000000..28b6a0432f
--- /dev/null
+++ b/web/docs/engine/reference/interface/deleteContext.md
@@ -0,0 +1,57 @@
+---
+title: deleteContext (KDC)
+---
+
+## Summary
+
+Context deletion - removes the specified number of deadkeys and characters from before the caret.
+
+## Syntax
+
+```c
+keyman.interface.deleteContext(dn, Pelem);
+```
+
+or
+
+```c
+KeymanWeb.KDC(n, Pelem); // Shorthand
+```
+
+### Parameters
+
+`dn`
+: Type: `number`
+: The number of entries (deadkeys, characters) to be deleted from the current context.
+
+`Pelem`
+: Type: `Element`
+: The element being operated upon.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+This is a core element of keyboard input management within KeymanWeb introduced with version 10. It is utilized to manage the deletion of context in a deadkey-aware manner, in parallel to [`keyman.interface.fullContextMatch`](fullContextMatch). For comparison with [Developer 'rules'](/developer/language/guide/rules) from keyboard source code...
+
+```keyman
+store(pair_1) 'uU'
+store(pair_2) 'lL'
+
+c Lots of keyboard rules...
+
+'nul' dk(nothing) + '.' > nul
+```
+
+would have a rule output as follows:
+
+```c
+// Context is length four (three characters + one deadkey), so we delete all four.
+keyman.interface.deleteContext(4, element);
+```
+
+## See also
+
+- [`keyman.interface.fullContextMatch()`](fullContextMatch)
diff --git a/web/docs/engine/reference/interface/fullContextMatch.md b/web/docs/engine/reference/interface/fullContextMatch.md
new file mode 100644
index 0000000000..d6afed737f
--- /dev/null
+++ b/web/docs/engine/reference/interface/fullContextMatch.md
@@ -0,0 +1,137 @@
+---
+title: fullContextMatch (KFCM)
+---
+
+## Summary
+
+Context matching: Returns `true` if the current context matches the specified rule context specification.
+
+## Syntax
+
+```c
+keyman.interface.fullContextMatch(n, Pelem, rule);
+```
+
+or
+
+```c
+KeymanWeb.KFCM(n, Pelem, rule); // Shorthand
+```
+
+### Parameters
+
+`n`
+: Type: `number`
+: Relative position of the caret for the context match attempt.
+
+`Pelem`
+: Type: `Element`
+: The element being operated upon.
+
+`rule`
+: Type: `Array(ContextEntry)`
+: The rule context specification to be matched.
+
+### Return Value
+
+`boolean`
+: `true` if the context matches the rule specification `rule`, otherwise `false`.
+
+## Rule specification
+
+Each `ContextEntry` in the `rule` array must be one of the following six types:
+
+- A plain string with one character
+- A `DeadkeyEntry` object with the following members:
+
+ `t`
+ : `'d'`
+ : Indicates to expect a [`deadkey`](/developer/language/reference/deadkey) entry.
+
+ `d`
+ : `number`
+ : The integer ID of the deadkey to match.
+
+- An `AnyEntry` object with the following members:
+
+ `t`
+ : `'a'`
+ : Indicates the use of an [`any`](/developer/language/reference/any) statement.
+
+ `a`
+ : `string`
+ : The store string to be searched for a context match
+
+ `n`
+ : `boolean` *optional*
+ : `true` signals to negate the match, as with a [`notany`](/developer/language/reference/notany) statement.
+
+- An `IndexEntry` object with the following members:
+
+ `t`
+ : `'i'`
+ : Indicates the use of an [`index`](/developer/language/reference/index) statement.
+
+ `i`
+ : `string`
+ : the store string to be indexed for output corresponding to a previous `any`
+
+ `o`
+ : `number`
+ : the index of the corresponding `any` in the rule's context, starting from 1.
+
+- A `ContextEx` object with the following members:
+
+ `t`
+ : `'c'`
+ : Indicates the use of a [`context`](/developer/language/reference/context) statement.
+
+ `c`
+ : `number`
+ : The position in context to be matched by the current context location.
+
+- A `NulEntry` object with the following member:
+
+ `t`
+ : `'n'`
+ : Indicates the use of a context-based [`nul`](/developer/language/reference/nul) rule.
+
+The rule will be interpreted left to right, starting at the specified relative position to the caret.
+
+## Description
+
+This is a core element of keyboard input management within KeymanWeb introduced with version 10.0, typically called automatically during keystroke processing events. For comparison with [Developer 'rules'](/developer/language/guide/rules) from keyboard source code...
+
+```keyman
+store(pair_1) 'aA'
+store(pair_2) 'bB'
+
+c Lots of keyboard rules...
+
+dk(money) 'c' any(pair_1) index(pair_2, 3) + '.' > 'taxi'
+```
+
+would have Javascript roughly as follows:
+
+```c
+// In the keyboard store definitions:
+this.s_pair_1 = 'aA'; // store(pair_1) 'aA'
+this.s_pair_2 = 'bB'; // store(pair_2) 'bB'
+
+// For the deadkey:
+this.d_money = 0; // dk(money)'s internal id
+
+// Within the keyboard rule-matching function:
+var matched = keyman.interface.fullContextMatch(4, element, {
+ {t:'d', d:this.d_money}, // dk(money)
+ 'c', // 'c'
+ {t:'a', a:this.s_pair_1}, // 'any(pair_1)'
+ {t:'i', i:this.s_pair_2, o:3} // 'index(pair_2, 3)'
+});
+```
+
+## See also
+
+- [The Keyman Keyboard Language Reference](/developer/language/reference)
+- [`keyman.interface.contextMatch()`](contextMatch)
+- [`keyman.interface.deleteContext()`](deleteContext)
diff --git a/web/docs/engine/reference/interface/ifStore.md b/web/docs/engine/reference/interface/ifStore.md
new file mode 100644
index 0000000000..64252cffc1
--- /dev/null
+++ b/web/docs/engine/reference/interface/ifStore.md
@@ -0,0 +1,62 @@
+---
+title: ifStore (KIFS)
+---
+
+## Summary
+
+`ifStore` compares the content of a [system `store`](/developer/language/guide/stores#toc-system-stores) with a string value.
+
+## Syntax
+
+```c
+keyman.interface.ifStore(systemId, strValue, Pelem);
+```
+
+or
+
+```c
+KeymanWeb.KIFS(systemId, strValue, Pelem);
+```
+
+### Parameters
+
+`systemId`
+: Type: `number`
+: The ID of the system store to test.
+
+`strValue`
+: Type: `string`
+: The string value to be used for comparison.
+
+`Pelem`
+: Type: `Element`
+: The page element currently active. (This parameter exists for use by possible future extensions.)
+
+### Return Value
+
+`boolean`
+: `true` if the value matches that of the system store, otherwise `false`.
+
+## Description
+
+Only system IDs `31` (`platform`) and `33` (`layer`) are currently supported.
+
+For `platform`, any combination of the following may be tested against the current device and browser:
+
+- Input method:
+: `['touch', 'hardware']`
+
+- any combination of OS:
+: `['windows', 'android', 'ios', 'macosx', 'linux']`
+
+- form factor:
+: `['desktop', 'tablet', 'phone']`
+
+- browser:
+: `['native', 'web', 'ie', 'chrome', 'firefox', 'safari', 'opera']`
+
+Only one of each category may be matched at a time.
+
+## See also
+
+- [`keyman.interface.setStore()`](setStore)
diff --git a/web/docs/engine/reference/interface/index.md b/web/docs/engine/reference/interface/index.md
new file mode 100644
index 0000000000..d257b7e3e3
--- /dev/null
+++ b/web/docs/engine/reference/interface/index.md
@@ -0,0 +1,107 @@
+---
+title: Output Functions - the Keyboard API
+---
+
+The KeymanWeb core object `window.keyman.interface` (with legacy-oriented, deprecated alias `KeymanWeb`) exposes a number of functions for low-level processing of input, context and output. These functions are designed for use by keyboards compiled through Keyman Developer in order to facilitate input text processing and will also work for custom-coded KeymanWeb keyboards. As such, most of these functions should only be called by keyboard code, and a good understanding of the [Keyman Keyboard Language](/developer/language) will prove extremely beneficial toward understanding the keyboard API functions enumerated in this section.
+
+Custom user interfaces would not normally use these functions, but they are described here as some custom keyboards, such as IME-style keyboards, may need to interact with the user interface.
+
+[`any` Function (Deprecated)](any)
+: Returns whether or not the char `ch` is found within the [`any`](/developer/language/reference/any)([`store`](/developer/language/reference/store)) string, setting an internally-tracked index for use in the `indexOutput` function.
+: Shorthand name: `KeymanWeb.KA`
+
+[`beep` Function](beep)
+: Flash body or element as substitute for an audible feedback [`beep`](/developer/language/reference/beep).
+: Shorthand name: `KeymanWeb.KB`
+
+[`beepReset` Function](beepReset)
+: Cancels a previous feedback [`beep`](/developer/language/reference/beep) operation on a page element.
+: Shorthand name: `KeymanWeb.KBR`
+
+[`context` Function (Deprecated)](context)
+: Gets [`context`](/developer/language/reference/context) for an ongoing keyboard operation relative to the caret's present position.
+: Shorthand name: `KeymanWeb.KC`
+
+[`contextExOutput` Function](contextExOutput)
+: Emits the character or object at `contextOffset` from the current matched rule's context.
+: Shorthand name: `KeymanWeb.KCXO`
+
+[`contextMatch` Function (Deprecated)](contextMatch)
+: Context matching: Returns `true` if the specified `context` call matches a provided string.
+: Shorthand name: `KeymanWeb.KCM`
+
+[`deadkeyMatch` Function (Deprecated)](deadkeyMatch)
+: Deadkey matching: Seeks to match the [`deadkey`](/developer/language/reference/deadkey) state `dk` at the relative caret position `n`.
+: Shorthand name: `KeymanWeb.KDM`
+
+[`deadkeyOutput` Function](deadkeyOutput)
+: Deadkey output: Associates the [`deadkey`](/developer/language/reference/deadkey) state `dk` with the element at the current caret position, after overwriting `nd` characters.
+: Shorthand name: `KeymanWeb.KDO`
+
+[`deleteContext` Function](deleteContext)
+: Context deletion - removes the specified number of deadkeys and characters from the left of the caret.
+: Shorthand name: `KeymanWeb.KDC`
+
+[`fullContextMatch` Function](fullContextMatch)
+: Context matching: Returns `true` if the current context matches the specified rule context specification.
+: Shorthand name: `KeymanWeb.KFCM`
+
+[`ifStore` Function](ifStore)
+: `ifStore` compares the content of a [system `store`](/developer/language/guide/stores#toc-system-stores) with a string value.
+: Shorthand name: `KeymanWeb.KIFS`
+
+[`indexOutput` Function](indexOutput)
+: Index-based output: Outputs a mapped character according to a previous selection from a `keyman.interface.any()` call upon a [`store`](/developer/language/reference/store) string, after deleting `nd` characters.
+: Shorthand name: `KeymanWeb.KIO`
+
+[`insertText` Function](insertText)
+: Inserts a text string and optional [`deadkey`](/developer/language/reference/deadkey) into the active output element.
+: Shorthand name: `KeymanWeb.KT`
+
+[`isKeypress` Function](isKeypress)
+: Returns `true` if the input event corresponds to a keypress event resulting in character output.
+: Shorthand name: `KeymanWeb.KIK`
+
+[`keyInformation` Function](keyInformation)
+: Returns an object with extended information about a specified keystroke event.
+: Shorthand name: `KeymanWeb.KKI`
+
+[`keyMatch` Function](keyMatch)
+: Keystroke matching: Returns `true` if the event matches the rule's shift mask and key code.
+: Shorthand name: `KeymanWeb.KKM`
+
+[`loadStore` Function](loadStore)
+: Load an option [`store`](/developer/language/guide/stores) value from a cookie or default value if no prior stored value exists.
+: Shorthand name: `KeymanWeb.KLOAD`
+
+[`nul` Function](_nul)
+: [`nul`](/developer/language/reference/nul) context check: Returns `true` if the length of the [`context`](/developer/language/reference/context) is less than or equal to `n` characters.
+: Shorthand name: `KeymanWeb.KN`
+
+[`output` Function](output)
+: Outputs the specified string to an element, overwriting characters before the caret if specified.
+: Shorthand name: `KeymanWeb.KO`
+
+[`registerKeyboard` Function](registerKeyboard)
+: Register the keyboard stub and load the keyboard.
+: Shorthand name: `KeymanWeb.KR`
+
+[`registerStub` Function](registerStub)
+: Register the keyboard stub, return true if already registered.
+: Shorthand name: `KeymanWeb.KRS`
+
+[`saveFocus` Function](saveFocus)
+: Save focus: Temporarily saves keyboard processing data for the currently-focused control.
+: Shorthand name: `KeymanWeb.KSF`
+
+[`saveStore` Function](saveStore)
+: Save an option [`store`](/developer/language/guide/stores) value to a cookie for the active keyboard.
+: Shorthand name: `KeymanWeb.KSAVE`
+
+[`setStore` Function](setStore)
+: `setStore` sets the value of a [system `store`](/developer/language/guide/stores#toc-system-stores) to a string.
+: Shorthand name: `KeymanWeb.KSETS`
+
+[`stateMatch` Function](stateMatch)
+: State-key matching: Returns `true` if the event matches the rule's state-key requirements.
+: Shorthand name: `KeymanWeb.KSM`
diff --git a/web/docs/engine/reference/interface/indexOutput.md b/web/docs/engine/reference/interface/indexOutput.md
new file mode 100644
index 0000000000..2654f37147
--- /dev/null
+++ b/web/docs/engine/reference/interface/indexOutput.md
@@ -0,0 +1,61 @@
+---
+title: indexOutput (KIO)
+---
+
+## Summary
+
+Index-based output: Outputs a mapped character according to a previous selection from a `keyman.interface.any()` call upon a [`store`](/developer/language/reference/store) string, after deleting `nd` characters.
+
+## Syntax
+
+```c
+keyman.interface.indexOutput(nd, store, index, Pelem);
+```
+
+or
+
+```c
+KeymanWeb.KIO(nd, store, index, Pelem);
+```
+
+### Parameters
+
+`nd`
+: Type: `number`
+: The number of characters to be overwritten.
+
+`store`
+: Type: `string`
+: The store string to be used for mapping a character previously detected via `keyman.interface.any()`, which itself maps to a [`any`](/developer/language/reference/any) call.
+
+`index`
+: Type: `number`
+: The index id to which the detected character's index in the original matching array was saved. The index id should be incremented by 1 relative to the value specified in `keyman.interface.any()`.
+
+`Pelem`
+: Type: `Element`
+: The HTML element receiving the output.
+
+## Description
+
+This function corresponds most directly to the keyboard language command [`index`](/developer/language/reference/index), which operates upon text [`store`](/developer/language/reference/store)s to allow for array-based input-output text matching. For example,
+
+```keyman
+store(keys) 'abcde'
+store(output) 'αβγδε'
++ any(keys) > index(output,1)
+```
+
+facilitates mapping the characters `'abcde'` to their respective entry in the output store `'αβγδε'`. `keyman.interface.indexOutput()`'s role in this process is usually optimized out into individual mappings for performance reasons, though it is often involved when `any` is involved as part of a rule's `context`, rather than upon the triggering keystroke itself.
+
+In order to output the desired character corresponding to `'a'` in the `output` store above, the code
+
+```c
+keyman.interface.indexOutput(0, 'αβγδε', 1, Pelem)
+```
+
+would suffice, overwriting no characters and using the previously-matched index (id = 0 + 1). Note that the `keyman.interface.indexOutput()` call must increment the id by 1 due to Keyman's keyboard language rules, which corresponds directly to the `index` call in the keyboard source above.
+
+## See also
+
+- [`keyman.interface.any()`](any)
diff --git a/web/docs/engine/reference/interface/insertText.md b/web/docs/engine/reference/interface/insertText.md
new file mode 100644
index 0000000000..313ae07f8d
--- /dev/null
+++ b/web/docs/engine/reference/interface/insertText.md
@@ -0,0 +1,38 @@
+---
+title: insertText (KT)
+---
+
+## Summary
+
+Inserts a text string and optional [`deadkey`](/developer/language/reference/deadkey) into the active output element.
+
+## Syntax
+
+```c
+keyman.interface.insertText(text, dk);
+```
+
+or
+
+```c
+KeymanWeb.KT(text, dk); // Shorthand
+```
+
+### Parameters
+
+`text`
+: Type: `string`
+: The text to insert.
+
+`dk`
+: Type: `number` *optional*
+: The deadkey's id, if one is to be inserted.
+
+### Return Value
+
+`boolean`
+: `true` if the operation is successful, otherwise `false`.
+
+## Description
+
+This function is designed to allow custom UI elements or custom OSK displays (as for the [EuroLatin keyboard](https://keymanweb.com/#aae,Keyboard_sil_euro_latin)) to directly insert input into a control without losing the current input state due to loss of focus for the control. It is safe for use outside of keyboard code.
diff --git a/web/docs/engine/reference/interface/isKeypress.md b/web/docs/engine/reference/interface/isKeypress.md
new file mode 100644
index 0000000000..c5edbcf913
--- /dev/null
+++ b/web/docs/engine/reference/interface/isKeypress.md
@@ -0,0 +1,36 @@
+---
+title: isKeypress (KIK)
+---
+
+## Summary
+
+Returns `true` if the input event corresponds to a keypress event resulting in character output.
+
+## Syntax
+
+```c
+keyman.interface.isKeypress(e);
+```
+
+or
+
+```c
+KeymanWeb.KIK(e); // Shorthand
+```
+
+### Parameters
+
+`e`
+: Type: `Object`
+: The event object to be evaluated.
+
+### Return Value
+
+`boolean`
+: `true` if the event would produce text output, otherwise `false`.
+
+## Description
+
+This function is designed to facilitate filtering of keystrokes, allowing custom-coded keyboards to ignore function-oriented keystroke events that should never be used for text generation, such as for F1-F12.
+
+The logic corresponds to that for the keyboard language [`nomatch`](/developer/language/reference/nomatch) rule.
diff --git a/web/docs/engine/reference/interface/keyInformation.md b/web/docs/engine/reference/interface/keyInformation.md
new file mode 100644
index 0000000000..3d64bff3f0
--- /dev/null
+++ b/web/docs/engine/reference/interface/keyInformation.md
@@ -0,0 +1,62 @@
+---
+title: keyInformation (KKI)
+---
+
+## Summary
+
+Returns an object with extended information about a specified keystroke event.
+
+## Syntax
+
+```c
+keyman.interface.keyInformation(e);
+```
+
+or
+
+```c
+KeymanWeb.KKI(e); // Shorthand
+```
+
+### Parameters
+
+`e`
+: Type: `Object`
+: The event object to be evaluated.
+
+### Return Value
+
+`Object`
+: An object with extended key event information.
+
+## Description
+
+---
+**Note:** This function will not succeed if it is called from outside of a keyboard's standard text-processing operations.
+
+---
+
+The `key_event` object contains the following members:
+
+`vk`
+: `boolean`
+: A flag indicating whether or not the event corresponds to a virtual key.
+
+`code`
+: `number`
+: The underlying keycode for the event.
+
+`modifiers`
+: `number`
+: A set of bit-flags corresponding to the SHIFT, CTRL, and ALT state of the keyboard.
+
+The bit masks for each modifier are as follows:
+
+- SHIFT
+: `0x10`
+
+- CTRL
+: `0x20`
+
+- ALT
+: `0x40`
diff --git a/web/docs/engine/reference/interface/keyMatch.md b/web/docs/engine/reference/interface/keyMatch.md
new file mode 100644
index 0000000000..52fe8f368d
--- /dev/null
+++ b/web/docs/engine/reference/interface/keyMatch.md
@@ -0,0 +1,61 @@
+---
+title: keyMatch (KKM)
+---
+
+## Summary
+
+Keystroke matching: Returns `true` if the event matches the rule's shift mask and key code.
+
+## Syntax
+
+```c
+keyman.interface.keyMatch(e, shiftCode, keyCode);
+```
+
+or
+
+```c
+KeymanWeb.KKM(e, shiftCode, keyCode); // Shorthand
+```
+
+### Parameters
+
+`e`
+: Type: `Object`
+: A keystroke-related event object to match.
+
+`shiftCode`
+: Type: `number`
+: The shift-state code the event object should match.
+
+`keyCode`
+: Type: `number`
+: The key code the event object should match.
+
+### Return Value
+
+`boolean`
+: `true` if the keystroke matches the desired values, otherwise `false`.
+
+## Description
+
+This is a core element of keyboard input management within KeymanWeb, typically called automatically during keystroke processing events. For comparison with [Developer 'rules'](/developer/language/guide/rules) from keyboard source code, in the rule
+
+```keyman
+"a" + "'" > "á"
+```
+
+a keyboard would check that the triggering keystroke (`"'"`) matches by using
+
+```keyman
+keyman.interface.keyMatch(e, 0, 39)
+```
+
+from within a raised keystroke event with object `e`, which checks that the keystroke represented by `e` is unshifted and matches the underlying keycode value for `"'"`, which is `39` in ASCII and Unicode.
+
+As `keyman.interface.keyMatch()` receives an event object as one of its parameters, it does not need a direct link to the element receiving input.
+
+## See also
+
+- [`keyman.interface.contextMatch()`](contextMatch)
+- [`keyman.interface.stateMatch()`](stateMatch)
diff --git a/web/docs/engine/reference/interface/loadStore.md b/web/docs/engine/reference/interface/loadStore.md
new file mode 100644
index 0000000000..c8ccee5616
--- /dev/null
+++ b/web/docs/engine/reference/interface/loadStore.md
@@ -0,0 +1,46 @@
+---
+title: loadStore (KLOAD)
+---
+
+## Summary
+
+Load an option [`store`](/developer/language/guide/stores) value from a cookie or default value if no prior stored value exists.
+
+## Syntax
+
+```c
+keyman.interface.loadStore(kbdName, storeName, value);
+```
+
+or
+
+```c
+KeymanWeb.KLOAD(kbdName, storeName, value); // Shorthand
+```
+
+### Parameters
+
+`kbdName`
+: Type: `string`
+: The keyboard's identifying internal name.
+
+`storeName`
+: Type: `string`
+: The option `store` name that is embedded in the cookie's name.
+
+`value`
+: Type: `string`
+: A value for the store to use as default if no prior value exists.
+
+### Return Value
+
+`string`
+: The current value of the store, or the default `value` provided if the store's value is `undefined`.
+
+## Description
+
+`keyman.interface.loadStore()` and [`keyman.interface.saveStore()`](saveStore) provide API-based functionality similar to that of the keyboard language's option `store`. Values will persist across multiple visits to the site by use of cookies. However, these functions cannot interact with `store`s from existing compiled keyboards due to compilation optimizations. As such, they are most useful for custom-coded web-oriented keyboards.
+
+## See also
+
+- [`keyman.interface.saveStore();`](saveStore)
diff --git a/web/docs/engine/reference/interface/output.md b/web/docs/engine/reference/interface/output.md
new file mode 100644
index 0000000000..81e53ff1ce
--- /dev/null
+++ b/web/docs/engine/reference/interface/output.md
@@ -0,0 +1,57 @@
+---
+title: output (KO)
+---
+
+## Summary
+
+Outputs the specified string to an element, overwriting `nd` characters before the caret.
+
+## Syntax
+
+```c
+keyman.interface.output(nd, Pelem, str);
+```
+
+or
+
+```c
+KeymanWeb.KO(nd, Pelem, str); // Shorthand
+```
+
+### Parameters
+
+`nd`
+: Type: `number`
+: The number of characters to overwrite. Passively ignores values less than zero.
+
+`Pelem`
+: Type: `Element`
+: The input element to receive the output text.
+
+`str`
+: Type: `string`
+: The output text to write to the input element.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+This is a core element of keyboard input management within KeymanWeb, typically called automatically during keystroke processing events. For comparison with [Developer 'rules'](/developer/language/guide/rules) from keyboard source code, in the rule
+
+```keyman
+"a" + "'" > "á"
+```
+
+a keyboard would, after checking that the initial context (`"a"`) matches, use
+
+```c
+keyman.interface.output(1, Pelem, "á");
+```
+
+to erase one character `"a"` and output one character `"á"`, effectively performing the desired replacement.
+
+## See also
+
+- [`keyman.interface.contextMatch()`](contextMatch)
diff --git a/web/docs/engine/reference/interface/registerKeyboard.md b/web/docs/engine/reference/interface/registerKeyboard.md
new file mode 100644
index 0000000000..ea2917f3b9
--- /dev/null
+++ b/web/docs/engine/reference/interface/registerKeyboard.md
@@ -0,0 +1,37 @@
+---
+title: registerKeyboard (KR)
+---
+
+## Summary
+
+Registers and loads the keyboard.
+
+## Syntax
+
+```c
+keyman.interface.registerKeyboard(Pk);
+```
+
+or
+
+```c
+KeymanWeb.KR(Pk); // Shorthand
+```
+
+### Parameters
+
+`Pk`
+: Type: `Object`
+: The keyboard object to be loaded and registered.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+---
+**Note:** Any calls made to this function before KeymanWeb has initialized will be deferred until initialization occurs. Furthermore, an existing keyboard stub must exist for KeymanWeb to fully link with the keyboard.
+
+---
+This keyboard object is typically provided directly by the keyboard-loading process employed within KeymanWeb and its keyboard source files.
diff --git a/web/docs/engine/reference/interface/registerStub.md b/web/docs/engine/reference/interface/registerStub.md
new file mode 100644
index 0000000000..2d9c8ef5a8
--- /dev/null
+++ b/web/docs/engine/reference/interface/registerStub.md
@@ -0,0 +1,39 @@
+---
+title: registerStub (KRS)
+---
+
+## Summary
+
+Registers the keyboard stub or returns true if already registered.
+
+## Syntax
+
+```c
+keyman.interface.registerStub(Pstub);
+```
+
+or
+
+```c
+KeymanWeb.KRS(Pstub); // Shorthand
+```
+
+### Parameters
+
+`Pstub`
+: Type: `Object`
+: A keyboard stub object representing the keyboard's basic lookup parameters.
+
+### Return Value
+
+`optional number`
+: `1` if the keyboard is preregistered, otherwise `null`.
+
+## Description
+
+---
+**Note:** This only registers the stub with KeymanWeb, allowing it to later request the keyboard from the server or filesystem upon demand in order to complete the linking process.
+
+---
+
+The `keyman.interface.registerStub` function is typically called on the user's behalf by the [`keyman.addKeyboards()`](../core/addKeyboards) function.
diff --git a/web/docs/engine/reference/interface/saveFocus.md b/web/docs/engine/reference/interface/saveFocus.md
new file mode 100644
index 0000000000..417761c066
--- /dev/null
+++ b/web/docs/engine/reference/interface/saveFocus.md
@@ -0,0 +1,35 @@
+---
+title: saveFocus (KSF)
+---
+
+## Summary
+
+Save focus: Temporarily saves keyboard processing data for the currently-focused control.
+
+## Syntax
+
+```c
+keyman.interface.saveFocus()
+```
+
+or
+
+```c
+KeymanWeb.KSF() // Shorthand
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+Use this function to temporarily preserve all keyboard processing information during a single change-of-focus event.
+
+This function is designed to allow custom UI elements, custom OSK displays (as for the [EuroLatin keyboard](https://keymanweb.com/#aae,Keyboard_sil_euro_latin)), or keyboards with picker-style functionality (such as the [Japanese keyboard](https://keymanweb.com/#jpn,Keyboard_japanese)) to operate without losing the current input state due to loss of focus for the active control.
+
+A good example of when to call this function would be for `onmousedown` events for visual elements not intended to change the element of focus within KeymanWeb. It is safe for use outside of keyboard code.
diff --git a/web/docs/engine/reference/interface/saveStore.md b/web/docs/engine/reference/interface/saveStore.md
new file mode 100644
index 0000000000..7855b9bf5f
--- /dev/null
+++ b/web/docs/engine/reference/interface/saveStore.md
@@ -0,0 +1,42 @@
+---
+title: saveStore (KSAVE)
+---
+
+## Summary
+
+Save an option [`store`](/developer/language/guide/stores) value to a cookie for the active keyboard.
+
+## Syntax
+
+```c
+keyman.interface.saveStore(storeName, value);
+```
+
+or
+
+```c
+KeymanWeb.KSAVE(storeName, value); // Shorthand
+```
+
+### Parameters
+
+`storeName`
+: Type: `string`
+: The option `store` name, which will be embedded in the cookie's name.
+
+`value`
+: Type: `string`
+: The option value to save.
+
+### Return Value
+
+`boolean`
+: `true` if the operation is successful, otherwise `false`.
+
+## Description
+
+[`keyman.interface.loadStore()`](loadStore) and `keyman.interface.saveStore()`provide API-based functionality similar to that of the keyboard language's option `store`. Values will persist across multiple visits to the site by use of cookies. However, these functions cannot interact with `store`s from existing compiled keyboards due to compilation optimizations. As such, they are most useful for custom-coded web-oriented keyboards.
+
+## See also
+
+- [`keyman.interface.loadStore();`](loadStore)
diff --git a/web/docs/engine/reference/interface/setStore.md b/web/docs/engine/reference/interface/setStore.md
new file mode 100644
index 0000000000..1244e51c51
--- /dev/null
+++ b/web/docs/engine/reference/interface/setStore.md
@@ -0,0 +1,48 @@
+---
+title: setStore (KSETS)
+---
+
+## Summary
+
+`setStore` sets the value of a [system `store`](/developer/language/guide/stores#toc-system-stores) to a string.
+
+## Syntax
+
+```c
+keyman.interface.setStore(systemId, strValue, Pelem);
+```
+
+or
+
+```c
+KeymanWeb.KSETS(systemId, strValue, Pelem); // Shorthand
+```
+
+### Parameters
+
+`systemId`
+: Type: `number`
+: The ID of the system store to set. Only system ID `33` (`layer`) is currently supported.
+
+`strValue`
+: Type: `string`
+: The string value to set as the system store's content.
+
+`Pelem`
+: Type: `Element`
+: The page element currently active. (This parameter exists for use by possible future extensions.)
+
+### Return Value
+
+`boolean`
+: `true` if the operation succeeds, otherwise `false`.
+
+## Description
+
+This function is used to set the value of writeable system stores. Many system stores are readonly, containing metadata about an individual keyboard, so `keyman.interface.ifStore()` will fail upon attempts to modify their values.
+
+This function cannot modify standard keyboard [`stores`](/developer/language/guide/stores) and is limited to system `stores` only, as standard keyboard stores are optimized into Javascript string literals set directly in code with automatically-generated names.
+
+## See also
+
+- [`keyman.interface.ifStore()`](ifStore)
diff --git a/web/docs/engine/reference/interface/stateMatch.md b/web/docs/engine/reference/interface/stateMatch.md
new file mode 100644
index 0000000000..5dbc4f3612
--- /dev/null
+++ b/web/docs/engine/reference/interface/stateMatch.md
@@ -0,0 +1,61 @@
+---
+title: stateMatch (KSM)
+---
+
+## Summary
+
+State-key matching: Returns `true` if the event matches the rule's state-key requirements.
+
+## Syntax
+
+```c
+keyman.interface.stateMatch(e, shiftCode);
+```
+
+or
+
+```c
+KeymanWeb.KSM(e, shiftCode); // Shorthand
+```
+
+### Parameters
+
+`e`
+: Type: `Object`
+: A keystroke-related event object to match.
+
+`state`
+: Type: `number`
+: The state-key bitflags the event should match.
+
+### Return Value
+
+`boolean`
+: `true` if the keystroke matches the desired states, otherwise `false`.
+
+## Description
+
+As of KeymanWeb 10.0, KeymanWeb now supports keyboard rules conditioned upon 'state keys' like Caps Lock [if specified by keyboard developers](/developer/language/guide/virtual-keys#toc-caps-lock).
+
+The `stateMatch` function examines the bit-flags to determine the state keys being tested and compares the keyboard event against them as appropriate. As such, it is designed to be a condition check alongside [`keyman.interface.keyMatch()`](keyMatch) and [`keyman.interface.contextMatch()`](contextMatch).
+
+For comparison with [Developer 'rules'](/developer/language/guide/virtual-keys#toc-caps-lock) from keyboard source code, in the rule
+
+```keyman
++ [CAPS K_A] > 'BIG A'
++ [NCAPS K_A] > 'small a'
+```
+
+a keyboard would check which rule the triggering keystroke (`"a"`) matches by using
+
+```c
+keyman.interface.stateMatch(e, 0x100)
+```
+
+from within a raised keystroke event with object `e`, which checks that the keystroke represented by `e` has an activated Caps Lock state as represented by the code 0x0100. The NCAPS rule would instead compare against 0x0200.
+
+As `keyman.interface.stateMatch()` receives an event object as one of its parameters, it does not need a direct link to the element receiving input.
+
+## See also
+
+- [`keyman.interface.keyMatch()`](keyMatch)
diff --git a/web/docs/engine/reference/keyboard_properties.md b/web/docs/engine/reference/keyboard_properties.md
new file mode 100644
index 0000000000..a5c5ac6b2e
--- /dev/null
+++ b/web/docs/engine/reference/keyboard_properties.md
@@ -0,0 +1,97 @@
+---
+title: Keyboard Properties
+---
+
+Most keyboards are generated automatically from the Keyman keyboard source by
+_Keyman Developer_ and contain properties used by _KeymanWeb_ during keyboard
+mapping. Keyboards implement mapping by invoking functions within _KeymanWeb_,
+but do not interact directly with the user interface. However, user interfaces
+may need to interact with custom developed keyboards if, for example, they use a
+"pick list" or have other IME-like behavior.
+
+Each registered keyboard object defines some or all of the following exposed
+string properties:
+
+`KN`
+
+: `string`, (`name`) visible name of the keyboard, required.
+
+`KI`
+
+: `string`, (`internalName`) identifier of the keyboard, starting with `Keyboard_`, required.
+
+`KMINVER`
+
+: `string`, minimum version that the keyboard will run on, `2.0` if not present, optional.
+
+`KV`
+
+: `object`, on screen keyboard definition, optional.
+
+`KDU`
+
+: `number`, `1` to display underlying characters on On Screen Keyboard, `0` or omitted to hide them, optional
+
+`KH`
+
+: `string`, Keyboard help, in HTML; if present replaces `KV` in the On Screen Keyboard, optional
+
+`KM`
+
+: `number`, `1` to use mnemonic layout, `0` or omitted for positional, optional
+
+`KBVER`
+
+: `string`, version of the keyboard (should be dotted decimal format), optional
+
+`KMBM`
+
+: `number`, bitmask denoting modifiers used in the keyboard, if not present defaults to 0x0070, optional
+
+`KVKL`
+
+: `object`, touch layout definition, optional.
+
+`KVER`
+
+: `string`, version of Keyman Developer used to compile the keyboard, optional
+
+`KVS`
+
+: `string[]`, array of all variable store names found in the keyboard (15.0 and later), optional
+
+`KS`
+
+: `number`, `1` means Unicode characters U+10000-U+10FFFF, including the Supplementary Multilingual Plane (SMP), are used in the keyboard, optional
+
+`KVKD`
+
+: `object`, Virtual key dictionary listing custom touch keys used in the keyboard, optional
+
+`KCSS`
+
+: `string`, Custom CSS defined by the keyboard, optional
+
+`KFont`
+
+: `object`, Embedded font specification for mapped input elements and on-screen keyboard, optional
+
+`KOskFont`
+
+: `object`, Embedded font specification for on-screen keyboard, optional
+
+For most keyboards which require an embedded font, the same font will be used
+for mapped elements and the on-screen keyboard, and only the `KFont` property
+wil be defined. The additional property `KOskFont` property would only be used
+where it may be helpful to use a different embedded font for the on-screen
+keyboard.
+
+The `KFont` and `KOskFont` members are objects with the following members:
+
+`family`
+
+: `string`, font-family name for embedded font, e.g. `'LatinWeb'`
+
+`files`
+
+: `string` or `string[]`, Font file name or names, e.g. `['DejaVuSans.ttf','DejaVuSans.woff','DejaVuSans.eot']`
diff --git a/web/docs/engine/reference/keyboard_registration_errors.md b/web/docs/engine/reference/keyboard_registration_errors.md
new file mode 100644
index 0000000000..9ff4214bc9
--- /dev/null
+++ b/web/docs/engine/reference/keyboard_registration_errors.md
@@ -0,0 +1,55 @@
+---
+title: Keyboard Registration Errors
+---
+
+If KeymanWeb has an error while adding/registering a keyboard, the `ErrorStub` object containing the following members is returned:
+
+`keyboard`
+
+: `object` optional
+
+ Information on the keyboard
+
+`language`
+
+: `object` optional
+
+ Information on the language associated with the keyboard
+
+`error`
+
+: `Error`
+
+ Javascript error that occurred during keyboard registration
+
+---
+
+The `ErrorStub.keyboard` object contains the following members:
+
+`id`
+
+: `string`
+
+ID (internal name) of keyboard
+
+`name`
+
+: `string`
+
+Name of the keyboard
+
+---
+
+The `ErrorStub.language` object contains the following members:
+
+`id`
+
+: `string`
+
+BCP 47 code for supported keyboard language. If a keyboard supports multiple languages, an array of ErrorStubs is returned.
+
+`name`
+
+: `string`
+
+Name of the language
diff --git a/web/docs/engine/reference/layouts.md b/web/docs/engine/reference/layouts.md
new file mode 100644
index 0000000000..df3e3b50c7
--- /dev/null
+++ b/web/docs/engine/reference/layouts.md
@@ -0,0 +1,5 @@
+---
+title: Layout Designer
+---
+
+One of the main features of *KeymanWeb 17* is its ability to support distinct, user-customizable layouts for touch-screen keyboards on phones and tablets. *Keyman Developer 17* includes a layout designer to simplify the process of creating custom layouts for any keyboard.
diff --git a/web/docs/engine/reference/layoutspec.md b/web/docs/engine/reference/layoutspec.md
new file mode 100644
index 0000000000..2cdaec1fff
--- /dev/null
+++ b/web/docs/engine/reference/layoutspec.md
@@ -0,0 +1,402 @@
+---
+title: Layout Specifications
+---
+
+Touch-screen layouts for *KeymanWeb 17* are specified as JSON objects containing a member object for each specified device type. Currently supported device types are *tablet* and *phone*. Layouts for *desktop* computers may also be specified but desktop on-screen keyboard design is normally managed by the
+standard *Keyman Developer* on-screen keyboard tool rather than the keyboard layout designer. If the same
+layout is appropriate for both *tablet* and *phone* devices only one need be specified, and will be used for either type of device.
+
+File encoding for manually-created layout files may use either UTF-8 or 7-bit ANSI coding, but must not include a BOM. For easier editing and management without requiring special fonts, embedded Unicode characters with values above 127 may use the *\uXXXX* notation.
+
+For details of the JSON specification, see [The JSON Data Interchange Format(ECMA-404)](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).
+
+
+
+
+
+Details of key member specifications are given below:
+
+
+
+
+
+For many keyboards, it is helpful to associate some keyboard layers with physical keyboard modifier states. This is reflected in the layer name, where a layer name of *shift* means that when a key in that layer is touched, the keystroke will be processed as if the keyboard Shift key is held.
+
+The special layer names of:
+ *leftalt* ,
+ *rightalt* ,
+ *alt* ,
+ *leftctrl* ,
+ *rightctrl* ,
+ *ctrl* ,
+ *ctrlalt* ,
+ *leftctrl-leftalt* ,
+ *rightctrl-rightalt* ,
+ *leftctrl-leftalt-shift* ,
+ *rightctrl-rightalt-shift* ,
+ *shift* ,
+ *shift-alt* ,
+ *shift-ctrl* ,
+ *shift-ctrl-alt* ,
+ *leftalt-shift* ,
+ *rightalt-shift* ,
+ *leftctrl-shift* , and
+ *rightctrl-shift*
+each apply the appropriate modifier keys when processing rules unless overridden by a *layer* value in the key specification. The layer names *default* , *numeric* , *symbol* and *currency* are also recognized, but no modifier key is applied for keys in these layers.
+
+The following special key identifiers have been added to simplify layer selection:
+
+| Identifier | Value |
+|:-------------|:------|
+| K_NUMERALS | 261 |
+| K_SYMBOLS | 262 |
+| K_CURRENCIES | 263 |
+| K_SHIFTED | 264 |
+| K_ALTGR | 265 |
+
+A special font is used to provide easily recognizable key graphics for various special purpose keys. The following key text strings will be recognized and cause the appropriate graphic to be used for the key cap instead of the actual text:
+
+| Text string | Key purpose |
+|:------------------|:--------------------------------------------------------|
+| \*Shift\* | Shift key image (inactive) |
+| \*Enter\* | Return |
+| \*Tab\* | Move to next input element in tab order |
+| \*BkSp\* | Backspace |
+| \*Menu\* | Display the language menu |
+| \*Hide\* | Hide the virtual keyboard |
+| \*Alt\* | Alt key caption |
+| \*Ctrl\* | Control key caption |
+| \*Caps\* | Caps Lock caption |
+| \*ABC\* | Select the upper case alphabetic layer |
+| \*abc\* | Return to the default (alphabetic) keyboard layer |
+| \*123\* | Select a numeric keyboard layer |
+| \*Symbol\* | Select a layer with various non-letter symbols |
+| \*Currency\* | Select a layer with currency symbols |
+| \*Shifted\* | Active Shift key image |
+| \*AltGr\* | Select Control + Alt (AltGr) modifier state |
+| \*TabLeft\* | Go back to previous input element in tab order |
+| \*LAlt\* | Select left Alt modifier state |
+| \*RAlt\* | Select right Alt modifier state |
+| \*LCtrl\* | Select left Control modifier state |
+| \*RCtrl\* | Select right Control modifier state |
+| \*LAltCtrl\* | Select left Alt + left Control modifier state |
+| \*RAltCtrl\* | Select right Alt + right Control modifier state |
+| \*LAltCtrlShift\* | Select left Alt + left Control + Shift modifier state |
+| \*RAltCtrlShift\* | Select right Alt + right Control + Shift modifier state |
+| \*AltShift\* | Select Alt + Shift modifier state |
+| \*CtrlShift\* | Select Control + Shift modifier state |
+| \*AltCtrlShift\* | Select Alt + Control + Shift modifier state |
+| \*LAltShift\* | Select left Alt + Shift modifier state |
+| \*RAltShift\* | Select right Alt + Shift modifier state |
+| \*LCtrlShift\* | Select left Control + Shift modifier state |
+| \*RCtrlShift\* | Select right Control + Shift modifier state |
diff --git a/web/docs/engine/reference/osk/addEventListener.md b/web/docs/engine/reference/osk/addEventListener.md
new file mode 100644
index 0000000000..8f36d96e5e
--- /dev/null
+++ b/web/docs/engine/reference/osk/addEventListener.md
@@ -0,0 +1,31 @@
+---
+title: addEventListener
+---
+
+## Summary
+
+Adds an event listener for user-handling of On-Screen keyboard events.
+
+## Syntax
+
+```c
+keyman.osk.addEventListener(eventName, func)
+```
+
+### Parameters
+
+`eventName`
+: Type: `string`
+: The name of an event generated by the `keyman.osk` object. See [the Events section](../events) for details and examples.
+
+`func`
+: Type: `function(Object)`
+: A function to be called when the event is raised.
+
+### Return Value
+
+`boolean`
+
+## Description
+
+Standard HTML element events for the On-Screen Keyboard element may also be intercepted and used to modify the user interface if necessary.
diff --git a/web/docs/engine/reference/osk/classes.md b/web/docs/engine/reference/osk/classes.md
new file mode 100644
index 0000000000..ea82b0bcf3
--- /dev/null
+++ b/web/docs/engine/reference/osk/classes.md
@@ -0,0 +1,154 @@
+---
+title: Class Names and Identifiers for On-Screen Keyboard and Other KeymanWeb Elements
+---
+
+The appearance of the _KeymanWeb_ on-screen keyboard, menu amd other elements can be customized
+by a web designer by redefining (or adding to) the default styles. Styles and named elements
+all have the class name (or id) prefix `kmw-` joined to the object and item names,
+for example `kmw-key-text`, to set the basic style for the keycap text on each on-screen keyboard key.
+Multiple classes are applied to many objects, with top-level classes of `tablet`,
+`phone` and `desktop` used to set different element styles according to the device type.
+Unique elements, such as the menu and pop-up key frame, are named rather than referred to by class.
+
+Most visual attributes such as text size and colour, background colour, shading, margins, etc. can be varied
+according to preference but developers should avoid changing positional attributes.
+
+### Class names applied to on-screen keyboard elements:
+
+| Class name | Keyboard element |
+| ----------------------- | ----------------------------------- |
+| `kmw-osk-frame` | Outer keyboard frame |
+| `kmw-osk-inner-frame` | Inner keyboard frame |
+| `kmw-key-layer-group` | Keyboard layers container element |
+| `kmw-key-layer` | Keyboard layer element |
+| `kmw-key-row` | Keyboard row container element |
+| `kmw-key-square` | Keyboard key container element |
+| `kmw-key-square-ex` | Pop-up key container element |
+| `kmw-key` | Key element |
+| `kmw-key-label` | Key label (desktop OSK and phonetic layouts) |
+| `kmw-key-text` | Keycap text |
+| `kmw-key-popup-icon` | Text or graphic to indicate that a keyboard key has associated popup keys |
+| `kmw-spacebar-caption` | Style applied to caption on spacebar |
+
+### Class names applied to different types of keys:
+
+| Class name | Key style |
+| ----------------------- | ------------------------------- |
+| `kmw-key-default` | Default |
+| `kmw-key-shift` | Shift key, layer-switching keys |
+| `kmw-key-shift-on` | Active shift key |
+| `kmw-key-deadkey` | [Dead key](/developer/language/reference/deadkey) |
+| `kmw-key-blank` | Blank, unmapped key |
+| `kmw-key-hidden` | Hidden spacer key |
+| `kmw-key-touched` | Active (touched) key |
+
+### Element identifiers for keys:
+
+Useful reference: [Keys, Virtual Keys, and Virtual Character Keys](/developer/language/guide/virtual-keys#toc-key-codes)
+
+Each key element (`kmw-key`) has an ID based on the key code used for it within Keyman Developer. Each ID is based on
+two or three pieces:
+- The key's layer
+- The key's code
+- _If_ it differs from the key's actual layer, the "modifier" setting for the key as set within the Touch Layout editor.
+
+The format:
+- ``-``
+- ``-``+`` (if different from ``)
+
+Some example IDs:
+- `default-K_K` - the `K_K` key on the `default` layer
+- `currency-U_20B2` - the `U_20B2` key (₲) on the `currency` layer
+- `numeric-K_0+default` - the `K_0` key displayed on the `numeric` layer, using the same modifiers as the `default` layer.
+
+For keys reached by longpress, the form of the ID is the same, just with one extra piece: it is prepended with `popup-`.
+- `popup-default-U_1E0F` - the `U_1E0F` subkey (ḏ) on the `default` layer
+ - This is one of the subkeys of the 'd' key on the `default` layer on the EuroLatin (SIL) keyboard.
+
+You can set styles for specific keys by using CSS selectors against specific key IDs.
+
+The following selector will find the key element for all keys with the key code `K_RBRKT` of the keyboard's phone layout.
+
+```css
+.phone div.kmw-key.kmw-key-default[id*='K_RBRKT']
+```
+
+Note the `[id*='K_RBRKT']` part. There can be a few variations here:
+- `*=` - "contains"
+- `^=` - "starts with"
+- `$=` - "ends with"
+
+So, to match all keys reached by longpress, you could use:
+
+```css
+div.kmw-key.kmw-key-default[id^='popup-']
+```
+
+Also, `:not(...)` can be used to invert a selector. The following selector will match all base keys, but not
+any longpress keys.
+
+```css
+div.kmw-key.kmw-key-default:not([id^='popup-'])
+```
+
+### Element identifiers and class names for desktop on-screen keyboard elements:
+
+| Class name or id | Desktop OSK element |
+| ----------------------- | ------------------------------- |
+| `kmw-title-bar` | OSK title bar |
+| `kmw-title-bar-caption` | OSK title bar caption (keyboard name) |
+| `kmw-title-bar-actions` | Container for image elements in OSK title bar |
+| `kmw-title-bar-image` | Active image element (button) in OSK title bar |
+| `kmw-footer` | Desktop OSK footer element |
+| `kmw-footer-caption` | Caption in desktop OSK footer |
+| `kmw-footer-resize` | Style for the footer's resizing icon |
+| `kmw-osk-static` | Container style for non-sizable keyboards |
+| `kmw-osk-none` | Empty keyboard container style |
+| `#kmw-pin-image` | Style of icon to return OSK to default position |
+| `#kmw-config-image` | Style of icon to open configuration options window |
+| `#kmw-help-image` | Style of icon to open keymanweb help window |
+| `#kmw-close-button` | Style of close button image |
+
+### Element identifiers and class names applied to pop-up key container elements:
+
+| Class name | Element |
+| ----------------------- | ------------------------------- |
+| `#kmw-popup-keys` | Pop-up key container |
+| `arrow-border` | Style setting callout arrow border |
+| `arrow-content` | Style setting callout arrow background |
+
+### Element identifiers and class names applied to language menu elements:
+
+| Class name | Menu element |
+| --------------------------- | ------------------------------- |
+| `#kmw-language-menu` | Language menu container element |
+| `#kmw-language-menu-background` | Hidden background layer preventing unwanted action while selecting a language or keyboard |
+| `#kmw-menu-scroll-container` | Container for language list scroller |
+| `#kmw-menu-scroller` | Langauge list scroller |
+| `#kmw-menu-index` | Container for language index |
+| `#kmw-menu-footer` | Placeholder at bottom of scroller |
+| `kbd-list` | Style for language-list element |
+| `kmw-list-open` | Style for list element when expanded |
+| `kmw-list-closed` | Style for list element when not expanded |
+| `kmw-list-entry` | Language entry in language list |
+| `kmw-single-entry` | Single keyboard entry in language list |
+| `current` | Active keyboard entry in language list |
+| `selected` | Touched entry in language list |
+
+### Message box class names:
+
+| Class name | Element |
+| ----------------------- | ------------------------------- |
+| `kmw-wait-box` | Message box |
+| `kmw-wait-background` | Message box background |
+| `kmw-wait-text` | Message box wait text |
+| `kmw-wait-graphic` | Message box wait icon |
+| `kmw-alert-text` | Message box alert text |
+| `kmw-alert-close` | Message box close icon |
+
+The default styles for _KeymanWeb_ can be found online at
+https://github.com/keymanapp/keyman/blob/master/web/src/resources/osk/kmwosk.css.
+
+For the styles for specific released versions, they can also be found through
+s.keyman.com, such as https://s.keyman.com/kmw/engine/17.0.326/osk/kmwosk.css
+for version 17.0.326.
\ No newline at end of file
diff --git a/web/docs/engine/reference/osk/getRect.md b/web/docs/engine/reference/osk/getRect.md
new file mode 100644
index 0000000000..a4eab65927
--- /dev/null
+++ b/web/docs/engine/reference/osk/getRect.md
@@ -0,0 +1,42 @@
+---
+title: getRect
+---
+
+## Summary
+
+Get absolute position and size of OSK window.
+
+## Syntax
+
+```c
+keyman.osk.getRect()
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`Object`
+: The position and size of the OSK's container element.
+
+## Description
+
+The returned `getRect` object contains the following members:
+
+`left`
+: `number`
+: The x-coordinate corresponding to the left side of the OSK.
+
+`top`
+: `number`
+: The y-coordinate corresponding to the top of the OSK.
+
+`width`
+: `number`
+: The width (in pixels) of the OSK.
+
+`height`
+: `number`
+: The height (in pixels) of the OSK.
diff --git a/web/docs/engine/reference/osk/hide.md b/web/docs/engine/reference/osk/hide.md
new file mode 100644
index 0000000000..8d5d4e91a5
--- /dev/null
+++ b/web/docs/engine/reference/osk/hide.md
@@ -0,0 +1,25 @@
+---
+title: hide
+---
+
+## Summary
+
+Hides the OSK.
+
+## Syntax
+
+```c
+keyman.osk.hide()
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+Hides the On-Screen Keyboard.
diff --git a/web/docs/engine/reference/osk/index.md b/web/docs/engine/reference/osk/index.md
new file mode 100644
index 0000000000..6f2018178b
--- /dev/null
+++ b/web/docs/engine/reference/osk/index.md
@@ -0,0 +1,41 @@
+---
+title: On-Screen Keyboard Module
+---
+
+The On-Screen Keyboard module is exposed to the developer as `window.keyman.osk`.
+
+[`addEventListener` Function](addEventListener)
+: Adds an event listener for user-handling of On-Screen keyboard events.
+
+[`getRect` Function](getRect)
+: Get absolute position and size of OSK window.
+
+[`hide` Function](hide)
+: Hide the OSK.
+
+[`isEnabled` Function](isEnabled)
+: Return the user-defined OSK visibility as set by prior calls to show or hide.
+
+[`isVisible` Function](isVisible)
+: Return the actual visibility of the On-Screen Keyboard.
+
+[`removeEventListener` Function](removeEventListener)
+: Removes a user-defined event handler.
+
+[`restorePosition` Function](restorePosition)
+: Move OSK back to default position, floating under active input element.
+
+[`setPos` Function](setPos)
+: Set absolute position and size of desktop OSK window, limited to screen.
+
+[`setRect` Function](setRect)
+: Set absolute position and size of desktop OSK window.
+
+[`show` Function](show)
+: Display, hide or toggle OSK visibility.
+
+[`userLocated` Function](userLocated)
+: Determine whether or not the OSK has been moved from its default position by the user.
+
+[Class Names and Identifiers for On-Screen Keyboard and Other KeymanWeb Elements](classes)
+: The appearance of the KeymanWeb on-screen keyboard, menu amd other elements can be customized by a web designer by redefining (or adding to) the default styles.
diff --git a/web/docs/engine/reference/osk/isEnabled.md b/web/docs/engine/reference/osk/isEnabled.md
new file mode 100644
index 0000000000..18811bc157
--- /dev/null
+++ b/web/docs/engine/reference/osk/isEnabled.md
@@ -0,0 +1,26 @@
+---
+title: isEnabled
+---
+
+## Summary
+
+Return the user-defined OSK visibility as set by prior calls to [`show`](show) or [`hide`](hide).
+
+## Syntax
+
+```c
+keyman.osk.isEnabled();
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`boolean`
+: `true` if the OSK is enabled, else `false`.
+
+## Description
+
+Actual OSK visibility will also depend on whether or not the target is focused (see isVisible)
diff --git a/web/docs/engine/reference/osk/isVisible.md b/web/docs/engine/reference/osk/isVisible.md
new file mode 100644
index 0000000000..436436568a
--- /dev/null
+++ b/web/docs/engine/reference/osk/isVisible.md
@@ -0,0 +1,22 @@
+---
+title: isVisible
+---
+
+## Summary
+
+Return the actual visibility of the On-Screen Keyboard.
+
+## Syntax
+
+```c
+keyman.osk.isVisible();
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`boolean`
+: `true` if the OSK is actually visible, else `false`. Note that this will usually return `false` after any UI event that results in (temporary) loss of focus.
diff --git a/web/docs/engine/reference/osk/removeEventListener.md b/web/docs/engine/reference/osk/removeEventListener.md
new file mode 100644
index 0000000000..19823c525f
--- /dev/null
+++ b/web/docs/engine/reference/osk/removeEventListener.md
@@ -0,0 +1,33 @@
+---
+title: removeEventListener
+---
+
+## Summary
+
+Removes a user-defined event handler.
+
+## Syntax
+
+```c
+keyman.osk.removeEventListener(eventName, func);
+```
+
+### Parameters
+
+`eventName`
+: Type: `string`
+: The name of an event generated by the `keyman.osk` object.
+
+`func`
+: Type: `Function`
+: A function currently set to handle that event when it is raised.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+To be implemented.
+
+Will be the OSK's analogue of the to-be-implemented core function [`removeEventListener`](../core/removeEventListener).
diff --git a/web/docs/engine/reference/osk/restorePosition.md b/web/docs/engine/reference/osk/restorePosition.md
new file mode 100644
index 0000000000..ea84208a36
--- /dev/null
+++ b/web/docs/engine/reference/osk/restorePosition.md
@@ -0,0 +1,40 @@
+---
+title: restorePosition
+---
+
+## Summary
+
+Move OSK back to default position, floating under active input element, for
+desktop OSK.
+
+## Syntax
+
+```js
+keyman.osk.restorePosition(keepDefaultPosition);
+```
+
+## Parameters
+
+`keepDefaultPosition`
+: `boolean` optional
+: If `true` does not reset the default `left`, `top` set by [`setRect()`](setRect).
+: If `false` or omitted, resets the default `left`, `top` as well.
+
+## Return Value
+
+`undefined`
+
+## Description
+
+This is the equivalent of pressing the pin in the title bar of the desktop OSK.
+The user may move the OSK, after which point the OSK stays where the user has
+placed it. Similarly, calling [`setPos()`](setPos) will fix the position of the
+OSK. Calling `restorePosition()` resets the position of the OSK and re-attaches
+it to the bottom of the active input element.
+
+Note that if the user clicks the pin it does not reset the default `left`, `top`
+as set by `setRect()`.
+
+## History
+
+* Published as public API in 14.0.272
\ No newline at end of file
diff --git a/web/docs/engine/reference/osk/setPos.md b/web/docs/engine/reference/osk/setPos.md
new file mode 100644
index 0000000000..7e6c53f93a
--- /dev/null
+++ b/web/docs/engine/reference/osk/setPos.md
@@ -0,0 +1,23 @@
+---
+title: setPos
+---
+
+## Summary
+
+Set absolute position and size of desktop OSK window, limited to screen.
+
+## Syntax
+
+```c
+keyman.osk.setPos(pt)
+```
+
+### Parameters
+
+`pt`
+: Type: `Object`
+: An object with the two properties `left` and `top`, used to set the position of the OSK.
+
+### Return Value
+
+`undefined`
diff --git a/web/docs/engine/reference/osk/setRect.md b/web/docs/engine/reference/osk/setRect.md
new file mode 100644
index 0000000000..e90ed0d836
--- /dev/null
+++ b/web/docs/engine/reference/osk/setRect.md
@@ -0,0 +1,55 @@
+---
+title: setRect
+---
+
+## Summary
+
+Set absolute position and size of desktop OSK window.
+
+## Syntax
+
+```c
+keyman.osk.setRect(p);
+```
+
+### Parameters
+
+`p`
+: Type: `Object`
+: An object specifying location and/or user permissions for altering the OSK's display.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+The `setRect` object contains the following members:
+
+`left`
+: `number` *optional*
+: Sets the x-coordinate of the OSK's left side.
+
+`top`
+: `number` *optional*
+: Sets the y-coordinate of the OSK's top side.
+
+`width`
+: `number` *optional*
+: Sets the width of the OSK.
+
+`height`
+: `number` *optional*
+: Sets the height of the OSK.
+
+`nosize`
+: `boolean` *optional*
+: If set to `true`, prevents the user from altering the OSK's size. If set to `false`, allows the user to resize the OSK. If omitted, does not change the existing state.
+
+`nomove`
+: `boolean` *optional*
+: If set to `true`, prevents the user from relocating the OSK manually. If set to `false`, allows the user to move the OSK. If omitted, does not change the existing state.
+
+The values and states of omitted object members will not be changed.
+
+This differs from [`setPos()`](setPos) in that it allows resizing the keyboard and controlling the user's ability to move/size the keyboard. Furthermore, when `left` and `top` members are included, they override the default position of the keyboard rather than setting the position temporarily.
diff --git a/web/docs/engine/reference/osk/show.md b/web/docs/engine/reference/osk/show.md
new file mode 100644
index 0000000000..a2e73b6c77
--- /dev/null
+++ b/web/docs/engine/reference/osk/show.md
@@ -0,0 +1,27 @@
+---
+title: show
+---
+
+## Summary
+
+Display, hide or toggle OSK visibility.
+
+## Syntax
+
+```c
+keyman.osk.show(mode);
+```
+
+### Parameters
+
+`mode`
+: Type: `boolean` *optional*
+: `true` to display, `false` to hide, omitted to toggle.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+Visibility will be toggled on or off if the argument is omitted.
diff --git a/web/docs/engine/reference/osk/userLocated.md b/web/docs/engine/reference/osk/userLocated.md
new file mode 100644
index 0000000000..ed85dde233
--- /dev/null
+++ b/web/docs/engine/reference/osk/userLocated.md
@@ -0,0 +1,22 @@
+---
+title: userLocated
+---
+
+## Summary
+
+Determine whether or not the OSK has been moved from its default position by the user.
+
+## Syntax
+
+```c
+keyman.osk.userLocated();
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`boolean`
+: `true` if location is specified by the user, else `false`.
diff --git a/web/docs/engine/reference/overview.md b/web/docs/engine/reference/overview.md
new file mode 100644
index 0000000000..574e704abf
--- /dev/null
+++ b/web/docs/engine/reference/overview.md
@@ -0,0 +1,25 @@
+---
+title: Overview
+---
+
+*KeymanWeb* is a cross-browser JavaScript input method solution.
+
+The *KeymanWeb 17 API* provides JavaScript functions to allow a website developer to integrate the use of
+*KeymanWeb* multi-lingual keyboard mapping into a website, using either a standard or a custom-designed user-interface. The functions are exposed as API calls to the *KeymanWeb* core, the
+*On-Screen Keyboard* module, a *Utility function* library, or one of the standard *User Interface* modules.
+
+A *KeymanWeb* instance is automatically constructed when you include the compiled KeymanWeb script (kmw-release.js) in your web page source.
+
+The *KeymanWeb API* comprises the following objects:
+
+- *Core*
+: Exposed as [`keyman`](core).
+
+- *On-Screen Keyboard*
+: Exposed as [`keyman.osk`](osk).
+
+- *Utility Functions*
+: Exposed as [`keyman.util`](util).
+
+- *User Interface*
+: Exposed as [`keyman.ui`](ui).
diff --git a/web/docs/engine/reference/ui/button.md b/web/docs/engine/reference/ui/button.md
new file mode 100644
index 0000000000..6c90d518e7
--- /dev/null
+++ b/web/docs/engine/reference/ui/button.md
@@ -0,0 +1,15 @@
+---
+title: "Button" Interface
+---
+
+The simplest user interface is the "button" UI, which appears at a fixed
+position on the web page, and is attached to an empty 'Div' element with
+id='KeymanWebControl' added to the page where appropriate.
+
+When the mouse is hovered over the 'button' UI, a menu of supported
+input languages and keyboards is shown:
+
+
+
+In this example, a Japanese keyboard with an Input Method Editor (IME)
+has been selected.
diff --git a/web/docs/engine/reference/ui/float.md b/web/docs/engine/reference/ui/float.md
new file mode 100644
index 0000000000..bf97c556d5
--- /dev/null
+++ b/web/docs/engine/reference/ui/float.md
@@ -0,0 +1,13 @@
+---
+title: "Float" Interface
+---
+
+The "float" user interface (the original
+*KeymanWeb* user interface) appears as a
+drop-down list of available keyboards below the currently focused
+element:
+
+
+
+An initialization option allows the interface element to be aligned at
+the right of the focused element if preferred.
diff --git a/web/docs/engine/reference/ui/images/ui_button.png b/web/docs/engine/reference/ui/images/ui_button.png
new file mode 100644
index 0000000000..c4225ee83a
Binary files /dev/null and b/web/docs/engine/reference/ui/images/ui_button.png differ
diff --git a/web/docs/engine/reference/ui/images/ui_float.png b/web/docs/engine/reference/ui/images/ui_float.png
new file mode 100644
index 0000000000..5ed6a977cc
Binary files /dev/null and b/web/docs/engine/reference/ui/images/ui_float.png differ
diff --git a/web/docs/engine/reference/ui/images/ui_toggle.png b/web/docs/engine/reference/ui/images/ui_toggle.png
new file mode 100644
index 0000000000..88c55f7b54
Binary files /dev/null and b/web/docs/engine/reference/ui/images/ui_toggle.png differ
diff --git a/web/docs/engine/reference/ui/images/ui_toolbar.png b/web/docs/engine/reference/ui/images/ui_toolbar.png
new file mode 100644
index 0000000000..428ec2b2e6
Binary files /dev/null and b/web/docs/engine/reference/ui/images/ui_toolbar.png differ
diff --git a/web/docs/engine/reference/ui/index.md b/web/docs/engine/reference/ui/index.md
new file mode 100644
index 0000000000..74788baf51
--- /dev/null
+++ b/web/docs/engine/reference/ui/index.md
@@ -0,0 +1,43 @@
+---
+title: Desktop User Interfaces
+---
+
+Four different KeymanWeb user interfaces for desktop browsers are
+included, allowing users to select and enable keyboard mapping from a
+list of installed keyboards, and to control the visibility of the
+On-Screen Keyboard.
+
+["Button" Interface](button)
+: The simplest user interface is the "button" UI, which appears at a
+ fixed position on the web page, and is attached to an empty 'Div'
+ element with id='KeymanWebControl' added to the page where
+ appropriate.
+
+
+
+["Toggle" Interface](toggle)
+: The "toggle" user interface provides a drop-down list of supported
+ input languages and keyboards, and moves with the focus to appear at
+ the right hand side of the focused element.
+
+
+
+["Float" Interface](float)
+: The "float" user interface (the original KeymanWeb user interface)
+ appears as a drop-down list of available keyboards below the
+ currently focused element
+
+
+
+["Toolbar" Interface](toolbar)
+: For pages which must support a large number of languages from many
+ regions, we recommend using our "toolbar" user interface, which
+ displays a drop-down map allowing users to first choose the region
+ from the map or by name, then select input language by country.
+
+Alternatively, developers may implement a custom interface for desktop
+browsers with appropriate corporate branding, using the various API
+functions to manage keyboard selection and display.
+
+For touch-screen devices, the user-interface is integrated into the
+On-Screen Keyboard, and cannot be overridden by the developer.
diff --git a/web/docs/engine/reference/ui/toggle.md b/web/docs/engine/reference/ui/toggle.md
new file mode 100644
index 0000000000..dc5ed97d4d
--- /dev/null
+++ b/web/docs/engine/reference/ui/toggle.md
@@ -0,0 +1,20 @@
+---
+title: "Toggle" Interface
+---
+
+The "toggle" user interface provides a drop-down list of supported input
+languages and keyboards, and moves with the focus to appear at the right
+hand side of the focused element:
+
+
+
+The "toggle" interface also supports the use of "hot keys" to simplify
+keyboard use:
+
+| Hot key | Action |
+|:---------------------------------------------|:----------------------------------------|
+| *Ctrl /* | enable/disable currently selected keyboard |
+| *Ctrl Shift /* | select next listed keyboard |
+| *Alt /* | enable/disable OSK display |
+
+
diff --git a/web/docs/engine/reference/ui/toolbar.md b/web/docs/engine/reference/ui/toolbar.md
new file mode 100644
index 0000000000..23dc943ee3
--- /dev/null
+++ b/web/docs/engine/reference/ui/toolbar.md
@@ -0,0 +1,19 @@
+---
+title: "Toolbar" Interface
+---
+
+For pages which must support a large number of languages from many
+regions, we recommend using our "toolbar" user interface, which displays
+a drop-down map allowing users to first choose the region from the map
+or by name, then select input language by country. A second drop-down
+list is displayed (as shown here) if more than one keyboard is available
+for the selected language.
+
+The "toolbar" user interface is attached to any DIV element on the page
+(by giving that element the
+*id='KeymanWebControl'*), and remains
+fixed in position with respect to that element, but the On-Screen
+Keyboard moves to each focused input element, unless fixed in position
+by the user.
+
+
diff --git a/web/docs/engine/reference/util/addStyleSheet.md b/web/docs/engine/reference/util/addStyleSheet.md
new file mode 100644
index 0000000000..004bcacdc3
--- /dev/null
+++ b/web/docs/engine/reference/util/addStyleSheet.md
@@ -0,0 +1,32 @@
+---
+title: addStyleSheet
+---
+
+## Summary
+
+Generates a style sheet element for use in adding or overriding default On-Screen Keyboard styles.
+
+## Syntax
+
+```c
+keyman.util.addStyleSheet(sheet)
+```
+
+### Parameters
+
+`sheet`
+: Type: `string`
+: A string representing a CSS style sheet.
+
+### Return Value
+
+`Object`
+: A page element representing the newly-embedded style sheet.
+
+## Description
+
+See our list of [standard OSK style names](../osk/classes) as a reference if implementing your own stylesheets.
+
+See also:
+- [`keyman.util.linkStyleSheet()`](linkStyleSheet)
+- [`keyman.util.removeStyleSheet()`](removeStyleSheet)
diff --git a/web/docs/engine/reference/util/alert.md b/web/docs/engine/reference/util/alert.md
new file mode 100644
index 0000000000..65cb3922e1
--- /dev/null
+++ b/web/docs/engine/reference/util/alert.md
@@ -0,0 +1,32 @@
+---
+title: alert
+---
+
+## Summary
+
+Generates a KeymanWeb alert window.
+
+## Syntax
+
+```c
+keyman.util.alert(msg, fn)
+```
+
+### Parameters
+
+`msg`
+: Type: `string`
+: Alert message text.
+
+`fn`
+: Type: `function()` *optional*
+: Function to be called upon alert dismissal.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+The optional second parameter specifies a function to be called when the
+window is dismissed.
\ No newline at end of file
diff --git a/web/docs/engine/reference/util/attachDOMEvent.md b/web/docs/engine/reference/util/attachDOMEvent.md
new file mode 100644
index 0000000000..41540e70bd
--- /dev/null
+++ b/web/docs/engine/reference/util/attachDOMEvent.md
@@ -0,0 +1,43 @@
+---
+title: attachDOMEvent
+---
+
+## Summary
+
+Attach user-defined event handler for any DOM event for an element.
+
+## Syntax
+
+```c
+keyman.util.attachDOMEvent(Pelem, eventName, handler, useCapture);
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: Element to which the event is being attached.
+
+`eventName`
+: Type: `string`
+: The name of the event, without an 'on' prefix.
+
+`handler`
+: Type: `function(Object)`
+: The event handler being attached.
+
+`useCapture`
+: Type: `boolean` *optional*
+: Set this to `true` if the event should be captured in the bubbling phase; otherwise, use `false` or leave this parameter empty.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+The event name should be specified without the 'on' prefix. The fourth argument, useCapture, is optional and will default to false.
+
+The method exists for legacy reasons that arise when dealing with old versions of IE, simplifying event-handling code.
+
+See also: [`keyman.util.detachDOMEvent`](detachDOMEvent)
diff --git a/web/docs/engine/reference/util/createElement.md b/web/docs/engine/reference/util/createElement.md
new file mode 100644
index 0000000000..198ba7117b
--- /dev/null
+++ b/web/docs/engine/reference/util/createElement.md
@@ -0,0 +1,28 @@
+---
+title: createElement
+---
+
+## Summary
+
+Create an unselectable HTML element for the *KeymanWeb* On-Screen keyboard and User Interfaces.
+
+## Syntax
+
+```c
+keyman.util.createElement(nodeName);
+```
+
+### Parameters
+
+`nodeName`
+: Type: `string`
+: Name for the newly-created element.
+
+### Return Value
+
+`Element`
+: The new, requested user-unselectable HTML element.
+
+## Description
+
+Elements created with this function do not capture the focus. Use `document.createElement` to create normally selectable elements.
diff --git a/web/docs/engine/reference/util/detachDOMEvent.md b/web/docs/engine/reference/util/detachDOMEvent.md
new file mode 100644
index 0000000000..8227ed8ebe
--- /dev/null
+++ b/web/docs/engine/reference/util/detachDOMEvent.md
@@ -0,0 +1,41 @@
+---
+title: detachDOMEvent
+---
+
+## Summary
+
+Detach DOM event handler from element to prevent memory leaks.
+
+## Syntax
+
+```c
+keyman.util.detachDOMEvent();
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: Element from which the event is being detached.
+
+`eventName`
+: Type: `string`
+: The name of the event, without an 'on' prefix.
+
+`handler`
+: Type: `function(Object)`
+: The event handler being detached.
+
+`useCapture`
+: Type: `boolean` *optional*
+: Set this to `true` if the event was being captured in the bubbling phase; otherwise, use `false` or leave this parameter empty.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+The fourth argument, useCapture, is optional and will default to false.
+
+See also: [`keyman.util.attachDOMEvent`](attachDOMEvent)
diff --git a/web/docs/engine/reference/util/getAbsolute.md b/web/docs/engine/reference/util/getAbsolute.md
new file mode 100644
index 0000000000..d1a5f12680
--- /dev/null
+++ b/web/docs/engine/reference/util/getAbsolute.md
@@ -0,0 +1,30 @@
+---
+title: getAbsolute
+---
+
+## Summary
+
+Get the absolute position of an element.
+
+## Syntax
+
+```c
+keyman.util.getAbsolute(Pelem);
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: An HTML element.
+
+### Return Value
+
+`Object`
+: An object with two `number` properties (`x` and `y`) corresponding to the specified element's absolute position on the page.
+
+## Description
+
+See also:
+- [`keyman.util.getAbsoluteX()`](getAbsoluteX)
+- [`keyman.util.getAbsoluteY()`](getAbsoluteY)
diff --git a/web/docs/engine/reference/util/getAbsoluteX.md b/web/docs/engine/reference/util/getAbsoluteX.md
new file mode 100644
index 0000000000..3b9e57a3ca
--- /dev/null
+++ b/web/docs/engine/reference/util/getAbsoluteX.md
@@ -0,0 +1,30 @@
+---
+title: getAbsoluteX
+---
+
+## Summary
+
+Get the absolute x-coordinate of an element.
+
+## Syntax
+
+```c
+keyman.util.getAbsoluteX(Pelem);
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: An HTML element.
+
+### Return Value
+
+`number`
+: The specified element's absolute x-coordinate on the page.
+
+## Description
+
+See also:
+- [`keyman.util.getAbsolute()`](getAbsolute)
+- [`keyman.util.getAbsoluteY()`](getAbsoluteY)
diff --git a/web/docs/engine/reference/util/getAbsoluteY.md b/web/docs/engine/reference/util/getAbsoluteY.md
new file mode 100644
index 0000000000..c41d75c2fd
--- /dev/null
+++ b/web/docs/engine/reference/util/getAbsoluteY.md
@@ -0,0 +1,30 @@
+---
+title: getAbsoluteY
+---
+
+## Summary
+
+Get the absolute y-coordinate of an element.
+
+## Syntax
+
+```c
+keyman.util.getAbsoluteY(Pelem);
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: An HTML element.
+
+### Return Value
+
+`number`
+: The specified element's absolute y-coordinate on the page.
+
+## Description
+
+See also:
+- [`keyman.util.getAbsolute()`](getAbsolute)
+- [`keyman.util.getAbsoluteX()`](getAbsoluteX)
diff --git a/web/docs/engine/reference/util/getOption.md b/web/docs/engine/reference/util/getOption.md
new file mode 100644
index 0000000000..5e182abeb0
--- /dev/null
+++ b/web/docs/engine/reference/util/getOption.md
@@ -0,0 +1,32 @@
+---
+title: getOption
+---
+
+## Summary
+
+Get a KeymanWeb, On-Screen Keyboard or User Interface option value.
+
+## Syntax
+
+```c
+keyman.util.getOption(optionName, dflt);
+```
+
+### Parameters
+
+`optionName`
+: Type: `string`
+: The named initialization option.
+
+`dflt`
+: Type: `string|Object` *optional*
+: The value to return if the option is not set.
+
+### Return Value
+
+`string|Object`
+: The value of the option (if set). If not set and no value is provided for `dflt`, returns the empty string.
+
+## Description
+
+See also [`keyman.util.setOption()`](setOption).
diff --git a/web/docs/engine/reference/util/index.md b/web/docs/engine/reference/util/index.md
new file mode 100644
index 0000000000..f599e3d5d6
--- /dev/null
+++ b/web/docs/engine/reference/util/index.md
@@ -0,0 +1,65 @@
+---
+title: Utility Module
+---
+
+The KeymanWeb Utility Function module is exposed to the developer as `window.keyman.util`.
+
+[`addStyleSheet` Function](addStyleSheet)
+: Add or override default On-Screen Keyboard styles.
+
+[`alert` Function](alert)
+: Customized alert window.
+
+[`attachDOMEvent` Function](attachDOMEvent)
+: Attach user-defined event handler for any DOM event for an element.
+
+[`createElement` Function](createElement)
+: Create an unselectable HTML element for the KeymanWeb On-Screen
+ keyboard and User Interfaces.
+
+[`detachDOMEvent` Function](detachDOMEvent)
+: Detach DOM event handler from element to prevent memory leaks.
+
+[`getAbsolute` Function](getAbsolute)
+: Get the absolute position of an element.
+
+[`getAbsoluteX` Function](getAbsoluteX)
+: Get the absolute y-coordinate of an element.
+
+[`getAbsoluteY` Function](getAbsoluteY)
+: Get the absolute y-coordinate of an element.
+
+[`getOption` Function](getOption)
+: Get a KeymanWeb, On-Screen Keyboard or User Interface option value.
+
+[`isTouchDevice` Function](isTouchDevice)
+: Allow external callers (such as UIs) to detect if the active device
+ is touch sensitive.
+
+[`linkStyleSheet` Function](linkStyleSheet)
+: Add a reference to an external stylesheet file.
+
+[`loadCookie` Function](loadCookie)
+: Get a document cookie, or an array of all document cookies.
+
+[`removeStyleSheet` Function](removeStyleSheet)
+: Remove user-defined style sheet.
+
+[`rgba` Function](rgba)
+: Browser-independent alpha-channel management.
+
+[`saveCookie` Function](saveCookie)
+: Save document variables as a cookie.
+
+[`setOption` Function](setOption)
+: Set a KeymanWeb, On-Screen Keyboard or User Interface option value.
+
+[`toFloat` Function](toFloat)
+: Floating conversion with default.
+
+[`toNumber` Function](toNumber)
+: Integer conversion with default.
+
+[`toNzString` Function](toNzString)
+: Returns default string value if argument is null, false, an empty
+ string, or undefined.
diff --git a/web/docs/engine/reference/util/isTouchDevice.md b/web/docs/engine/reference/util/isTouchDevice.md
new file mode 100644
index 0000000000..2531aca196
--- /dev/null
+++ b/web/docs/engine/reference/util/isTouchDevice.md
@@ -0,0 +1,29 @@
+---
+title: isTouchDevice
+---
+
+## Summary
+
+Allow external callers (such as UIs) to detect if the active device is considered touch sensitive by KeymanWeb.
+
+## Syntax
+
+```c
+keyman.util.isTouchDevice();
+```
+
+### Parameters
+
+None.
+
+### Return Value
+
+`boolean`
+: `true` if KMW is targetting touch-sensitivity for the device, otherwise `false`.
+
+```
+isTouchDevice ...
+```
+
+> [!Note]
+> In current versions of KeymanWeb this function will return `false` for touchscreen laptops; current touch support is specialized for mobile phones and tablets.
diff --git a/web/docs/engine/reference/util/linkStyleSheet.md b/web/docs/engine/reference/util/linkStyleSheet.md
new file mode 100644
index 0000000000..c163a411e7
--- /dev/null
+++ b/web/docs/engine/reference/util/linkStyleSheet.md
@@ -0,0 +1,29 @@
+---
+title: linkStyleSheet
+---
+
+## Summary
+
+Add a reference to an external stylesheet file.
+
+## Syntax
+
+```c
+keyman.util.linkStyleSheet(s);
+```
+
+### Parameters
+
+`s`
+: Type: `string`
+: Path to a pre-existing stylesheet file.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+See also:
+- [`keyman.util.addStyleSheet()`](addStyleSheet)
+- [`keyman.util.removeStyleSheet()`](removeStyleSheet).
diff --git a/web/docs/engine/reference/util/loadCookie.md b/web/docs/engine/reference/util/loadCookie.md
new file mode 100644
index 0000000000..e9215a8854
--- /dev/null
+++ b/web/docs/engine/reference/util/loadCookie.md
@@ -0,0 +1,28 @@
+---
+title: loadCookie
+---
+
+## Summary
+
+Get a document cookie, or an array of all document cookies.
+
+## Syntax
+
+```c
+keyman.util.loadCookie(cn);
+```
+
+### Parameters
+
+`cn`
+: Type: `string` **optional**
+: Name of the cookie to be loaded if not loading the default cookie.
+
+### Return Value
+
+`Object`
+: An array of names and strings or an array of variables and values.
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/util/removeStyleSheet.md b/web/docs/engine/reference/util/removeStyleSheet.md
new file mode 100644
index 0000000000..2e0c097726
--- /dev/null
+++ b/web/docs/engine/reference/util/removeStyleSheet.md
@@ -0,0 +1,32 @@
+---
+title: removeStyleSheet
+---
+
+## Summary
+
+Remove user-defined style sheet.
+
+## Syntax
+
+```c
+keyman.util.removeStyleSheet(Pelem);
+```
+
+### Parameters
+
+`Pelem`
+: Type: `Element`
+: Element representing the style sheet to be removed.
+
+### Return Value
+
+`boolean`
+: `true` if the style sheet element was successfully removed, otherwise `false`.
+
+## Description
+
+If the element does not represent a style sheet, this function will not remove the element and will simply return `false`.
+
+See also:
+- [`keyman.util.addStyleSheet()`](addStyleSheet)
+- [`keyman.util.linkStyleSheet()`](linkStyleSheet)
diff --git a/web/docs/engine/reference/util/rgba.md b/web/docs/engine/reference/util/rgba.md
new file mode 100644
index 0000000000..6107034b48
--- /dev/null
+++ b/web/docs/engine/reference/util/rgba.md
@@ -0,0 +1,44 @@
+---
+title: rgba
+---
+
+## Summary
+
+Browser-independent alpha-channel management.
+
+## Syntax
+
+```c
+keyman.util.rgba(s, r, g, b, a);
+```
+
+### Parameters
+
+`s`
+: Type: `Element`
+: Element style object
+
+`r`
+: Type: `number`
+: Value for red (0-255)
+
+`g`
+: Type: `number`
+: Value for green (0-255)
+
+`b`
+: Type: `number`
+: Value for blue (0-255)
+
+`a`
+: Type: `number`
+: Value for alpha/opacity (0-1.0)
+
+### Return Value
+
+`string`
+: Background color CSS value.
+
+## Description
+
+This function returns the required string value for setting background transparency, and applies an appropriate `a` filter to the element for IE versions before IE9.
diff --git a/web/docs/engine/reference/util/saveCookie.md b/web/docs/engine/reference/util/saveCookie.md
new file mode 100644
index 0000000000..66c97a29ef
--- /dev/null
+++ b/web/docs/engine/reference/util/saveCookie.md
@@ -0,0 +1,31 @@
+---
+title: saveCookie
+---
+
+## Summary
+
+Save document variables as a cookie.
+
+## Syntax
+
+```c
+keyman.util.saveCookie(cn, cv);
+```
+
+### Parameters
+
+`cn`
+: Type: `string`
+: Name of the cookie to save.
+
+`cv`
+: Type: `Object`
+: An array of named arguments and values.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/util/setOption.md b/web/docs/engine/reference/util/setOption.md
new file mode 100644
index 0000000000..0596bf0e11
--- /dev/null
+++ b/web/docs/engine/reference/util/setOption.md
@@ -0,0 +1,31 @@
+---
+title: setOption
+---
+
+## Summary
+
+Set a KeymanWeb, On-Screen Keyboard or User Interface option value.
+
+## Syntax
+
+```c
+keyman.util.setOption(optionName, value);
+```
+
+### Parameters
+
+`optionName`
+: Type: `string`
+: The named initialization option.
+
+`value`
+: Type: `string|Object` *optional*
+: The value the option will be set to. Clears the option's current value if left blank.
+
+### Return Value
+
+`undefined`
+
+## Description
+
+See also [`keyman.util.getOption()`](getOption).
diff --git a/web/docs/engine/reference/util/toFloat.md b/web/docs/engine/reference/util/toFloat.md
new file mode 100644
index 0000000000..549af81e07
--- /dev/null
+++ b/web/docs/engine/reference/util/toFloat.md
@@ -0,0 +1,32 @@
+---
+title: toFloat
+---
+
+## Summary
+
+Floating conversion with default.
+
+## Syntax
+
+```c
+keyman.util.toFloat(s, dflt);
+```
+
+### Parameters
+
+`s`
+: Type: `string`
+: Numeric string.
+
+`dflt`
+: Type: `number`
+: Default value if parse is unsuccessful.
+
+### Return Value
+
+`number`
+: The string's conversion to a numeric value, or the default value if unsuccessful.
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/util/toNumber.md b/web/docs/engine/reference/util/toNumber.md
new file mode 100644
index 0000000000..a71950ec5a
--- /dev/null
+++ b/web/docs/engine/reference/util/toNumber.md
@@ -0,0 +1,32 @@
+---
+title: toNumber
+---
+
+## Summary
+
+String -> number conversion, with default.
+
+## Syntax
+
+```c
+keyman.util.toNumber(s, dflt);
+```
+
+### Parameters
+
+`s`
+: Type: `string`
+: Numeric string.
+
+`dflt`
+: Type: `number`
+: Default value if parse is unsuccessful.
+
+### Return Value
+
+`number`
+: The string's conversion to a whole-number numeric value, or the default value if unsuccessful.
+
+## Description
+
+...
diff --git a/web/docs/engine/reference/util/toNzString.md b/web/docs/engine/reference/util/toNzString.md
new file mode 100644
index 0000000000..b1b98af6f1
--- /dev/null
+++ b/web/docs/engine/reference/util/toNzString.md
@@ -0,0 +1,32 @@
+---
+title: toNzString
+---
+
+## Summary
+
+Returns string value for the item, or the default string value if the argument is null, false, an empty string, or undefined.
+
+## Syntax
+
+```c
+keyman.util.toNzString(item, dflt);
+```
+
+### Parameters
+
+`item`
+: Type: `*`
+: Variable to convert.
+
+`dflt`
+: Type: `*` *optional*
+: Value to use of the converted variable is null, false, the empty string, or undefined.
+
+### Return Value
+
+`string`
+: The string equivalent value for the item being converted.
+
+## Description
+
+...
diff --git a/web/docs/engine/troubleshooting/embedded_fonts.md b/web/docs/engine/troubleshooting/embedded_fonts.md
new file mode 100644
index 0000000000..81215add20
--- /dev/null
+++ b/web/docs/engine/troubleshooting/embedded_fonts.md
@@ -0,0 +1,53 @@
+---
+title: Embedded Font Troubleshooting
+---
+
+KeymanWeb allows users to display and enter text that may require a font
+not normally installed with your operating system, by including
+(embedding) a special copy of a suitable font in the web page.
+
+However, many older browsers do not support the use of embedded fonts.
+This test page will help you to find out whether or not your browser
+supports the use of embedded fonts for a number of languages which may
+not be fully supported by your operating system.
+
+In the table below, the left column has an image showing how the sample
+text should appear, the center column displays the sample text using a
+font installed on your system, if available, and the right column shows
+the same sample text displayed using an embedded font downloaded
+automatically with this web page.
+
+---
+**Note:** This page may take a minute or more to load all of the fonts
+needed to display correctly.
+
+---
+
+| Language | Sample text - image | Sample text - installed font | Sample text - embedded font\* |
+|----------|---------------------|------------------------------|-------------------------------|
+| Amharic |  | ኢትዮጵያ | ኢትዮጵያ |
+| Burmese |  | မြန်မာအက္ခရာ | မြန်မာအက္ခရာ |
+| Dinka |  | Thuɔŋjäŋ | Thuɔŋjäŋ |
+| Khmer |  | ភាសាខ្មែរ | ភាសាខ្មែរ |
+| Lao |  | ພາສາລາວກໍໄດ້ | ພາສາລາວກໍໄດ້ |
+| Oriya |  | ଓଡ଼ିଆ | ଓଡ଼ିଆ |
+| Sinhala |  | සිංහල | සිංහල |
+| Tamil |  | தமிழ் | தமிழ் |
+| Tibetan |  | བོད་ཡུལ། | བོད་ཡུལ། |
+
+---
+**If the embedded font display for a language is not exactly the same as in the corresponding image,**
+for example, with script characters shown
+but incorrectly positioned or ordered, you will need to install the
+Keyman Desktop package for your language onto your computer. You can
+download the Keyman Desktop package by clicking the "Help on this
+keyboard" link in the On Screen Keyboard. This is likely to be observed
+with scripts such as Burmese, Khmer or Tibetan if your operating system
+does not fully support the display of the font used for those scripts.
+
+---
+
+## More Help
+
+If you are experiencing continued difficulty in using KeymanWeb and have not been able to find a solution on this site, [please contact us](/contact).
+
diff --git a/web/docs/engine/troubleshooting/images/BurmeseSample.png b/web/docs/engine/troubleshooting/images/BurmeseSample.png
new file mode 100644
index 0000000000..5a5d2707f2
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/BurmeseSample.png differ
diff --git a/web/docs/engine/troubleshooting/images/DinkaSample.png b/web/docs/engine/troubleshooting/images/DinkaSample.png
new file mode 100644
index 0000000000..b26e5a92f6
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/DinkaSample.png differ
diff --git a/web/docs/engine/troubleshooting/images/GeezSample.png b/web/docs/engine/troubleshooting/images/GeezSample.png
new file mode 100644
index 0000000000..230ea58b93
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/GeezSample.png differ
diff --git a/web/docs/engine/troubleshooting/images/KhmerSample.png b/web/docs/engine/troubleshooting/images/KhmerSample.png
new file mode 100644
index 0000000000..e00a40b10b
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/KhmerSample.png differ
diff --git a/web/docs/engine/troubleshooting/images/LaoSample.png b/web/docs/engine/troubleshooting/images/LaoSample.png
new file mode 100644
index 0000000000..a2179bcc9e
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/LaoSample.png differ
diff --git a/web/docs/engine/troubleshooting/images/OriyaSample.png b/web/docs/engine/troubleshooting/images/OriyaSample.png
new file mode 100644
index 0000000000..e2aef1c7e1
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/OriyaSample.png differ
diff --git a/web/docs/engine/troubleshooting/images/SinhalaSample.png b/web/docs/engine/troubleshooting/images/SinhalaSample.png
new file mode 100644
index 0000000000..bb9cd40522
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/SinhalaSample.png differ
diff --git a/web/docs/engine/troubleshooting/images/TamilSample.png b/web/docs/engine/troubleshooting/images/TamilSample.png
new file mode 100644
index 0000000000..20c7812aa4
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/TamilSample.png differ
diff --git a/web/docs/engine/troubleshooting/images/TibetanSample.png b/web/docs/engine/troubleshooting/images/TibetanSample.png
new file mode 100644
index 0000000000..cd1c10e125
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/TibetanSample.png differ
diff --git a/web/docs/engine/troubleshooting/images/bigone.bmp b/web/docs/engine/troubleshooting/images/bigone.bmp
new file mode 100644
index 0000000000..2b875ab02f
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/bigone.bmp differ
diff --git a/web/docs/engine/troubleshooting/images/boxes.gif b/web/docs/engine/troubleshooting/images/boxes.gif
new file mode 100644
index 0000000000..5cb8151a7a
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/boxes.gif differ
diff --git a/web/docs/engine/troubleshooting/images/ctrlkey.gif b/web/docs/engine/troubleshooting/images/ctrlkey.gif
new file mode 100644
index 0000000000..13054987c3
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/ctrlkey.gif differ
diff --git a/web/docs/engine/troubleshooting/images/incorrect-tibetan1.gif b/web/docs/engine/troubleshooting/images/incorrect-tibetan1.gif
new file mode 100644
index 0000000000..1f4b48525c
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/incorrect-tibetan1.gif differ
diff --git a/web/docs/engine/troubleshooting/images/incorrect-tibetan2.gif b/web/docs/engine/troubleshooting/images/incorrect-tibetan2.gif
new file mode 100644
index 0000000000..8d91858f88
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/incorrect-tibetan2.gif differ
diff --git a/web/docs/engine/troubleshooting/images/oskeyboard.gif b/web/docs/engine/troubleshooting/images/oskeyboard.gif
new file mode 100644
index 0000000000..4f03d41a4e
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/oskeyboard.gif differ
diff --git a/web/docs/engine/troubleshooting/images/pin.gif b/web/docs/engine/troubleshooting/images/pin.gif
new file mode 100644
index 0000000000..5e6f0997d6
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/pin.gif differ
diff --git a/web/docs/engine/troubleshooting/images/ui-bt-hidekb.gif b/web/docs/engine/troubleshooting/images/ui-bt-hidekb.gif
new file mode 100644
index 0000000000..a22745688d
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/ui-bt-hidekb.gif differ
diff --git a/web/docs/engine/troubleshooting/images/ui-tb-control6.gif b/web/docs/engine/troubleshooting/images/ui-tb-control6.gif
new file mode 100644
index 0000000000..e24085f61d
Binary files /dev/null and b/web/docs/engine/troubleshooting/images/ui-tb-control6.gif differ
diff --git a/web/docs/engine/troubleshooting/index.md b/web/docs/engine/troubleshooting/index.md
new file mode 100644
index 0000000000..019401f8ee
--- /dev/null
+++ b/web/docs/engine/troubleshooting/index.md
@@ -0,0 +1,92 @@
+---
+title: Troubleshooting
+---
+
+Listed below are some difficulties occasionally experienced when using
+KeymanWeb. The information on this page is continually reviewed and
+updated, and other questions are addressed in the [Keyman Community](https://community.software.sil.org/c/keyman).
+
+- [Why are boxes appearing when I type?](#boxes)
+- [Why isn't my language appearing correctly?](#one)
+- [Why can't I see the On-Screen Keyboard?](#two)
+- [Why can I only type in English?](#three)
+
+
+
+#### Boxes (Characters do not Appear)
+
+
+
+If empty boxes, or boxes containing Unicode character codes, appear in
+your text box when you type (and/or on the On-Screen Keyboard), as in
+the images on the right, please check the following:
+
+- Confirm that your browser supports embedded fonts and is up to date,
+ as some earlier versions of browsers do not include this feature. In
+ this case, to enable KeymanWeb to function properly, you will need
+ to update your browser or download the specific font required for
+ your keyboard.
+- If you copy and paste text that you have typed in KeymanWeb into
+ another application such as Microsoft Word, you may find that it
+ does not display. In this case, you will need to installing the
+ Keyman Desktop package for the keyboard onto your computer. You can
+ download the Keyman Desktop package by clicking the "Help on this
+ keyboard" link in the On Screen Keyboard.
+- An [embedded font test page](embedded_fonts) is available for further testing of embedded font support on your computer.
+
+
+
+#### Characters are not Displayed Correctly
+
+
+
+If you find that you can see the characters for a language on screen,
+but they don't display quite right, you may be experiencing a limitation
+in your operating system. An example of this is visible in the Tibetan
+script on the right. Installing Keyman Desktop or Keyman for Mac may
+help resolve these issues.
+
+
+
+#### Disappearing On-Screen Keyboard
+
+If the [On-Screen Keyboard](osk) does not appear, or disappears as soon
+as you move it, please check the following:
+
+- Make sure KeymanWeb is activated by clicking in the text area.
+- Confirm that the [On-Screen Keyboard](osk) is turned on. In the
+ **Button** interface, the first item in the Keyboard Menu should be
+ , while in the other user
+ interface designs, the On-Screen Keyboard icon  should have a box around it.
+- Ensure that a keyboard has been actively selected. The On-Screen
+ Keyboard will not display for the default operating system keyboard,
+ which is generally available as the first selectable keyboard on
+ KeymanWeb desktop user interfaces.
+- Scroll up and down (and across if necessary) the website to see if
+ the On-Screen Keyboard is actually being displayed, but is in a
+ different position.
+- For more information on using the On-Screen Keyboard, [click
+ here](osk).
+
+
+
+#### English Letters
+
+If English letters appear when you type, rather than your language,
+please check the following:
+
+- Confirm that KeymanWeb is activated for the textbox or text area you
+ are typing into.
+- Make sure you have selected the correct keyboard for the language
+ you wish to use. Some languages use more than one writing system,
+ and these are often available as different keyboards.
+- For more information on the KeymanWeb user interfaces, [click
+ here](../ui).
+
+
+
+#### More Help
+
+If you are experiencing continued difficulty in using KeymanWeb and have not been able to find a solution on this page, [click here](/contact).
+
+
diff --git a/web/docs/engine/troubleshooting/osk.md b/web/docs/engine/troubleshooting/osk.md
new file mode 100644
index 0000000000..7adc06bba0
--- /dev/null
+++ b/web/docs/engine/troubleshooting/osk.md
@@ -0,0 +1,83 @@
+---
+title: What is a Keyboard?
+---
+
+When using KeymanWeb, the term *keyboard* refers specifically to
+the way the keys are arranged for a specific language (i.e. which letter
+or character appears when a given key is pressed). Some languages have
+more than one keyboard layout; a typewriter-based layout and a phonetic
+layout, for example.
+
+This page gives information about KeymanWeb's On-Screen Keyboard: the
+map of the keyboard which appears on a website when KeymanWeb is in use.
+
+#### On-Screen Keyboard
+
+
+
+The **On-Screen Keyboard** *(left)* displays the layout of the keyboard
+you are currently using. When you press any key, the blue character or
+letter marked on the On-Screen Keyboard will appear in the textbox. Many
+keyboards also use combinations of **Shift**, **Ctrl** or **Alt** and
+letter keys to include more characters. When Shift, Ctrl or Alt is
+pressed, the On-Screen Keyboard display will change to show these
+characters.
+
+You can also use the On-Screen Keyboard to enter text directly, without
+pressing any keys on your physical keyboard. Click once on any character
+displayed on the On-Screen-Keyboard, and it will be entered into the
+textbox. Shift-, Ctrl- and Alt- combinations also work with this method:
+click once on Shift, for example, and it will stay 'pressed' until it is
+clicked again or the physical Shift key is pressed. Although text entry
+using this method can be less efficient, it can be useful when a
+non-English physical keyboard is attached to the computer in use.
+
+#### **Moving and Hiding the On-Screen Keyboard**
+
+The On-Screen Keyboard can be moved to any area of the website which is
+being displayed. It can be placed in a more convenient position for
+referring to when typing, or moved out of the way if it is obscuring
+part of the textbox or another part of the screen. To move the On-Screen
+Keyboard, move the mouse pointer over the On-Screen Keyboard's title bar
+(where the title 'Tavultesoft Keyman' is displayed), and the pointer
+will change to a four-way arrow. Hold down the left mouse button, drag
+the Keyboard to your desired posistion and release the mouse button. The
+On-Screen Keyboard will remain in the new position until it is moved
+again.
+
+When you move the On-Screen Keyboard, a drawing pin icon  will appear in the title bar. Clicking on the drawing pin icon will return the On-Screen Keyboard to its original position near the KeymanWeb Control.
+
+If you are familiar with the layout of the keyboard in use and do not
+need to refer to the On-Screen Keyboard, it can be hidden (and displayed
+again if necessary) using the KeymanWeb Control. The method for hiding
+and displaying the On-Screen Keyboard varies slightly (it is done
+through either a menu item or a button) depending on which User
+Interface is configured on your website. Please refer to the specific
+[User Interface pages](../ui) for more details.
+
+#### **Resizing the On-Screen Keyboard**
+
+You can also change the size of the On-Screen Keyboard. For example, you
+may choose to make the On-Screen Keyboard smaller, instead of moving it,
+to better fit it on your screen; or you might like to enlarge the
+On-Screen Keyboard to make it clearer and easier to refer to.
+
+
+
+To resize the On-Screen Keyboard, move the mouse pointer over the shaded
+corner of the 'Ctrl' Key at its bottom right. When the pointer changes
+to a diagonal two-way arrow, hold down the left mouse button and drag
+the mouse to make the On-Screen Keyboard larger or smaller. Releasing
+the mouse button will set the size, and the On-Screen Keyboard will
+remain the new size until it is resized again.
+
+#### Information on Specific Keyboards
+
+KeymanWeb supports a very wide range of languages, and many keyboards
+available for use with KeymanWeb include features specific to particular
+languages. Because of this, each keyboard has its own documentation,
+which can be accessed by clicking on the Help on this Keyboard
+link at the bottom of the On-Screen Keyboard. Although the level of
+detail in this documentation does vary somewhat, depending on the
+designer and the requirements of each keyboard, this is the first place
+to look for information on using a particular language with KeymanWeb.
diff --git a/web/docs/engine/ui/images/ctrlkey.gif b/web/docs/engine/ui/images/ctrlkey.gif
new file mode 100644
index 0000000000..13054987c3
Binary files /dev/null and b/web/docs/engine/ui/images/ctrlkey.gif differ
diff --git a/web/docs/engine/ui/images/oskeyboard.gif b/web/docs/engine/ui/images/oskeyboard.gif
new file mode 100644
index 0000000000..4f03d41a4e
Binary files /dev/null and b/web/docs/engine/ui/images/oskeyboard.gif differ
diff --git a/web/docs/engine/ui/images/pin.gif b/web/docs/engine/ui/images/pin.gif
new file mode 100644
index 0000000000..5e6f0997d6
Binary files /dev/null and b/web/docs/engine/ui/images/pin.gif differ
diff --git a/web/docs/engine/ui/images/squareboxes.gif b/web/docs/engine/ui/images/squareboxes.gif
new file mode 100644
index 0000000000..8b25becc2b
Binary files /dev/null and b/web/docs/engine/ui/images/squareboxes.gif differ
diff --git a/web/docs/engine/ui/images/ui-123.gif b/web/docs/engine/ui/images/ui-123.gif
new file mode 100644
index 0000000000..837ff66536
Binary files /dev/null and b/web/docs/engine/ui/images/ui-123.gif differ
diff --git a/web/docs/engine/ui/images/ui-b-123.gif b/web/docs/engine/ui/images/ui-b-123.gif
new file mode 100644
index 0000000000..c23f0a36a3
Binary files /dev/null and b/web/docs/engine/ui/images/ui-b-123.gif differ
diff --git a/web/docs/engine/ui/images/ui-bt-control.gif b/web/docs/engine/ui/images/ui-bt-control.gif
new file mode 100644
index 0000000000..413ccc6b34
Binary files /dev/null and b/web/docs/engine/ui/images/ui-bt-control.gif differ
diff --git a/web/docs/engine/ui/images/ui-bt-hidekb.gif b/web/docs/engine/ui/images/ui-bt-hidekb.gif
new file mode 100644
index 0000000000..a22745688d
Binary files /dev/null and b/web/docs/engine/ui/images/ui-bt-hidekb.gif differ
diff --git a/web/docs/engine/ui/images/ui-bt-menu.gif b/web/docs/engine/ui/images/ui-bt-menu.gif
new file mode 100644
index 0000000000..7ce3113cc7
Binary files /dev/null and b/web/docs/engine/ui/images/ui-bt-menu.gif differ
diff --git a/web/docs/engine/ui/images/ui-bt-showkb.gif b/web/docs/engine/ui/images/ui-bt-showkb.gif
new file mode 100644
index 0000000000..2533bb05b0
Binary files /dev/null and b/web/docs/engine/ui/images/ui-bt-showkb.gif differ
diff --git a/web/docs/engine/ui/images/ui-bt-step123.gif b/web/docs/engine/ui/images/ui-bt-step123.gif
new file mode 100644
index 0000000000..3dacf0b51d
Binary files /dev/null and b/web/docs/engine/ui/images/ui-bt-step123.gif differ
diff --git a/web/docs/engine/ui/images/ui-button.gif b/web/docs/engine/ui/images/ui-button.gif
new file mode 100644
index 0000000000..1762f77fc6
Binary files /dev/null and b/web/docs/engine/ui/images/ui-button.gif differ
diff --git a/web/docs/engine/ui/images/ui-fl-control.gif b/web/docs/engine/ui/images/ui-fl-control.gif
new file mode 100644
index 0000000000..bc0e2c1a11
Binary files /dev/null and b/web/docs/engine/ui/images/ui-fl-control.gif differ
diff --git a/web/docs/engine/ui/images/ui-fl-control2.gif b/web/docs/engine/ui/images/ui-fl-control2.gif
new file mode 100644
index 0000000000..f4b17e0a5c
Binary files /dev/null and b/web/docs/engine/ui/images/ui-fl-control2.gif differ
diff --git a/web/docs/engine/ui/images/ui-fl-control3.gif b/web/docs/engine/ui/images/ui-fl-control3.gif
new file mode 100644
index 0000000000..b4731a1f01
Binary files /dev/null and b/web/docs/engine/ui/images/ui-fl-control3.gif differ
diff --git a/web/docs/engine/ui/images/ui-fl-step123.gif b/web/docs/engine/ui/images/ui-fl-step123.gif
new file mode 100644
index 0000000000..d52d64338d
Binary files /dev/null and b/web/docs/engine/ui/images/ui-fl-step123.gif differ
diff --git a/web/docs/engine/ui/images/ui-floating.gif b/web/docs/engine/ui/images/ui-floating.gif
new file mode 100644
index 0000000000..e961ab8416
Binary files /dev/null and b/web/docs/engine/ui/images/ui-floating.gif differ
diff --git a/web/docs/engine/ui/images/ui-osk.gif b/web/docs/engine/ui/images/ui-osk.gif
new file mode 100644
index 0000000000..910ef3f62d
Binary files /dev/null and b/web/docs/engine/ui/images/ui-osk.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control.gif b/web/docs/engine/ui/images/ui-tb-control.gif
new file mode 100644
index 0000000000..b27d559356
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control2.gif b/web/docs/engine/ui/images/ui-tb-control2.gif
new file mode 100644
index 0000000000..11448648be
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control2.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control3.gif b/web/docs/engine/ui/images/ui-tb-control3.gif
new file mode 100644
index 0000000000..2fa52fb79b
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control3.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control4.gif b/web/docs/engine/ui/images/ui-tb-control4.gif
new file mode 100644
index 0000000000..ba960a3c99
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control4.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control5.gif b/web/docs/engine/ui/images/ui-tb-control5.gif
new file mode 100644
index 0000000000..302b0d9eb2
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control5.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control6.gif b/web/docs/engine/ui/images/ui-tb-control6.gif
new file mode 100644
index 0000000000..e24085f61d
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control6.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-step123.gif b/web/docs/engine/ui/images/ui-tb-step123.gif
new file mode 100644
index 0000000000..c88da5812a
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-step123.gif differ
diff --git a/web/docs/engine/ui/images/ui-tg-control.gif b/web/docs/engine/ui/images/ui-tg-control.gif
new file mode 100644
index 0000000000..e3410b5f9a
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tg-control.gif differ
diff --git a/web/docs/engine/ui/images/ui-tg-control2.gif b/web/docs/engine/ui/images/ui-tg-control2.gif
new file mode 100644
index 0000000000..19a655964f
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tg-control2.gif differ
diff --git a/web/docs/engine/ui/images/ui-tg-control3.gif b/web/docs/engine/ui/images/ui-tg-control3.gif
new file mode 100644
index 0000000000..57dd52706e
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tg-control3.gif differ
diff --git a/web/docs/engine/ui/images/ui-tg-controlz2.gif b/web/docs/engine/ui/images/ui-tg-controlz2.gif
new file mode 100644
index 0000000000..4127d4ca40
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tg-controlz2.gif differ
diff --git a/web/docs/engine/ui/images/ui-tg-step123.gif b/web/docs/engine/ui/images/ui-tg-step123.gif
new file mode 100644
index 0000000000..695cf110cc
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tg-step123.gif differ
diff --git a/web/docs/engine/ui/images/ui-toggle.gif b/web/docs/engine/ui/images/ui-toggle.gif
new file mode 100644
index 0000000000..f468c54b2e
Binary files /dev/null and b/web/docs/engine/ui/images/ui-toggle.gif differ
diff --git a/web/docs/engine/ui/images/ui-toolbar.gif b/web/docs/engine/ui/images/ui-toolbar.gif
new file mode 100644
index 0000000000..b27d559356
Binary files /dev/null and b/web/docs/engine/ui/images/ui-toolbar.gif differ
diff --git a/web/docs/engine/ui/images/white.gif b/web/docs/engine/ui/images/white.gif
new file mode 100644
index 0000000000..714cf142c1
Binary files /dev/null and b/web/docs/engine/ui/images/white.gif differ
diff --git a/web/docs/engine/ui/index.md b/web/docs/engine/ui/index.md
new file mode 100644
index 0000000000..04d74d8bee
--- /dev/null
+++ b/web/docs/engine/ui/index.md
@@ -0,0 +1,67 @@
+---
+title: Using KeymanWeb
+---
+## User Interface options
+
+As a web-based language solution, KeymanWeb can be used for an extremely
+wide variety of applications. A range of standard User Interface designs
+have been included to provide flexibility in incorporating KeymanWeb
+into a website. This allows developers to select an interface which best
+complements their website design. Customised designs can be developed to
+suit specific site requirements. Please [contact support](/contact/)
+for more information.
+
+Using the various interfaces is largely similar, but because the
+appearance of each is quite distinct, they are dealt with in different
+sections of this help documentation. Please click on the links below for
+more information on the interface you are using.
+
+
+
+Moving the mouse point over the Menu Button will display the **Keyboard
+Menu** *(left)*. This is a list of all the keyboards which have been
+integrated for use with KeymanWeb on this particular website.
+
+### Selecting a Keyboard
+
+To choose the keyboard or language in which to type, click once on that
+keyboard's name in the Keyboard Menu. The name will then be marked in
+**bold** text on the menu. On many sites, you can start typing
+immediately, while in other cases, you will need to click once inside
+the text box or text area before beginning to type.
+
+If a website incorporates several keyboards, it is possible to type in
+more than one language inside a single text box by returning to the
+Keyboard Menu and selecting a different keyboard. To return to typing in
+English or your default language, simply choose 'English' from the
+Keyboard Menu.
+
+KeymanWeb will only affect the keyboard used in the text box to which it
+is attached. If you type text into any other text box or text area, it
+will continue to appear in your normal language.
+
+### On-Screen Keyboard
+
+
+
+The [On-Screen Keyboard](osk) *(left)* is a dynamic display showing the
+layout of the keyboard you are using. At the top of the Keyboard Menu
+(assuming the On-Screen Keyboard is not already visible) is the item
+. Clicking on this once will
+cause the On-Screen Keyboard to appear and change the menu item to
+. This works in reverse if the
+On-Screen Keyboard is already displayed.
+
+To avoid obscuring the display, the On-Screen Keyboard will not actually
+be displayed unless you have clicked in a text box which incorporates
+KeymanWeb. For more information about using the On-Screen Keyboard,
+[click here](osk).
diff --git a/web/docs/engine/ui/ui-floating.md b/web/docs/engine/ui/ui-floating.md
new file mode 100644
index 0000000000..46658acf9b
--- /dev/null
+++ b/web/docs/engine/ui/ui-floating.md
@@ -0,0 +1,57 @@
+---
+title: Using the KeymanWeb Floating Interface
+---
+KeymanWeb's Floating user interface provides a straightforward and
+unobtrusive method of incorporating a range of languages and keyboards
+into a website.
+
+### Using the Floating Interface to Type in Your Language
+
+
+
+### Control Bar
+
+
+
+On a website which uses this KeymanWeb interface to allow typing in one
+or more languages, the **Control Bar** *(left)* will appear when you
+click in a text box or text area.
+
+The Control Bar will be located either to the right of or below the text
+box, depending on how the website has been set up, and will disappear
+when you click on a different part of the website.
+
+### Selecting a Keyboard
+
+
+
+In the centre of the Control Bar is a menu which displays a list of all
+the keyboards that have been integrated into the website. To choose the
+keyboard or language in which to type, click once on that keyboard's
+name in the Keyboard Menu. The name will then be highlighted on the
+menu, and you can start typing immediately.
+
+If a website incorporates several keyboards, it is possible to type in
+more than one language inside a single text box by returning to this
+menu and selecting a different keyboard. To return to typing in English
+or your default language, simply choose 'English' from the menu.
+
+KeymanWeb will only affect the keyboard used in the text box to which it
+is attached. If you type text into any other text box or text area, it
+will continue to appear in your normal language.
+
+### On-Screen Keyboard
+
+
+
+The [On-Screen Keyboard](osk) *(left)* is a dynamic display showing the
+layout of the keyboard you are using. Clicking on the On-Screen Keyboard
+icon  on the right side of the Control Bar
+turns the On-Screen Keyboard on and off. When the On-Screen keyboard is
+activated, this icon will have a border around it, as shown. However, to
+avoid obscuring the display, the On-Screen Keyboard will not actually be
+displayed unless you have clicked in a text box which incorporates
+KeymanWeb. For more information about using the On-Screen Keyboard,
+[click here](osk).
+
+
diff --git a/web/docs/engine/ui/ui-toggle.md b/web/docs/engine/ui/ui-toggle.md
new file mode 100644
index 0000000000..83e3335b59
--- /dev/null
+++ b/web/docs/engine/ui/ui-toggle.md
@@ -0,0 +1,42 @@
+---
+title: Using the KeymanWeb Toggle Interface
+---
+KeymanWeb's Toggle user interface is designed to provide a simple and
+unobtrusive way of incorporating a single keyboard into a website.
+
+### Using the Toggle Interface to Type in Your Language
+
+
+
+### Toggle Control
+
+ When you click in a text box (or text area) on the website, the **Toggle
+Control** *(left)* appears on the right of the box, indicating that it
+is possible to type in another language.
+
+ Hovering the mouse pointer over the KeymanWeb icon on the left-hand side
+of the Toggle control *(left)* will display the name of the language and
+keyboard which has been enabled for this site. Clicking on the icon will
+turn KeymanWeb on and enable you to type in this language. When
+KeymanWeb is active, there will be a solid border around the KeymanWeb
+icon (as in the image). To turn KeymanWeb off and return to typing in
+your default language, simply click on the icon once again.
+
+---
+**Note:** Clicking in a different text box or text area will not necessarily turn KeymanWeb off; this depends on how the website has been configured.
+
+---
+
+### On-Screen Keyboard
+
+
+
+The [On-Screen Keyboard](osk) *(left)* is a dynamic display showing the
+layout of the keyboard you are using. Clicking on the On-Screen Keyboard
+icon  on the right side of the Toggle
+Control turns the On-Screen Keyboard on and off. When the On-Screen
+keyboard is activated, this icon will have a solid border around it.
+However, to avoid obscuring the display, the On-Screen Keyboard will not
+actually be displayed unless you have clicked in a text box which
+incorporates KeymanWeb. For more information about using the On-Screen
+Keyboard, [click here](osk).
diff --git a/web/docs/engine/ui/ui-toolbar.md b/web/docs/engine/ui/ui-toolbar.md
new file mode 100644
index 0000000000..ad6787b15c
--- /dev/null
+++ b/web/docs/engine/ui/ui-toolbar.md
@@ -0,0 +1,68 @@
+---
+title: Using the KeymanWeb Toolbar Interface
+---
+## Toolbar Interface
+
+KeymanWeb's Toolbar user interface provides a very clear and visible
+method of incorporating a range of international languages and keyboards
+into a website. The toolbar is visible all the time, which makes it
+suitable for incorporating into a site's overall design.
+
+### Using the Toolbar Interface to Type in Your Language
+
+
+
+### Toolbar
+
+ If the **Toolbar** *(left)* is visible on a website, this is an
+indication that KeymanWeb has been set up to allow typing in one or more
+languages. The Toolbar is usually located above, inside or close to a
+text box or text area, though this will vary, depending on the site.
+
+### Selecting a Keyboard
+
+
+
+To begin typing in a different language, in which to type, click on the
+**Keyboards** dropdown menu on the Toolbar. A world map, divided into
+regions, will be displayed, with a list of available languages below
+*(right)*. Clicking on each region of the world will update the list so
+show which languages from that region can be used to type. Simply click
+on the name of the language you wish to use.
+
+For languages which have only a single keyboard available, a label
+giving the name of the selected language will be added to the Toolbar,
+and you can click in a suitable text box or text area and begin typing
+with that keyboard. To return to typing in English or your default
+language, click on the  icon near the
+centre of the Toolbar.
+
+
+
+For many languages, however, a variety of keyboard layouts is available,
+and more than one of these may have been incorporated into a website. In
+this case, beside the language name on the Toolbar, another dropdown
+menu will appear, with a list of keyboards to choose from (left). Click
+on the desired keyboard and then in the text box to begin typing using
+this keyboard.
+
+If a website incorporates several keyboards, it is possible to type in
+more than one language inside a single text box by returning to the
+menus on the Toolbar and selecting a different language and/or keyboard.
+As mentioned above, clicking on the 
+icon near the centre of the Toolbar will return you to typing in English
+or your default language.
+
+### On-Screen Keyboard
+
+
+
+The [On-Screen Keyboard](osk) *(left)* is a dynamic display showing the
+layout of the keyboard you are using. Clicking on the On-Screen Keyboard
+icon  on the right side of the Toolbar
+turns the On-Screen Keyboard on and off. When the On-Screen keyboard is
+activated, this icon will have a border around it, as shown. However, to
+avoid obscuring the display, the On-Screen Keyboard will not actually be
+displayed unless you have clicked in a text box which incorporates
+KeymanWeb. For more information about using the On-Screen Keyboard,
+[click here](osk).
diff --git a/web/docs/engine/whats-new.md b/web/docs/engine/whats-new.md
new file mode 100644
index 0000000000..49fa337fe0
--- /dev/null
+++ b/web/docs/engine/whats-new.md
@@ -0,0 +1,3 @@
+---
+title: What's New in KeymanWeb 18.0
+---
| Object name or description | +Object or array element members | +||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| (container object) | +
+
|
+ ||||||||||||||||||||||||||||||||||||||||||||||||
| (layout specification) | +
+
|
+ ||||||||||||||||||||||||||||||||||||||||||||||||
| layer | +
+
|
+ ||||||||||||||||||||||||||||||||||||||||||||||||
| row | +
+
|
+ ||||||||||||||||||||||||||||||||||||||||||||||||
| key | +
+
|
+
| Member name | +Details | +||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| id | +Each key id must start with >K_ , for keys mapped to standard Keyman virtual key names, e.g. K_HYPHEN , or either U_ or T_ for user-defined names. Keys identified as U_xxxx[_xxxx...] specify one or more Unicode characters in hex format, e.g. U_1363 for the Ethiopic Comma character, and will insert those characters if the key id is not matched by a rule. Other user-defined keys, such as T_ZZZ , will be ignored unless matched by a rule. The key id is required except for key styles 9 or 10 (blank or spacer keys). | +||||||||||||||
| text | +Where a key id is of the form K_XXXX , the text on the key will be the indicated Unicode character if this member is omitted. However, what the keystroke output will depend on any rules that process the keystroke, and may or may not be the same as the key text. | +||||||||||||||
| sp | +
+
|
+ ||||||||||||||
| font | +The font for the key label may be specified if it is necessary to use a different font for that key. | +||||||||||||||
| fontsize | +The font size for the key label may be specified (in em units) if necessary. | +||||||||||||||
| width | +By default, each key has a width of 100 + units, with rows then scaled to make the widest row fit on the screen. + Set the width value if a key should be narrower or wider than the + standard width. | +||||||||||||||
| pad | +Space before key, in same units as width (default key width=100 units). | +||||||||||||||
| layer | +Override the default layer type for processing key rules. For example, use 'layer':'shift' in any layer to process a key rule as if it were the shift layer, i.e. as if the Shift key was down. | +||||||||||||||
| nextlayer | +Select the key layer to be displayed after processing the current keystroke. This will usually be used to implement custom layer selection, but can also be used to select a different layer after a deadkey or normal key, and will override any nextlayer value specifed for the entire layer. The layer to be displayed may also be specified using the setlayer() statement in a rule in the keyboard source. | +||||||||||||||
| sk | +Pop-up key specifications are identical to normal key specifications except that they cannot be nested. (Key size and spacing members width and pad are ignored for pop-up keys.) | +
+
+If empty boxes, or boxes containing Unicode character codes, appear in
+your text box when you type (and/or on the On-Screen Keyboard), as in
+the images on the right, please check the following:
+
+- Confirm that your browser supports embedded fonts and is up to date,
+ as some earlier versions of browsers do not include this feature. In
+ this case, to enable KeymanWeb to function properly, you will need
+ to update your browser or download the specific font required for
+ your keyboard.
+- If you copy and paste text that you have typed in KeymanWeb into
+ another application such as Microsoft Word, you may find that it
+ does not display. In this case, you will need to installing the
+ Keyman Desktop package for the keyboard onto your computer. You can
+ download the Keyman Desktop package by clicking the "Help on this
+ keyboard" link in the On Screen Keyboard.
+- An [embedded font test page](embedded_fonts) is available for further testing of embedded font support on your computer.
+
+
+
+#### Characters are not Displayed Correctly
+
+
+
+If you find that you can see the characters for a language on screen,
+but they don't display quite right, you may be experiencing a limitation
+in your operating system. An example of this is visible in the Tibetan
+script on the right. Installing Keyman Desktop or Keyman for Mac may
+help resolve these issues.
+
+
+
+#### Disappearing On-Screen Keyboard
+
+If the [On-Screen Keyboard](osk) does not appear, or disappears as soon
+as you move it, please check the following:
+
+- Make sure KeymanWeb is activated by clicking in the text area.
+- Confirm that the [On-Screen Keyboard](osk) is turned on. In the
+ **Button** interface, the first item in the Keyboard Menu should be
+ , while in the other user
+ interface designs, the On-Screen Keyboard icon  should have a box around it.
+- Ensure that a keyboard has been actively selected. The On-Screen
+ Keyboard will not display for the default operating system keyboard,
+ which is generally available as the first selectable keyboard on
+ KeymanWeb desktop user interfaces.
+- Scroll up and down (and across if necessary) the website to see if
+ the On-Screen Keyboard is actually being displayed, but is in a
+ different position.
+- For more information on using the On-Screen Keyboard, [click
+ here](osk).
+
+
+
+#### English Letters
+
+If English letters appear when you type, rather than your language,
+please check the following:
+
+- Confirm that KeymanWeb is activated for the textbox or text area you
+ are typing into.
+- Make sure you have selected the correct keyboard for the language
+ you wish to use. Some languages use more than one writing system,
+ and these are often available as different keyboards.
+- For more information on the KeymanWeb user interfaces, [click
+ here](../ui).
+
+
+
+#### More Help
+
+If you are experiencing continued difficulty in using KeymanWeb and have not been able to find a solution on this page, [click here](/contact).
+
+
diff --git a/web/docs/engine/troubleshooting/osk.md b/web/docs/engine/troubleshooting/osk.md
new file mode 100644
index 0000000000..7adc06bba0
--- /dev/null
+++ b/web/docs/engine/troubleshooting/osk.md
@@ -0,0 +1,83 @@
+---
+title: What is a Keyboard?
+---
+
+When using KeymanWeb, the term *keyboard* refers specifically to
+the way the keys are arranged for a specific language (i.e. which letter
+or character appears when a given key is pressed). Some languages have
+more than one keyboard layout; a typewriter-based layout and a phonetic
+layout, for example.
+
+This page gives information about KeymanWeb's On-Screen Keyboard: the
+map of the keyboard which appears on a website when KeymanWeb is in use.
+
+#### On-Screen Keyboard
+
+
+
+The **On-Screen Keyboard** *(left)* displays the layout of the keyboard
+you are currently using. When you press any key, the blue character or
+letter marked on the On-Screen Keyboard will appear in the textbox. Many
+keyboards also use combinations of **Shift**, **Ctrl** or **Alt** and
+letter keys to include more characters. When Shift, Ctrl or Alt is
+pressed, the On-Screen Keyboard display will change to show these
+characters.
+
+You can also use the On-Screen Keyboard to enter text directly, without
+pressing any keys on your physical keyboard. Click once on any character
+displayed on the On-Screen-Keyboard, and it will be entered into the
+textbox. Shift-, Ctrl- and Alt- combinations also work with this method:
+click once on Shift, for example, and it will stay 'pressed' until it is
+clicked again or the physical Shift key is pressed. Although text entry
+using this method can be less efficient, it can be useful when a
+non-English physical keyboard is attached to the computer in use.
+
+#### **Moving and Hiding the On-Screen Keyboard**
+
+The On-Screen Keyboard can be moved to any area of the website which is
+being displayed. It can be placed in a more convenient position for
+referring to when typing, or moved out of the way if it is obscuring
+part of the textbox or another part of the screen. To move the On-Screen
+Keyboard, move the mouse pointer over the On-Screen Keyboard's title bar
+(where the title 'Tavultesoft Keyman' is displayed), and the pointer
+will change to a four-way arrow. Hold down the left mouse button, drag
+the Keyboard to your desired posistion and release the mouse button. The
+On-Screen Keyboard will remain in the new position until it is moved
+again.
+
+When you move the On-Screen Keyboard, a drawing pin icon  will appear in the title bar. Clicking on the drawing pin icon will return the On-Screen Keyboard to its original position near the KeymanWeb Control.
+
+If you are familiar with the layout of the keyboard in use and do not
+need to refer to the On-Screen Keyboard, it can be hidden (and displayed
+again if necessary) using the KeymanWeb Control. The method for hiding
+and displaying the On-Screen Keyboard varies slightly (it is done
+through either a menu item or a button) depending on which User
+Interface is configured on your website. Please refer to the specific
+[User Interface pages](../ui) for more details.
+
+#### **Resizing the On-Screen Keyboard**
+
+You can also change the size of the On-Screen Keyboard. For example, you
+may choose to make the On-Screen Keyboard smaller, instead of moving it,
+to better fit it on your screen; or you might like to enlarge the
+On-Screen Keyboard to make it clearer and easier to refer to.
+
+
+
+To resize the On-Screen Keyboard, move the mouse pointer over the shaded
+corner of the 'Ctrl' Key at its bottom right. When the pointer changes
+to a diagonal two-way arrow, hold down the left mouse button and drag
+the mouse to make the On-Screen Keyboard larger or smaller. Releasing
+the mouse button will set the size, and the On-Screen Keyboard will
+remain the new size until it is resized again.
+
+#### Information on Specific Keyboards
+
+KeymanWeb supports a very wide range of languages, and many keyboards
+available for use with KeymanWeb include features specific to particular
+languages. Because of this, each keyboard has its own documentation,
+which can be accessed by clicking on the Help on this Keyboard
+link at the bottom of the On-Screen Keyboard. Although the level of
+detail in this documentation does vary somewhat, depending on the
+designer and the requirements of each keyboard, this is the first place
+to look for information on using a particular language with KeymanWeb.
diff --git a/web/docs/engine/ui/images/ctrlkey.gif b/web/docs/engine/ui/images/ctrlkey.gif
new file mode 100644
index 0000000000..13054987c3
Binary files /dev/null and b/web/docs/engine/ui/images/ctrlkey.gif differ
diff --git a/web/docs/engine/ui/images/oskeyboard.gif b/web/docs/engine/ui/images/oskeyboard.gif
new file mode 100644
index 0000000000..4f03d41a4e
Binary files /dev/null and b/web/docs/engine/ui/images/oskeyboard.gif differ
diff --git a/web/docs/engine/ui/images/pin.gif b/web/docs/engine/ui/images/pin.gif
new file mode 100644
index 0000000000..5e6f0997d6
Binary files /dev/null and b/web/docs/engine/ui/images/pin.gif differ
diff --git a/web/docs/engine/ui/images/squareboxes.gif b/web/docs/engine/ui/images/squareboxes.gif
new file mode 100644
index 0000000000..8b25becc2b
Binary files /dev/null and b/web/docs/engine/ui/images/squareboxes.gif differ
diff --git a/web/docs/engine/ui/images/ui-123.gif b/web/docs/engine/ui/images/ui-123.gif
new file mode 100644
index 0000000000..837ff66536
Binary files /dev/null and b/web/docs/engine/ui/images/ui-123.gif differ
diff --git a/web/docs/engine/ui/images/ui-b-123.gif b/web/docs/engine/ui/images/ui-b-123.gif
new file mode 100644
index 0000000000..c23f0a36a3
Binary files /dev/null and b/web/docs/engine/ui/images/ui-b-123.gif differ
diff --git a/web/docs/engine/ui/images/ui-bt-control.gif b/web/docs/engine/ui/images/ui-bt-control.gif
new file mode 100644
index 0000000000..413ccc6b34
Binary files /dev/null and b/web/docs/engine/ui/images/ui-bt-control.gif differ
diff --git a/web/docs/engine/ui/images/ui-bt-hidekb.gif b/web/docs/engine/ui/images/ui-bt-hidekb.gif
new file mode 100644
index 0000000000..a22745688d
Binary files /dev/null and b/web/docs/engine/ui/images/ui-bt-hidekb.gif differ
diff --git a/web/docs/engine/ui/images/ui-bt-menu.gif b/web/docs/engine/ui/images/ui-bt-menu.gif
new file mode 100644
index 0000000000..7ce3113cc7
Binary files /dev/null and b/web/docs/engine/ui/images/ui-bt-menu.gif differ
diff --git a/web/docs/engine/ui/images/ui-bt-showkb.gif b/web/docs/engine/ui/images/ui-bt-showkb.gif
new file mode 100644
index 0000000000..2533bb05b0
Binary files /dev/null and b/web/docs/engine/ui/images/ui-bt-showkb.gif differ
diff --git a/web/docs/engine/ui/images/ui-bt-step123.gif b/web/docs/engine/ui/images/ui-bt-step123.gif
new file mode 100644
index 0000000000..3dacf0b51d
Binary files /dev/null and b/web/docs/engine/ui/images/ui-bt-step123.gif differ
diff --git a/web/docs/engine/ui/images/ui-button.gif b/web/docs/engine/ui/images/ui-button.gif
new file mode 100644
index 0000000000..1762f77fc6
Binary files /dev/null and b/web/docs/engine/ui/images/ui-button.gif differ
diff --git a/web/docs/engine/ui/images/ui-fl-control.gif b/web/docs/engine/ui/images/ui-fl-control.gif
new file mode 100644
index 0000000000..bc0e2c1a11
Binary files /dev/null and b/web/docs/engine/ui/images/ui-fl-control.gif differ
diff --git a/web/docs/engine/ui/images/ui-fl-control2.gif b/web/docs/engine/ui/images/ui-fl-control2.gif
new file mode 100644
index 0000000000..f4b17e0a5c
Binary files /dev/null and b/web/docs/engine/ui/images/ui-fl-control2.gif differ
diff --git a/web/docs/engine/ui/images/ui-fl-control3.gif b/web/docs/engine/ui/images/ui-fl-control3.gif
new file mode 100644
index 0000000000..b4731a1f01
Binary files /dev/null and b/web/docs/engine/ui/images/ui-fl-control3.gif differ
diff --git a/web/docs/engine/ui/images/ui-fl-step123.gif b/web/docs/engine/ui/images/ui-fl-step123.gif
new file mode 100644
index 0000000000..d52d64338d
Binary files /dev/null and b/web/docs/engine/ui/images/ui-fl-step123.gif differ
diff --git a/web/docs/engine/ui/images/ui-floating.gif b/web/docs/engine/ui/images/ui-floating.gif
new file mode 100644
index 0000000000..e961ab8416
Binary files /dev/null and b/web/docs/engine/ui/images/ui-floating.gif differ
diff --git a/web/docs/engine/ui/images/ui-osk.gif b/web/docs/engine/ui/images/ui-osk.gif
new file mode 100644
index 0000000000..910ef3f62d
Binary files /dev/null and b/web/docs/engine/ui/images/ui-osk.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control.gif b/web/docs/engine/ui/images/ui-tb-control.gif
new file mode 100644
index 0000000000..b27d559356
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control2.gif b/web/docs/engine/ui/images/ui-tb-control2.gif
new file mode 100644
index 0000000000..11448648be
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control2.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control3.gif b/web/docs/engine/ui/images/ui-tb-control3.gif
new file mode 100644
index 0000000000..2fa52fb79b
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control3.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control4.gif b/web/docs/engine/ui/images/ui-tb-control4.gif
new file mode 100644
index 0000000000..ba960a3c99
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control4.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control5.gif b/web/docs/engine/ui/images/ui-tb-control5.gif
new file mode 100644
index 0000000000..302b0d9eb2
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control5.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-control6.gif b/web/docs/engine/ui/images/ui-tb-control6.gif
new file mode 100644
index 0000000000..e24085f61d
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-control6.gif differ
diff --git a/web/docs/engine/ui/images/ui-tb-step123.gif b/web/docs/engine/ui/images/ui-tb-step123.gif
new file mode 100644
index 0000000000..c88da5812a
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tb-step123.gif differ
diff --git a/web/docs/engine/ui/images/ui-tg-control.gif b/web/docs/engine/ui/images/ui-tg-control.gif
new file mode 100644
index 0000000000..e3410b5f9a
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tg-control.gif differ
diff --git a/web/docs/engine/ui/images/ui-tg-control2.gif b/web/docs/engine/ui/images/ui-tg-control2.gif
new file mode 100644
index 0000000000..19a655964f
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tg-control2.gif differ
diff --git a/web/docs/engine/ui/images/ui-tg-control3.gif b/web/docs/engine/ui/images/ui-tg-control3.gif
new file mode 100644
index 0000000000..57dd52706e
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tg-control3.gif differ
diff --git a/web/docs/engine/ui/images/ui-tg-controlz2.gif b/web/docs/engine/ui/images/ui-tg-controlz2.gif
new file mode 100644
index 0000000000..4127d4ca40
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tg-controlz2.gif differ
diff --git a/web/docs/engine/ui/images/ui-tg-step123.gif b/web/docs/engine/ui/images/ui-tg-step123.gif
new file mode 100644
index 0000000000..695cf110cc
Binary files /dev/null and b/web/docs/engine/ui/images/ui-tg-step123.gif differ
diff --git a/web/docs/engine/ui/images/ui-toggle.gif b/web/docs/engine/ui/images/ui-toggle.gif
new file mode 100644
index 0000000000..f468c54b2e
Binary files /dev/null and b/web/docs/engine/ui/images/ui-toggle.gif differ
diff --git a/web/docs/engine/ui/images/ui-toolbar.gif b/web/docs/engine/ui/images/ui-toolbar.gif
new file mode 100644
index 0000000000..b27d559356
Binary files /dev/null and b/web/docs/engine/ui/images/ui-toolbar.gif differ
diff --git a/web/docs/engine/ui/images/white.gif b/web/docs/engine/ui/images/white.gif
new file mode 100644
index 0000000000..714cf142c1
Binary files /dev/null and b/web/docs/engine/ui/images/white.gif differ
diff --git a/web/docs/engine/ui/index.md b/web/docs/engine/ui/index.md
new file mode 100644
index 0000000000..04d74d8bee
--- /dev/null
+++ b/web/docs/engine/ui/index.md
@@ -0,0 +1,67 @@
+---
+title: Using KeymanWeb
+---
+## User Interface options
+
+As a web-based language solution, KeymanWeb can be used for an extremely
+wide variety of applications. A range of standard User Interface designs
+have been included to provide flexibility in incorporating KeymanWeb
+into a website. This allows developers to select an interface which best
+complements their website design. Customised designs can be developed to
+suit specific site requirements. Please [contact support](/contact/)
+for more information.
+
+Using the various interfaces is largely similar, but because the
+appearance of each is quite distinct, they are dealt with in different
+sections of this help documentation. Please click on the links below for
+more information on the interface you are using.
+
+
+
+
+
+
diff --git a/web/docs/engine/ui/osk.md b/web/docs/engine/ui/osk.md
new file mode 100644
index 0000000000..9d13cc9a85
--- /dev/null
+++ b/web/docs/engine/ui/osk.md
@@ -0,0 +1,90 @@
+---
+title: On Screen Keyboard
+---
+
+### What is a Keyboard?
+
+When using KeymanWeb, the term *keyboard* refers specifically to
+the way the keys are arranged for a specific language (i.e. which letter
+or character appears when a given key is pressed). Some languages have
+more than one keyboard layout; a typewriter-based layout and a phonetic
+layout, for example.
+
+This page gives information about KeymanWeb's On-Screen Keyboard: the
+map of the keyboard which appears on a website when KeymanWeb is in use.
+
+[More about KeymanWeb keyboards](../../current-version/guide/what-is-a-keyboard)
+
+### On-Screen Keyboard
+
+
+
+The **On-Screen Keyboard** *(above)* displays the layout of the keyboard
+you are currently using. When you press any key, the blue character or
+letter marked on the On-Screen Keyboard will appear in the textbox. Many
+keyboards also use combinations of **Shift**, **Ctrl** or **Alt** and
+letter keys to include more characters. When Shift, Ctrl or Alt is
+pressed, the On-Screen Keyboard display will change to show these
+characters.
+
+You can also use the On-Screen Keyboard to enter text directly, without
+pressing any keys on your physical keyboard. Click once on any character
+displayed on the On-Screen-Keyboard, and it will be entered into the
+textbox. Shift-, Ctrl- and Alt- combinations also work with this method:
+click once on Shift, for example, and it will stay 'pressed' until it is
+clicked again or the physical Shift key is pressed. Although text entry
+using this method can be less efficient, it can be useful when a
+non-English physical keyboard is attached to the computer in use.
+
+### Moving and Hiding the On-Screen Keyboard
+
+The On-Screen Keyboard can be moved to any area of the website which is
+being displayed. It can be placed in a more convenient position for
+referring to when typing, or moved out of the way if it is obscuring
+part of the textbox or another part of the screen. To move the On-Screen
+Keyboard, move the mouse pointer over the On-Screen Keyboard's title bar
+(where the title 'Tavultesoft Keyman' is displayed), and the pointer
+will change to a four-way arrow. Hold down the left mouse button, drag
+the Keyboard to your desired posistion and release the mouse button. The
+On-Screen Keyboard will remain in the new position until it is moved
+again.
+
+When you move the On-Screen Keyboard, a drawing pin icon
+ will appear in the title bar. Clicking on the
+drawing pin icon will return the On-Screen Keyboard to its original
+position near the KeymanWeb Control.
+
+If you are familiar with the layout of the keyboard in use and do not
+need to refer to the On-Screen Keyboard, it can be hidden (and displayed
+again if necessary) using the KeymanWeb Control. The method for hiding
+and displaying the On-Screen Keyboard varies slightly (it is done
+through either a menu item or a button) depending on which User
+Interface is configured on your website. Please refer to the specific
+[User Interface pages](../ui) for more details.
+
+### Resizing the On-Screen Keyboard
+
+You can also change the size of the On-Screen Keyboard. For example, you
+may choose to make the On-Screen Keyboard smaller, instead of moving it,
+to better fit it on your screen; or you might like to enlarge the
+On-Screen Keyboard to make it clearer and easier to refer to.
+
+
+
+To resize the On-Screen Keyboard, move the mouse pointer over the shaded
+corner of the 'Ctrl' Key at its bottom right. When the pointer changes
+to a diagonal two-way arrow, hold down the left mouse button and drag
+the mouse to make the On-Screen Keyboard larger or smaller. Releasing
+the mouse button will set the size, and the On-Screen Keyboard will
+remain the new size until it is resized again.
+
+### Information on Specific Keyboards
+
+KeymanWeb supports a very wide range of languages, and many keyboards
+available for use with KeymanWeb include features specific to particular
+languages. Because of this, each keyboard has its own documentation,
+which can be accessed by clicking on the Help on this Keyboard
+link at the bottom of the On-Screen Keyboard. Although the level of
+detail in this documentation does vary somewhat, depending on the
+designer and the requirements of each keyboard, this is the first place
+to look for information on using a particular language with KeymanWeb.
diff --git a/web/docs/engine/ui/ui-button.md b/web/docs/engine/ui/ui-button.md
new file mode 100644
index 0000000000..1a9331689b
--- /dev/null
+++ b/web/docs/engine/ui/ui-button.md
@@ -0,0 +1,60 @@
+---
+title: Using the KeymanWeb Button Interface
+---
+KeymanWeb's Button user interface allows multiple keyboards to be
+integrated into a website and controlled through a single button
+control. This button is visible all the time, and so can be incorporated
+into the site's overall design.
+
+### Using the Button Interface to Type in Your Language
+
+
+
+### Button Control
+
+ If the **Button Control** *(left)* is visible on a website, this is an
+indication that KeymanWeb has been set up to allow typing in one or more
+languages. The Button Control is usually located above, beside or close
+to a text box or text area, though this will vary depending on the
+design and layout of the site.
+
++Button +Interface |
++ | +Floating +Interface |
+
+Toggle +Interface |
++ | +Toolbar +Interface |
+
| More information is also +available on how to use the On Screen Keyboard. | +||
+On Screen +Keyboard |
+||
+
+Moving the mouse point over the Menu Button will display the **Keyboard
+Menu** *(left)*. This is a list of all the keyboards which have been
+integrated for use with KeymanWeb on this particular website.
+
+### Selecting a Keyboard
+
+To choose the keyboard or language in which to type, click once on that
+keyboard's name in the Keyboard Menu. The name will then be marked in
+**bold** text on the menu. On many sites, you can start typing
+immediately, while in other cases, you will need to click once inside
+the text box or text area before beginning to type.
+
+If a website incorporates several keyboards, it is possible to type in
+more than one language inside a single text box by returning to the
+Keyboard Menu and selecting a different keyboard. To return to typing in
+English or your default language, simply choose 'English' from the
+Keyboard Menu.
+
+KeymanWeb will only affect the keyboard used in the text box to which it
+is attached. If you type text into any other text box or text area, it
+will continue to appear in your normal language.
+
+### On-Screen Keyboard
+
+
+
+The [On-Screen Keyboard](osk) *(left)* is a dynamic display showing the
+layout of the keyboard you are using. At the top of the Keyboard Menu
+(assuming the On-Screen Keyboard is not already visible) is the item
+. Clicking on this once will
+cause the On-Screen Keyboard to appear and change the menu item to
+. This works in reverse if the
+On-Screen Keyboard is already displayed.
+
+To avoid obscuring the display, the On-Screen Keyboard will not actually
+be displayed unless you have clicked in a text box which incorporates
+KeymanWeb. For more information about using the On-Screen Keyboard,
+[click here](osk).
diff --git a/web/docs/engine/ui/ui-floating.md b/web/docs/engine/ui/ui-floating.md
new file mode 100644
index 0000000000..46658acf9b
--- /dev/null
+++ b/web/docs/engine/ui/ui-floating.md
@@ -0,0 +1,57 @@
+---
+title: Using the KeymanWeb Floating Interface
+---
+KeymanWeb's Floating user interface provides a straightforward and
+unobtrusive method of incorporating a range of languages and keyboards
+into a website.
+
+### Using the Floating Interface to Type in Your Language
+
+
+
+### Control Bar
+
+
+
+On a website which uses this KeymanWeb interface to allow typing in one
+or more languages, the **Control Bar** *(left)* will appear when you
+click in a text box or text area.
+
+The Control Bar will be located either to the right of or below the text
+box, depending on how the website has been set up, and will disappear
+when you click on a different part of the website.
+
+### Selecting a Keyboard
+
+
+
+In the centre of the Control Bar is a menu which displays a list of all
+the keyboards that have been integrated into the website. To choose the
+keyboard or language in which to type, click once on that keyboard's
+name in the Keyboard Menu. The name will then be highlighted on the
+menu, and you can start typing immediately.
+
+If a website incorporates several keyboards, it is possible to type in
+more than one language inside a single text box by returning to this
+menu and selecting a different keyboard. To return to typing in English
+or your default language, simply choose 'English' from the menu.
+
+KeymanWeb will only affect the keyboard used in the text box to which it
+is attached. If you type text into any other text box or text area, it
+will continue to appear in your normal language.
+
+### On-Screen Keyboard
+
+
+
+The [On-Screen Keyboard](osk) *(left)* is a dynamic display showing the
+layout of the keyboard you are using. Clicking on the On-Screen Keyboard
+icon  on the right side of the Control Bar
+turns the On-Screen Keyboard on and off. When the On-Screen keyboard is
+activated, this icon will have a border around it, as shown. However, to
+avoid obscuring the display, the On-Screen Keyboard will not actually be
+displayed unless you have clicked in a text box which incorporates
+KeymanWeb. For more information about using the On-Screen Keyboard,
+[click here](osk).
+
+
diff --git a/web/docs/engine/ui/ui-toggle.md b/web/docs/engine/ui/ui-toggle.md
new file mode 100644
index 0000000000..83e3335b59
--- /dev/null
+++ b/web/docs/engine/ui/ui-toggle.md
@@ -0,0 +1,42 @@
+---
+title: Using the KeymanWeb Toggle Interface
+---
+KeymanWeb's Toggle user interface is designed to provide a simple and
+unobtrusive way of incorporating a single keyboard into a website.
+
+### Using the Toggle Interface to Type in Your Language
+
+
+
+### Toggle Control
+
+ When you click in a text box (or text area) on the website, the **Toggle
+Control** *(left)* appears on the right of the box, indicating that it
+is possible to type in another language.
+
+ Hovering the mouse pointer over the KeymanWeb icon on the left-hand side
+of the Toggle control *(left)* will display the name of the language and
+keyboard which has been enabled for this site. Clicking on the icon will
+turn KeymanWeb on and enable you to type in this language. When
+KeymanWeb is active, there will be a solid border around the KeymanWeb
+icon (as in the image). To turn KeymanWeb off and return to typing in
+your default language, simply click on the icon once again.
+
+---
+**Note:** Clicking in a different text box or text area will not necessarily turn KeymanWeb off; this depends on how the website has been configured.
+
+---
+
+### On-Screen Keyboard
+
+
+
+The [On-Screen Keyboard](osk) *(left)* is a dynamic display showing the
+layout of the keyboard you are using. Clicking on the On-Screen Keyboard
+icon  on the right side of the Toggle
+Control turns the On-Screen Keyboard on and off. When the On-Screen
+keyboard is activated, this icon will have a solid border around it.
+However, to avoid obscuring the display, the On-Screen Keyboard will not
+actually be displayed unless you have clicked in a text box which
+incorporates KeymanWeb. For more information about using the On-Screen
+Keyboard, [click here](osk).
diff --git a/web/docs/engine/ui/ui-toolbar.md b/web/docs/engine/ui/ui-toolbar.md
new file mode 100644
index 0000000000..ad6787b15c
--- /dev/null
+++ b/web/docs/engine/ui/ui-toolbar.md
@@ -0,0 +1,68 @@
+---
+title: Using the KeymanWeb Toolbar Interface
+---
+## Toolbar Interface
+
+KeymanWeb's Toolbar user interface provides a very clear and visible
+method of incorporating a range of international languages and keyboards
+into a website. The toolbar is visible all the time, which makes it
+suitable for incorporating into a site's overall design.
+
+### Using the Toolbar Interface to Type in Your Language
+
+
+
+### Toolbar
+
+ If the **Toolbar** *(left)* is visible on a website, this is an
+indication that KeymanWeb has been set up to allow typing in one or more
+languages. The Toolbar is usually located above, inside or close to a
+text box or text area, though this will vary, depending on the site.
+
+### Selecting a Keyboard
+
+
+
+To begin typing in a different language, in which to type, click on the
+**Keyboards** dropdown menu on the Toolbar. A world map, divided into
+regions, will be displayed, with a list of available languages below
+*(right)*. Clicking on each region of the world will update the list so
+show which languages from that region can be used to type. Simply click
+on the name of the language you wish to use.
+
+For languages which have only a single keyboard available, a label
+giving the name of the selected language will be added to the Toolbar,
+and you can click in a suitable text box or text area and begin typing
+with that keyboard. To return to typing in English or your default
+language, click on the  icon near the
+centre of the Toolbar.
+
+
+
+For many languages, however, a variety of keyboard layouts is available,
+and more than one of these may have been incorporated into a website. In
+this case, beside the language name on the Toolbar, another dropdown
+menu will appear, with a list of keyboards to choose from (left). Click
+on the desired keyboard and then in the text box to begin typing using
+this keyboard.
+
+If a website incorporates several keyboards, it is possible to type in
+more than one language inside a single text box by returning to the
+menus on the Toolbar and selecting a different language and/or keyboard.
+As mentioned above, clicking on the 
+icon near the centre of the Toolbar will return you to typing in English
+or your default language.
+
+### On-Screen Keyboard
+
+
+
+The [On-Screen Keyboard](osk) *(left)* is a dynamic display showing the
+layout of the keyboard you are using. Clicking on the On-Screen Keyboard
+icon  on the right side of the Toolbar
+turns the On-Screen Keyboard on and off. When the On-Screen keyboard is
+activated, this icon will have a border around it, as shown. However, to
+avoid obscuring the display, the On-Screen Keyboard will not actually be
+displayed unless you have clicked in a text box which incorporates
+KeymanWeb. For more information about using the On-Screen Keyboard,
+[click here](osk).
diff --git a/web/docs/engine/whats-new.md b/web/docs/engine/whats-new.md
new file mode 100644
index 0000000000..49fa337fe0
--- /dev/null
+++ b/web/docs/engine/whats-new.md
@@ -0,0 +1,3 @@
+---
+title: What's New in KeymanWeb 18.0
+---