diff --git a/guacamole-common-js/src/main/webapp/modules/OnScreenKeyboard.js b/guacamole-common-js/src/main/webapp/modules/OnScreenKeyboard.js
index 71a5a0897..4a2e0e560 100644
--- a/guacamole-common-js/src/main/webapp/modules/OnScreenKeyboard.js
+++ b/guacamole-common-js/src/main/webapp/modules/OnScreenKeyboard.js
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Glyptodon LLC
+ * Copyright (C) 2015 Glyptodon LLC
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -23,110 +23,100 @@
 var Guacamole = Guacamole || {};
 
 /**
- * Dynamic on-screen keyboard. Given the URL to an XML keyboard layout file,
- * this object will download and use the XML to construct a clickable on-screen
- * keyboard with its own key events.
- * 
+ * Dynamic on-screen keyboard. Given the layout object for an on-screen
+ * keyboard, this object will construct a clickable on-screen keyboard with its
+ * own key events.
+ *
  * @constructor
- * @param {String} url The URL of an XML keyboard layout file.
+ * @param {Guacamole.OnScreenKeyboard.Layout} layout
+ *     The layout of the on-screen keyboard to display.
  */
-Guacamole.OnScreenKeyboard = function(url) {
-
-    var on_screen_keyboard = this;
+Guacamole.OnScreenKeyboard = function(layout) {
 
     /**
-     * State of all modifiers. This is the bitwise OR of all active modifier
-     * values.
-     * 
-     * @private
+     * Reference to this Guacamole.OnScreenKeyboard.
+     *
+     * @type Guacamole.OnScreenKeyboard
      */
-    var modifiers = 0;
+    var osk = this;
 
     /**
      * Map of currently-set modifiers to the keysym associated with their
      * original press. When the modifier is cleared, this keysym must be
      * released.
      *
+     * @private
      * @type Object.<String, Number>
      */
-    var modifier_keysyms = {};
+    var modifierKeysyms = {};
 
+    /**
+     * Map of all key names to their current pressed states. If a key is not
+     * pressed, it may not be in this map at all, but all pressed keys will
+     * have a corresponding mapping to true.
+     *
+     * @type Object.<String, Boolean>
+     */
+    var pressed = {};
+
+    /**
+     * All scalable elements which are part of the on-screen keyboard. Each
+     * scalable element is carefully controlled to ensure the interface layout
+     * and sizing remains constant, even on browsers that would otherwise
+     * experience rounding error due to unit conversions.
+     *
+     * @private
+     * @type ScaledElement[]
+     */
     var scaledElements = [];
-    
-    var modifier_masks = {};
-    var next_mask = 1;
 
     /**
-     * Adds a class to an element.
+     * Adds a CSS class to an element.
      * 
      * @private
      * @function
-     * @param {Element} element The element to add a class to.
-     * @param {String} classname The name of the class to add.
+     * @param {Element} element
+     *     The element to add a class to.
+     *
+     * @param {String} classname
+     *     The name of the class to add.
      */
-    var addClass;
+    var addClass = function addClass(element, classname) {
 
-    /**
-     * Removes a class from an element.
-     * 
-     * @private
-     * @function
-     * @param {Element} element The element to remove a class from.
-     * @param {String} classname The name of the class to remove.
-     */
-    var removeClass;
-
-    /**
-     * The number of mousemove events to require before re-enabling mouse
-     * event handling after receiving a touch event.
-     */
-    this.touchMouseThreshold = 3;
-
-    /**
-     * Counter of mouse events to ignore. This decremented by mousemove, and
-     * while non-zero, mouse events will have no effect.
-     * @private
-     */
-    var ignore_mouse = 0;
-
-    // Ignore all pending mouse events when touch events are the apparent source
-    function ignorePendingMouseEvents() { ignore_mouse = on_screen_keyboard.touchMouseThreshold; }
-
-    // If Node.classList is supported, implement addClass/removeClass using that
-    if (Node.classList) {
-
-        /** @ignore */
-        addClass = function(element, classname) {
+        // If classList supported, use that
+        if (element.classList)
             element.classList.add(classname);
-        };
-        
-        /** @ignore */
-        removeClass = function(element, classname) {
-            element.classList.remove(classname);
-        };
-        
-    }
 
-    // Otherwise, implement own
-    else {
-
-        /** @ignore */
-        addClass = function(element, classname) {
-
-            // Simply add new class
+        // Otherwise, simply append the class
+        else
             element.className += " " + classname;
 
-        };
-        
-        /** @ignore */
-        removeClass = function(element, classname) {
+    };
 
-            // Filter out classes with given name
+    /**
+     * Removes a CSS class from an element.
+     * 
+     * @private
+     * @function
+     * @param {Element} element
+     *     The element to remove a class from.
+     *
+     * @param {String} classname
+     *     The name of the class to remove.
+     */
+    var removeClass = function removeClass(element, classname) {
+
+        // If classList supported, use that
+        if (element.classList)
+            element.classList.remove(classname);
+
+        // Otherwise, manually filter out classes with given name
+        else {
             element.className = element.className.replace(/([^ ]+)[ ]*/g,
-                function(match, testClassname, spaces, offset, string) {
+                function removeMatchingClasses(match, testClassname) {
 
                     // If same class, remove
-                    if (testClassname == classname)
+                    if (testClassname === classname)
                         return "";
 
                     // Otherwise, allow
@@ -134,393 +124,282 @@ Guacamole.OnScreenKeyboard = function(url) {
                     
                 }
             );
-
-        };
-        
-    }
-
-    // Returns a unique power-of-two value for the modifier with the
-    // given name. The same value will be returned for the same modifier.
-    function getModifierMask(name) {
-        
-        var value = modifier_masks[name];
-        if (!value) {
-
-            // Get current modifier, advance to next
-            value = next_mask;
-            next_mask <<= 1;
-
-            // Store value of this modifier
-            modifier_masks[name] = value;
-
         }
 
-        return value;
-            
-    }
+    };
 
-    function ScaledElement(element, width, height, scaleFont) {
+    /**
+     * Counter of mouse events to ignore. This decremented by mousemove, and
+     * while non-zero, mouse events will have no effect.
+     *
+     * @private
+     * @type Number
+     */
+    var ignoreMouse = 0;
 
-        this.width = width;
-        this.height = height;
+    /**
+     * Ignores all pending mouse events when touch events are the apparent
+     * source. Mouse events are ignored until at least touchMouseThreshold
+     * mouse events occur without corresponding touch events.
+     *
+     * @private
+     */
+    var ignorePendingMouseEvents = function ignorePendingMouseEvents() {
+        ignoreMouse = osk.touchMouseThreshold;
+    };
 
+    /**
+     * An element whose dimensions are maintained according to an arbitrary
+     * scale. The conversion factor for these arbitrary units to pixels is
+     * provided later via a call to scale().
+     *
+     * @private
+     * @constructor
+     * @param {Element} element
+     *     The element whose scale should be maintained.
+     *
+     * @param {Number} width
+     *     The width of the element, in arbitrary units, relative to other
+     *     ScaledElements.
+     *
+     * @param {Number} height
+     *     The height of the element, in arbitrary units, relative to other
+     *     ScaledElements.
+     *     
+     * @param {Boolean} [scaleFont=false]
+     *     Whether the line height and font size should be scaled as well.
+     */
+    var ScaledElement = function ScaledElement(element, width, height, scaleFont) {
+
+        /**
+         * The width of this ScaledElement, in arbitrary units, relative to
+         * other ScaledElements.
+         *
+         * @type Number
+         */
+         this.width = width;
+
+        /**
+         * The height of this ScaledElement, in arbitrary units, relative to
+         * other ScaledElements.
+         *
+         * @type Number
+         */
+         this.height = height;
+ 
+        /**
+         * Resizes the associated element, updating its dimensions according to
+         * the given pixels per unit.
+         *
+         * @param {Number} pixels
+         *     The number of pixels to assign per arbitrary unit.
+         */
         this.scale = function(pixels) {
-            element.style.width      = (width  * pixels) + "px";
-            element.style.height     = (height * pixels) + "px";
 
+            // Scale element width/height
+            element.style.width  = (width  * pixels) + "px";
+            element.style.height = (height * pixels) + "px";
+
+            // Scale font, if requested
             if (scaleFont) {
                 element.style.lineHeight = (height * pixels) + "px";
                 element.style.fontSize   = pixels + "px";
             }
-        }
 
-    }
+        };
 
-    // For each child of element, call handler defined in next
-    function parseChildren(element, next) {
+    };
 
-        var children = element.childNodes;
-        for (var i=0; i<children.length; i++) {
+    /**
+     * Returns whether all modifiers having the given names are currently
+     * active.
+     *
+     * @param {String[]} names
+     *     The names of all modifiers to test.
+     *
+     * @returns {Boolean}
+     *     true if all specified modifiers are pressed, false otherwise.
+     */
+    var modifiersPressed = function modifiersPressed(names) {
 
-            // Get child node
-            var child = children[i];
+        // If any required modifiers are not pressed, return false
+        for (var i=0; i < names.length; i++) {
 
-            // Do not parse text nodes
-            if (!child.tagName)
-                continue;
-
-            // Get handler for node
-            var handler = next[child.tagName];
-
-            // Call handler if defined
-            if (handler)
-                handler(child);
-
-            // Throw exception if no handler
-            else
-                throw new Error(
-                      "Unexpected " + child.tagName
-                    + " within " + element.tagName
-                );
+            // Test whether current modifier is pressed
+            var name = names[i];
+            if (!(name in modifierKeysyms))
+                return false;
 
         }
 
-    }
+        // Otherwise, all required modifiers are pressed
+        return true;
+
+    };
+
+    /**
+     * Returns the single matching Key object associated with the key of the
+     * given name, where that Key object's requirements (such as pressed
+     * modifiers) are all currently satisfied.
+     *
+     * @param {String} keyName
+     *     The name of the key to retrieve.
+     *
+     * @returns {Guacamole.OnScreenKeyboard.Key}
+     *     The Key object associated with the given name, where that object's
+     *     requirements are all currently satisfied, or null if no such Key
+     *     can be found.
+     */
+    var getActiveKey = function getActiveKey(keyName) {
+
+        // Get key array for given name
+        var keys = osk.keys[keyName];
+        if (!keys)
+            return null;
+
+        // Find last matching key
+        for (var i = keys.length - 1; i >= 0; i--) {
+
+            // Get candidate key
+            var candidate = keys[i];
+
+            // If all required modifiers are pressed, use that key
+            if (modifiersPressed(candidate.requires))
+                return candidate;
+
+        }
+
+        // No valid key
+        return null;
+
+    };
+
+    /**
+     * Presses the key having the given name, updating the associated key
+     * element with the "guac-keyboard-pressed" CSS class. If the key is
+     * already pressed, this function has no effect.
+     *
+     * @param {String} keyName
+     *     The name of the key to press.
+     *
+     * @param {String} keyElement
+     *     The element associated with the given key.
+     */
+    var press = function press(keyName, keyElement) {
+
+        // Press key if not yet pressed
+        if (!pressed[keyName]) {
+
+            addClass(keyElement, "guac-keyboard-pressed");
+
+            // Get current key based on modifier state
+            var key = getActiveKey(keyName);
+
+            // Update modifier state
+            if (key.modifier) {
+
+                // Construct classname for modifier
+                var modifierClass = "guac-keyboard-modifier-" + getCSSName(key.modifier);
+
+                // Retrieve originally-pressed keysym, if modifier was already pressed
+                var originalKeysym = modifierKeysyms[key.modifier];
+
+                // Activate modifier if not pressed
+                if (!originalKeysym) {
+                    
+                    addClass(keyboard, modifierClass);
+                    modifierKeysyms[key.modifier] = key.keysym;
+                    
+                    // Send key event
+                    if (osk.onkeydown)
+                        osk.onkeydown(key.keysym);
+
+                }
+
+                // Deactivate if not pressed
+                else {
+
+                    removeClass(keyboard, modifierClass);
+                    delete modifierKeysyms[key.modifier];
+                    
+                    // Send key event
+                    if (osk.onkeyup)
+                        osk.onkeyup(originalKeysym);
+
+                }
+
+            }
+
+            // If not modifier, send key event now
+            else if (osk.onkeydown)
+                osk.onkeydown(key.keysym);
+
+            // Mark key as pressed
+            pressed[keyName] = true;
+
+        }
+
+    };
+
+    /**
+     * Releases the key having the given name, removing the
+     * "guac-keyboard-pressed" CSS class from the associated element. If the
+     * key is already released, this function has no effect.
+     *
+     * @param {String} keyName
+     *     The name of the key to release.
+     *
+     * @param {String} keyElement
+     *     The element associated with the given key.
+     */
+    var release = function release(keyName, keyElement) {
+
+        // Release key if currently pressed
+        if (pressed[keyName]) {
+
+            removeClass(keyElement, "guac-keyboard-pressed");
+
+            // Get current key based on modifier state
+            var key = getActiveKey(keyName);
+
+            // Send key event if not a modifier key
+            if (!key.modifier && osk.onkeyup)
+                osk.onkeyup(key.keysym);
+
+            // Mark key as released
+            pressed[keyName] = false;
+
+        }
+
+    };
 
     // Create keyboard
     var keyboard = document.createElement("div");
     keyboard.className = "guac-keyboard";
 
-    // Retrieve keyboard XML
-    var xmlhttprequest = new XMLHttpRequest();
-    xmlhttprequest.open("GET", url, false);
-    xmlhttprequest.send(null);
-
-    var xml = xmlhttprequest.responseXML;
-
-    if (xml) {
-
-        function parse_row(e) {
-            
-            var row = document.createElement("div");
-            row.className = "guac-keyboard-row";
-
-            parseChildren(e, {
-                
-                "column": function(e) {
-                    row.appendChild(parse_column(e));
-                },
-                
-                "gap": function parse_gap(e) {
-
-                    // Create element
-                    var gap = document.createElement("div");
-                    gap.className = "guac-keyboard-gap";
-
-                    // Set gap size
-                    var gap_units = 1;
-                    if (e.getAttribute("size"))
-                        gap_units = parseFloat(e.getAttribute("size"));
-
-                    scaledElements.push(new ScaledElement(gap, gap_units, gap_units));
-                    row.appendChild(gap);
-
-                },
-                
-                "key": function parse_key(e) {
-                    
-                    // Create element
-                    var key_element = document.createElement("div");
-                    key_element.className = "guac-keyboard-key";
-
-                    // Append class if specified
-                    if (e.getAttribute("class"))
-                        key_element.className += " " + e.getAttribute("class");
-
-                    // Position keys using container div
-                    var key_container_element = document.createElement("div");
-                    key_container_element.className = "guac-keyboard-key-container";
-                    key_container_element.appendChild(key_element);
-
-                    // Create key
-                    var key = new Guacamole.OnScreenKeyboard.Key();
-
-                    // Set key size
-                    var key_units = 1;
-                    if (e.getAttribute("size"))
-                        key_units = parseFloat(e.getAttribute("size"));
-
-                    key.size = key_units;
-
-                    parseChildren(e, {
-                        "cap": function parse_cap(e) {
-
-                            // TODO: Handle "sticky" attribute
-                            
-                            // Get content of key cap
-                            var content = e.textContent || e.text;
-
-                            // If read as blank, assume cap is a single space.
-                            if (content.length == 0)
-                                content = " ";
-                            
-                            // Get keysym
-                            var real_keysym = null;
-                            if (e.getAttribute("keysym"))
-                                real_keysym = parseInt(e.getAttribute("keysym"));
-
-                            // If no keysym specified, try to get from key content
-                            else if (content.length == 1) {
-
-                                var charCode = content.charCodeAt(0);
-                                if (charCode >= 0x0000 && charCode <= 0x00FF)
-                                    real_keysym = charCode;
-                                else if (charCode >= 0x0100 && charCode <= 0x10FFFF)
-                                    real_keysym = 0x01000000 | charCode;
-
-                            }
-                            
-                            // Create cap
-                            var cap = new Guacamole.OnScreenKeyboard.Cap(content, real_keysym);
-
-                            if (e.getAttribute("modifier"))
-                                cap.modifier = e.getAttribute("modifier");
-                            
-                            // Create cap element
-                            var cap_element = document.createElement("div");
-                            cap_element.className = "guac-keyboard-cap";
-                            cap_element.textContent = content;
-                            key_element.appendChild(cap_element);
-
-                            // Append class if specified
-                            if (e.getAttribute("class"))
-                                cap_element.className += " " + e.getAttribute("class");
-
-                            // Get modifier value
-                            var modifierValue = 0;
-                            if (e.getAttribute("if")) {
-
-                                // Get modifier value for specified comma-delimited
-                                // list of required modifiers.
-                                var requirements = e.getAttribute("if").split(",");
-                                for (var i=0; i<requirements.length; i++) {
-                                    modifierValue |= getModifierMask(requirements[i]);
-                                    addClass(cap_element, "guac-keyboard-requires-" + requirements[i]);
-                                    addClass(key_element, "guac-keyboard-uses-" + requirements[i]);
-                                }
-
-                            }
-
-                            // Store cap
-                            key.modifierMask |= modifierValue;
-                            key.caps[modifierValue] = cap;
-
-                        }
-                    });
-
-                    scaledElements.push(new ScaledElement(key_container_element, key_units, 1, true));
-                    row.appendChild(key_container_element);
-
-                    // Set up click handler for key
-                    function press() {
-
-                        // Press key if not yet pressed
-                        if (!key.pressed) {
-
-                            addClass(key_element, "guac-keyboard-pressed");
-
-                            // Get current cap based on modifier state
-                            var cap = key.getCap(modifiers);
-
-                            // Update modifier state
-                            if (cap.modifier) {
-
-                                // Construct classname for modifier
-                                var modifierClass = "guac-keyboard-modifier-" + cap.modifier;
-                                var modifierMask = getModifierMask(cap.modifier);
-
-                                // Toggle modifier state
-                                modifiers ^= modifierMask;
-
-                                // Activate modifier if pressed
-                                if (modifiers & modifierMask) {
-                                    
-                                    addClass(keyboard, modifierClass);
-                                    modifier_keysyms[cap.modifier] = cap.keysym;
-                                    
-                                    // Send key event
-                                    if (on_screen_keyboard.onkeydown && cap.keysym)
-                                        on_screen_keyboard.onkeydown(cap.keysym);
-
-                                }
-
-                                // Deactivate if not pressed
-                                else {
-
-                                    var original_keysym = modifier_keysyms[cap.modifier];
-
-                                    removeClass(keyboard, modifierClass);
-                                    delete modifier_keysyms[cap.modifier];
-                                    
-                                    // Send key event
-                                    if (on_screen_keyboard.onkeyup && original_keysym)
-                                        on_screen_keyboard.onkeyup(original_keysym);
-
-                                }
-
-                            }
-
-                            // If not modifier, send key event now
-                            else if (on_screen_keyboard.onkeydown && cap.keysym)
-                                on_screen_keyboard.onkeydown(cap.keysym);
-
-                            // Mark key as pressed
-                            key.pressed = true;
-
-                        }
-
-                    }
-
-                    function release() {
-
-                        // Release key if currently pressed
-                        if (key.pressed) {
-
-                            // Get current cap based on modifier state
-                            var cap = key.getCap(modifiers);
-
-                            removeClass(key_element, "guac-keyboard-pressed");
-
-                            // Send key event if not a modifier key
-                            if (!cap.modifier && on_screen_keyboard.onkeyup && cap.keysym)
-                                on_screen_keyboard.onkeyup(cap.keysym);
-
-                            // Mark key as released
-                            key.pressed = false;
-
-                        }
-
-                    }
-
-                    function touchPress(e) {
-                        e.preventDefault();
-                        ignore_mouse = on_screen_keyboard.touchMouseThreshold;
-                        press();
-                    }
-
-                    function touchRelease(e) {
-                        e.preventDefault();
-                        ignore_mouse = on_screen_keyboard.touchMouseThreshold;
-                        release();
-                    }
-
-                    function mousePress(e) {
-                        e.preventDefault();
-                        if (ignore_mouse == 0)
-                            press();
-                    }
-
-                    function mouseRelease(e) {
-                        e.preventDefault();
-                        if (ignore_mouse == 0)
-                            release();
-                    }
-
-                    key_element.addEventListener("touchstart", touchPress, true);
-                    key_element.addEventListener("touchend",   touchRelease, true);
-
-                    key_element.addEventListener("mousedown", mousePress,   true);
-                    key_element.addEventListener("mouseup",   mouseRelease, true);
-                    key_element.addEventListener("mouseout",  mouseRelease, true);
-
-                }
-                
-            });
-
-            return row;
-
-        }
-
-        function parse_column(e) {
-            
-            var col = document.createElement("div");
-            col.className = "guac-keyboard-column";
-
-            if (col.getAttribute("align"))
-                col.style.textAlign = col.getAttribute("align");
-
-            // Columns can only contain rows
-            parseChildren(e, {
-                "row": function(e) {
-                    col.appendChild(parse_row(e));
-                }
-            });
-
-            return col;
-
-        }
-
-        // Parse document
-        var keyboard_element = xml.documentElement;
-        if (keyboard_element.tagName != "keyboard")
-            throw new Error("Root element must be keyboard");
-
-        // Get attributes
-        if (!keyboard_element.getAttribute("size"))
-            throw new Error("size attribute is required for keyboard");
-        
-        var keyboard_size = parseFloat(keyboard_element.getAttribute("size"));
-        
-        parseChildren(keyboard_element, {
-            
-            "row": function(e) {
-                keyboard.appendChild(parse_row(e));
-            },
-            
-            "column": function(e) {
-                keyboard.appendChild(parse_column(e));
-            }
-            
-        });
-
-    }
-
     // Do not allow selection or mouse movement to propagate/register.
     keyboard.onselectstart =
     keyboard.onmousemove   =
     keyboard.onmouseup     =
-    keyboard.onmousedown   =
-    function(e) {
+    keyboard.onmousedown   = function handleMouseEvents(e) {
 
         // If ignoring events, decrement counter
-        if (ignore_mouse)
-            ignore_mouse--;
+        if (ignoreMouse)
+            ignoreMouse--;
 
         e.stopPropagation();
         return false;
 
     };
 
+    /**
+     * The number of mousemove events to require before re-enabling mouse
+     * event handling after receiving a touch event.
+     *
+     * @type Number
+     */
+    this.touchMouseThreshold = 3;
+
     /**
      * Fired whenever the user presses a key on this Guacamole.OnScreenKeyboard.
      * 
@@ -535,7 +414,14 @@ Guacamole.OnScreenKeyboard = function(url) {
      * @event
      * @param {Number} keysym The keysym of the key being released.
      */
-    this.onkeyup   = null;
+    this.onkeyup = null;
+
+    /**
+     * The keyboard layout provided at time of construction.
+     *
+     * @type Guacamole.OnScreenKeyboard.Layout
+     */
+    this.layout = new Guacamole.OnScreenKeyboard.Layout(layout);
 
     /**
      * Returns the element containing the entire on-screen keyboard.
@@ -556,90 +442,495 @@ Guacamole.OnScreenKeyboard = function(url) {
     this.resize = function(width) {
 
         // Get pixel size of a unit
-        var unit = Math.floor(width * 10 / keyboard_size) / 10;
+        var unit = Math.floor(width * 10 / osk.layout.width) / 10;
 
         // Resize all scaled elements
         for (var i=0; i<scaledElements.length; i++) {
             var scaledElement = scaledElements[i];
-            scaledElement.scale(unit)
+            scaledElement.scale(unit);
         }
 
     };
 
-};
-
-/**
- * Basic representation of a single key of a keyboard. Each key has a set of
- * caps associated with tuples of modifiers. The cap determins what happens
- * when a key is pressed, while it is the state of modifier keys that determines
- * what cap is in effect on any particular key.
- * 
- * @constructor
- */
-Guacamole.OnScreenKeyboard.Key = function() {
-
-    var key = this;
-
     /**
-     * Whether this key is currently pressed.
+     * Given the name of a key and its corresponding definition, which may be
+     * an array of keys objects, a number (keysym), a string (key title), or a
+     * single key object, returns an array of key objects, deriving any missing
+     * properties as needed, and ensuring the key name is defined.
+     *
+     * @private
+     * @param {String} name
+     *     The name of the key being coerced into an array of Key objects.
+     *
+     * @param {Number|String|Guacamole.OnScreenKeyboard.Key|Guacamole.OnScreenKeyboard.Key[]} object
+     *     The object defining the behavior of the key having the given name,
+     *     which may be the title of the key (a string), the keysym (a number),
+     *     a single Key object, or an array of Key objects.
+     *     
+     * @returns {Guacamole.OnScreenKeyboard.Key[]}
+     *     An array of all keys associated with the given name.
      */
-    this.pressed = false;
+    var asKeyArray = function asKeyArray(name, object) {
 
-    /**
-     * Width of the key, relative to the size of the keyboard.
-     */
-    this.size = 1;
+        // If already an array, just coerce into a true Key[] 
+        if (object instanceof Array) {
+            var keys = [];
+            for (var i=0; i < object.length; i++) {
+                keys.push(new Guacamole.OnScreenKeyboard.Key(object[i], name));
+            }
+            return keys;
+        }
 
-    /**
-     * An associative map of all caps by modifier.
-     */
-    this.caps = {};
+        // Derive key object from keysym if that's all we have
+        if (typeof object === 'number') {
+            return [new Guacamole.OnScreenKeyboard.Key({
+                name   : name,
+                keysym : object
+            })];
+        }
 
-    /**
-     * Bit mask with all modifiers that affect this key set.
-     */
-    this.modifierMask = 0;
+        // Derive key object from title if that's all we have
+        if (typeof object === 'string') {
+            return [new Guacamole.OnScreenKeyboard.Key({
+                name  : name,
+                title : object
+            })];
+        }
+
+        // Otherwise, assume it's already a key object, just not an array
+        return [new Guacamole.OnScreenKeyboard.Key(object, name)];
 
-    /**
-     * Given the bitwise OR of all active modifiers, returns the key cap
-     * which applies.
-     */
-    this.getCap = function(modifier) {
-        return key.caps[modifier & key.modifierMask];
     };
 
+    /**
+     * Converts the rather forgiving key mapping allowed by
+     * Guacamole.OnScreenKeyboard.Layout into a rigorous mapping of key name
+     * to key definition, where the key definition is always an array of Key
+     * objects.
+     *
+     * @private
+     * @param {Object.<String, Number|String|Guacamole.OnScreenKeyboard.Key|Guacamole.OnScreenKeyboard.Key[]>} keys
+     *     A mapping of key name to key definition, where the key definition is
+     *     the title of the key (a string), the keysym (a number), a single
+     *     Key object, or an array of Key objects.
+     *
+     * @returns {Object.<String, Guacamole.OnScreenKeyboard.Key[]>}
+     *     A more-predictable mapping of key name to key definition, where the
+     *     key definition is always simply an array of Key objects.
+     */
+    var getKeys = function getKeys(keys) {
+
+        var keyArrays = {};
+
+        // Coerce all keys into individual key arrays
+        for (var name in layout.keys) {
+            keyArrays[name] = asKeyArray(name, keys[name]);
+        }
+
+        return keyArrays;
+
+    };
+
+    /**
+     * Map of all key names to their corresponding set of keys. Each key name
+     * may correspond to multiple keys due to the effect of modifiers.
+     *
+     * @type Object.<String, Guacamole.OnScreenKeyboard.Key[]>
+     */
+    this.keys = getKeys(layout.keys);
+
+    /**
+     * Given an arbitrary string representing the name of some component of the
+     * on-screen keyboard, returns a string formatted for use as a CSS class
+     * name. The result will be lowercase. Word boundaries previously denoted
+     * by CamelCase will be replaced by individual hyphens, as will all
+     * contiguous non-alphanumeric characters.
+     *
+     * @private
+     * @param {String} name
+     *     An arbitrary string representing the name of some component of the
+     *     on-screen keyboard.
+     *
+     * @returns {String}
+     *     A string formatted for use as a CSS class name.
+     */
+    var getCSSName = function getCSSName(name) {
+
+        // Convert name from possibly-CamelCase to hyphenated lowercase
+        var cssName = name
+               .replace(/([a-z])([A-Z])/g, '$1-$2')
+               .replace(/[^A-Za-z0-9]+/g, '-')
+               .toLowerCase();
+
+        return cssName;
+
+    };
+
+    /**
+     * Appends DOM elements to the given element as dictated by the layout
+     * structure object provided. If a name is provided, an additional CSS
+     * class, prepended with "guac-keyboard-", will be added to the top-level
+     * element.
+     * 
+     * If the layout structure object is an array, all elements within that
+     * array will be recursively appended as children of a group, and the
+     * top-level element will be given the CSS class "guac-keyboard-group".
+     *
+     * If the layout structure object is an object, all properties within that
+     * object will be recursively appended as children of a group, and the
+     * top-level element will be given the CSS class "guac-keyboard-group". The
+     * name of each property will be applied as the name of each child object
+     * for the sake of CSS. Each property will be added in sorted order.
+     *
+     * If the layout structure object is a string, the key having that name
+     * will be appended. The key will be given the CSS class
+     * "guac-keyboard-key" and "guac-keyboard-key-NAME", where NAME is the name
+     * of the key. If the name of the key is a single character, this will
+     * first be transformed into the C-style hexadecimal literal for the
+     * Unicode codepoint of that character. For example, the key "A" would
+     * become "guac-keyboard-key-0x41".
+     * 
+     * If the layout structure object is a number, a gap of that size will be
+     * inserted. The gap will be given the CSS class "guac-keyboard-gap", and
+     * will be scaled according to the same size units as each key.
+     *
+     * @private
+     * @param {Element} element
+     *     The element to append elements to.
+     *
+     * @param {Array|Object|String|Number} object
+     *     The layout structure object to use when constructing the elements to
+     *     append.
+     *
+     * @param {String} [name]
+     *     The name of the top-level element being appended, if any.
+     */
+    var appendElements = function appendElements(element, object, name) {
+
+        var i;
+
+        // Create div which will become the group or key
+        var div = document.createElement('div');
+
+        // Add class based on name, if name given
+        if (name)
+            addClass(div, 'guac-keyboard-' + getCSSName(name));
+
+        // If an array, append each element
+        if (object instanceof Array) {
+
+            // Add group class
+            addClass(div, 'guac-keyboard-group');
+
+            // Append all elements of array
+            for (i=0; i < object.length; i++)
+                appendElements(div, object[i]);
+
+        }
+
+        // If an object, append each property value
+        else if (object instanceof Object) {
+
+            // Add group class
+            addClass(div, 'guac-keyboard-group');
+
+            // Append all children, sorted by name
+            var names = Object.keys(object).sort();
+            for (i=0; i < names.length; i++) {
+                var name = names[i];
+                appendElements(div, object[name], name);
+            }
+
+        }
+
+        // If a number, create as a gap 
+        else if (typeof object === 'number') {
+
+            // Add gap class
+            addClass(div, 'guac-keyboard-gap');
+
+            // Maintain scale
+            scaledElements.push(new ScaledElement(div, object, object));
+
+        }
+
+        // If a string, create as a key
+        else if (typeof object === 'string') {
+
+            // If key name is only one character, use codepoint for name
+            var keyName = object;
+            if (keyName.length === 1)
+                keyName = '0x' + keyName.charCodeAt(0).toString(16);
+
+            // Add key container class
+            addClass(div, 'guac-keyboard-key-container');
+
+            // Create key element which will contain all possible caps
+            var keyElement = document.createElement('div');
+            keyElement.className = 'guac-keyboard-key '
+                                 + 'guac-keyboard-key-' + getCSSName(keyName);
+
+            // Add all associated keys as caps within DOM
+            var keys = osk.keys[object];
+            if (keys) {
+                for (i=0; i < keys.length; i++) {
+
+                    // Get current key
+                    var key = keys[i];
+
+                    // Create cap element for key
+                    var capElement = document.createElement('div');
+                    capElement.className   = 'guac-keyboard-cap';
+                    capElement.textContent = key.title;
+
+                    // Add classes for any requirements
+                    for (var j=0; j < key.requires.length; j++) {
+                        var requirement = key.requires[j];
+                        addClass(capElement, 'guac-keyboard-requires-' + getCSSName(requirement));
+                        addClass(keyElement, 'guac-keyboard-uses-'     + getCSSName(requirement));
+                    }
+
+                    // Add cap to key within DOM
+                    keyElement.appendChild(capElement);
+
+                }
+            }
+
+            // Add key to DOM, maintain scale
+            div.appendChild(keyElement);
+            scaledElements.push(new ScaledElement(div, osk.layout.keyWidths[object] || 1, 1, true));
+
+            /**
+             * Handles a touch event which results in the pressing of an OSK
+             * key. Touch events will result in mouse events being ignored for
+             * touchMouseThreshold events.
+             *
+             * @param {TouchEvent} e
+             *     The touch event being handled.
+             */
+            var touchPress = function touchPress(e) {
+                e.preventDefault();
+                ignoreMouse = osk.touchMouseThreshold;
+                press(object, keyElement);
+            };
+
+            /**
+             * Handles a touch event which results in the release of an OSK
+             * key. Touch events will result in mouse events being ignored for
+             * touchMouseThreshold events.
+             *
+             * @param {TouchEvent} e
+             *     The touch event being handled.
+             */
+            var touchRelease = function touchRelease(e) {
+                e.preventDefault();
+                ignoreMouse = osk.touchMouseThreshold;
+                release(object, keyElement);
+            };
+
+            /**
+             * Handles a mouse event which results in the pressing of an OSK
+             * key. If mouse events are currently being ignored, this handler
+             * does nothing.
+             *
+             * @param {MouseEvent} e
+             *     The touch event being handled.
+             */
+            var mousePress = function mousePress(e) {
+                e.preventDefault();
+                if (ignoreMouse === 0)
+                    press(object, keyElement);
+            };
+
+            /**
+             * Handles a mouse event which results in the release of an OSK
+             * key. If mouse events are currently being ignored, this handler
+             * does nothing.
+             *
+             * @param {MouseEvent} e
+             *     The touch event being handled.
+             */
+            var mouseRelease = function mouseRelease(e) {
+                e.preventDefault();
+                if (ignoreMouse === 0)
+                    release(object, keyElement);
+            };
+
+            // Handle touch events on key
+            keyElement.addEventListener("touchstart", touchPress,   true);
+            keyElement.addEventListener("touchend",   touchRelease, true);
+
+            // Handle mouse events on key
+            keyElement.addEventListener("mousedown", mousePress,   true);
+            keyElement.addEventListener("mouseup",   mouseRelease, true);
+            keyElement.addEventListener("mouseout",  mouseRelease, true);
+
+        } // end if object is key name
+
+        // Add newly-created group/key
+        element.appendChild(div);
+
+    };
+
+    // Create keyboard layout in DOM
+    appendElements(keyboard, layout.layout);
+
 };
 
 /**
- * Basic representation of a cap of a key. The cap is the visible part of a key
- * and determines the active behavior of a key when pressed. The state of all
- * modifiers on the keyboard determines the active cap for all keys, thus
- * each cap is associated with a set of modifiers.
- * 
+ * Represents an entire on-screen keyboard layout, including all available
+ * keys, their behaviors, and their relative position and sizing.
+ *
  * @constructor
- * @param {String} text The text to be displayed within this cap.
- * @param {Number} keysym The keysym this cap sends when its associated key is
- *                        pressed or released.
- * @param {String} modifier The modifier represented by this cap.
+ * @param {Guacamole.OnScreenKeyboard.Layout|Object} template
+ *     The object whose identically-named properties will be used to initialize
+ *     the properties of this layout.
  */
-Guacamole.OnScreenKeyboard.Cap = function(text, keysym, modifier) {
-    
-    /**
-     * Modifier represented by this keycap
-     */
-    this.modifier = null;
-    
-    /**
-     * The text to be displayed within this keycap
-     */
-    this.text = text;
+Guacamole.OnScreenKeyboard.Layout = function(template) {
 
     /**
-     * The keysym this cap sends when its associated key is pressed/released
+     * The language of keyboard layout, such as "en_US". This property is for
+     * informational purposes only, but it is recommend to conform to the
+     * [language code]_[country code] format.
+     *
+     * @type String
      */
-    this.keysym = keysym;
+    this.language = template.language;
+
+    /**
+     * The type of keyboard layout, such as "qwerty". This property is for
+     * informational purposes only, and does not conform to any standard.
+     *
+     * @type String
+     */
+    this.type = template.type;
+
+    /**
+     * Map of key name to corresponding keysym, title, or key object. If only
+     * the keysym or title is provided, the key object will be created
+     * implicitly. In all cases, the name property of the key object will be
+     * taken from the name given in the mapping.
+     *
+     * @type Object.<String, Number|String|Guacamole.OnScreenKeyboard.Key|Guacamole.OnScreenKeyboard.Key[]>
+     */
+    this.keys = template.keys;
+
+    /**
+     * Arbitrarily nested, arbitrarily grouped key names. The contents of the
+     * layout will be traversed to produce an identically-nested grouping of
+     * keys in the DOM tree. All strings will be transformed into their
+     * corresponding sets of keys, while all objects and arrays will be
+     * transformed into named groups and anonymous groups respectively. Any
+     * numbers present will be transformed into gaps of that size, scaled
+     * according to the same units as each key.
+     *
+     * @type Object
+     */
+    this.layout = template.layout;
+
+    /**
+     * The width of the entire keyboard, in arbitrary units. The width of each
+     * key is relative to this width, as both width values are assumed to be in
+     * the same units. The conversion factor between these units and pixels is
+     * derived later via a call to resize() on the Guacamole.OnScreenKeyboard.
+     *
+     * @type Number
+     */
+    this.width = template.width;
+
+    /**
+     * The width of each key, in arbitrary units, relative to other keys in
+     * this layout. The true pixel size of each key will be determined by the
+     * overall size of the keyboard. If not defined here, the width of each
+     * key will default to 1.
+     *
+     * @type Object.<String, Number>
+     */
+    this.keyWidths = template.keyWidths || {};
+
+};
+
+/**
+ * Represents a single key, or a single possible behavior of a key. Each key
+ * on the on-screen keyboard must have at least one associated
+ * Guacamole.OnScreenKeyboard.Key, whether that key is explicitly defined or
+ * implied, and may have multiple Guacamole.OnScreenKeyboard.Key if behavior
+ * depends on modifier states.
+ *
+ * @constructor
+ * @param {Guacamole.OnScreenKeyboard.Key|Object} template
+ *     The object whose identically-named properties will be used to initialize
+ *     the properties of this key.
+ *     
+ * @param {String} [name]
+ *     The name to use instead of any name provided within the template, if
+ *     any. If omitted, the name within the template will be used, assuming the
+ *     template contains a name.
+ */
+Guacamole.OnScreenKeyboard.Key = function(template, name) {
+
+    /**
+     * The unique name identifying this key within the keyboard layout.
+     *
+     * @type String
+     */
+    this.name = name || template.name;
+
+    /**
+     * The human-readable title that will be displayed to the user within the
+     * key. If not provided, this will be derived from the key name.
+     *
+     * @type String
+     */
+    this.title = template.title || this.name;
+
+    /**
+     * The keysym to be pressed/released when this key is pressed/released. If
+     * not provided, this will be derived from the title if the title is a
+     * single character.
+     *
+     * @type Number
+     */
+    this.keysym = template.keysym || (function deriveKeysym(title) {
+
+        // Do not derive keysym if title is not exactly one character
+        if (!title || title.length !== 1)
+            return null;
+
+        // For characters between U+0000 and U+00FF, the keysym is the codepoint
+        var charCode = title.charCodeAt(0);
+        if (charCode >= 0x0000 && charCode <= 0x00FF)
+            return charCode;
+
+        // For characters between U+0100 and U+10FFFF, the keysym is the codepoint or'd with 0x01000000
+        if (charCode >= 0x0100 && charCode <= 0x10FFFF)
+            return 0x01000000 | charCode;
+
+        // Unable to derive keysym
+        return null;
+
+    })(this.title);
+
+    /**
+     * The name of the modifier set when the key is pressed and cleared when
+     * this key is released, if any. The names of modifiers are distinct from
+     * the names of keys; both the "RightShift" and "LeftShift" keys may set
+     * the "shift" modifier, for example. By default, the key will affect no
+     * modifiers.
+     * 
+     * @type String
+     */
+    this.modifier = template.modifier;
+
+    /**
+     * An array containing the names of each modifier required for this key to
+     * have an effect. For example, a lowercase letter may require nothing,
+     * while an uppercase letter would require "shift", assuming the Shift key
+     * is named "shift" within the layout. By default, the key will require
+     * no modifiers.
+     *
+     * @type String[]
+     */
+    this.requires = template.requires || [];
 
-    // Set modifier if provided
-    if (modifier) this.modifier = modifier;
-    
 };
diff --git a/guacamole/src/main/webapp/app/osk/directives/guacOsk.js b/guacamole/src/main/webapp/app/osk/directives/guacOsk.js
index decb06f8d..bca9bc9b4 100644
--- a/guacamole/src/main/webapp/app/osk/directives/guacOsk.js
+++ b/guacamole/src/main/webapp/app/osk/directives/guacOsk.js
@@ -40,8 +40,13 @@ angular.module('osk').directive('guacOsk', [function guacOsk() {
         },
 
         templateUrl: 'app/osk/templates/guacOsk.html',
-        controller: ['$scope', '$rootScope', '$window', '$element',
-            function guacOsk($scope, $rootScope, $window, $element) {
+        controller: ['$scope', '$injector', '$element',
+            function guacOsk($scope, $injector, $element) {
+
+            // Required services
+            var $http        = $injector.get('$http');
+            var $rootScope   = $injector.get('$rootScope');
+            var cacheService = $injector.get('cacheService');
 
             /**
              * The current on-screen keyboard, if any.
@@ -67,7 +72,7 @@ angular.module('osk').directive('guacOsk', [function guacOsk() {
             };
 
             // Set layout whenever URL changes
-            $scope.$watch("layout", function setLayout(layout) {
+            $scope.$watch("layout", function setLayout(url) {
 
                 // Remove current keyboard
                 if (keyboard) {
@@ -76,24 +81,40 @@ angular.module('osk').directive('guacOsk', [function guacOsk() {
                 }
 
                 // Load new keyboard
-                if (layout) {
+                if (url) {
 
-                    // Add OSK element
-                    keyboard = new Guacamole.OnScreenKeyboard(layout);
-                    main.appendChild(keyboard.getElement());
+                    // Retrieve layout JSON
+                    $http({
+                        cache   : cacheService.languages,
+                        method  : 'GET',
+                        url     : url
+                    })
 
-                    // Init size
-                    keyboard.resize(main.offsetWidth);
+                    // Build OSK with retrieved layout
+                    .success(function layoutRetrieved(layout) {
 
-                    // Broadcast keydown for each key pressed
-                    keyboard.onkeydown = function(keysym) {
-                        $rootScope.$broadcast('guacSyntheticKeydown', keysym);
-                    };
-                    
-                    // Broadcast keydown for each key released 
-                    keyboard.onkeyup = function(keysym) {
-                        $rootScope.$broadcast('guacSyntheticKeyup', keysym);
-                    };
+                        // Abort if the layout changed while we were waiting for a response
+                        if ($scope.layout !== url)
+                            return;
+
+                        // Add OSK element
+                        keyboard = new Guacamole.OnScreenKeyboard(layout);
+                        main.appendChild(keyboard.getElement());
+
+                        // Init size
+                        keyboard.resize(main.offsetWidth);
+
+                        // Broadcast keydown for each key pressed
+                        keyboard.onkeydown = function(keysym) {
+                            $rootScope.$broadcast('guacSyntheticKeydown', keysym);
+                        };
+                        
+                        // Broadcast keydown for each key released 
+                        keyboard.onkeyup = function(keysym) {
+                            $rootScope.$broadcast('guacSyntheticKeyup', keysym);
+                        };
+
+                    });
 
                 }
 
diff --git a/guacamole/src/main/webapp/app/osk/styles/osk.css b/guacamole/src/main/webapp/app/osk/styles/osk.css
index ad131bed4..f61ac6f9d 100644
--- a/guacamole/src/main/webapp/app/osk/styles/osk.css
+++ b/guacamole/src/main/webapp/app/osk/styles/osk.css
@@ -36,8 +36,15 @@
     vertical-align: middle;
 }
 
+.guac-keyboard,
+.guac-keyboard * {
+    overflow: hidden;
+    white-space: nowrap;
+}
+
 .guac-keyboard .guac-keyboard-key-container {
     display: inline-block;
+    margin: 0.05em;
 }
 
 .guac-keyboard .guac-keyboard-key {
@@ -51,7 +58,6 @@
 
 .guac-keyboard .guac-keyboard-cap {
     color: white;
-    font-family: sans-serif;
     font-size: 50%;
     font-weight: lighter;
     text-align: center;
@@ -67,26 +73,26 @@
     border-color: #666;
 }
 
-.guac-keyboard.guac-keyboard-modifier-shift .guac-keyboard-key.shift,
-.guac-keyboard.guac-keyboard-modifier-numsym .guac-keyboard-key.numsym {
+/* Active shift */
+.guac-keyboard.guac-keyboard-modifier-shift .guac-keyboard-key-rshift,
+.guac-keyboard.guac-keyboard-modifier-shift .guac-keyboard-key-lshift,
+
+/* Active ctrl */
+.guac-keyboard.guac-keyboard-modifier-control .guac-keyboard-key-rctrl,
+.guac-keyboard.guac-keyboard-modifier-control .guac-keyboard-key-lctrl,
+
+/* Active alt */
+.guac-keyboard.guac-keyboard-modifier-alt .guac-keyboard-key-ralt,
+.guac-keyboard.guac-keyboard-modifier-alt .guac-keyboard-key-lalt,
+
+/* Active caps */
+.guac-keyboard.guac-keyboard-modifier-caps .guac-keyboard-key-caps {
     background: #882;
     border-color: #DD4;
 }
 
-.guac-keyboard.guac-keyboard-modifier-control .guac-keyboard-key.control,
-.guac-keyboard.guac-keyboard-modifier-numsym .guac-keyboard-key.numsym {
-    background: #882;
-    border-color: #DD4;
-}
-
-.guac-keyboard.guac-keyboard-modifier-alt .guac-keyboard-key.alt,
-.guac-keyboard.guac-keyboard-modifier-numsym .guac-keyboard-key.numsym {
-    background: #882;
-    border-color: #DD4;
-}
-
-.guac-keyboard.guac-keyboard-modifier-super .guac-keyboard-key.super,
-.guac-keyboard.guac-keyboard-modifier-numsym .guac-keyboard-key.numsym {
+.guac-keyboard.guac-keyboard-modifier-super .guac-keyboard-key-super,
+.guac-keyboard.guac-keyboard-modifier-super .guac-keyboard-key-menu {
     background: #882;
     border-color: #DD4;
 }
@@ -97,16 +103,54 @@
     border-style: inset;
 }
 
-.guac-keyboard .guac-keyboard-row {
+.guac-keyboard .guac-keyboard-group {
     line-height: 0;
 }
 
-.guac-keyboard .guac-keyboard-column {
+.guac-keyboard .guac-keyboard-group.guac-keyboard-alpha,
+.guac-keyboard .guac-keyboard-group.guac-keyboard-movement {
     display: inline-block;
     text-align: center;
     vertical-align: top;
 }
 
+.guac-keyboard .guac-keyboard-group.guac-keyboard-main {
+
+    /* IE10 */
+    display: -ms-flexbox;
+    -ms-flex-align: stretch;
+    -ms-flex-direction: row;
+
+    /* Ancient Mozilla */
+    display: -moz-box;
+    -moz-box-align: stretch;
+    -moz-box-orient: horizontal;
+    
+    /* Ancient WebKit */
+    display: -webkit-box;
+    -webkit-box-align: stretch;
+    -webkit-box-orient: horizontal;
+
+    /* Old WebKit */
+    display: -webkit-flex;
+    -webkit-align-items: stretch;
+    -webkit-flex-direction: row;
+
+    /* W3C */
+    display: flex;
+    align-items: stretch;
+    flex-direction: row;
+
+}
+
+.guac-keyboard .guac-keyboard-group.guac-keyboard-movement {
+    -ms-flex: 1 1 auto;
+    -moz-box-flex: 1;
+    -webkit-box-flex: 1;
+    -webkit-flex: 1 1 auto;
+    flex: 1 1 auto;
+}
+
 .guac-keyboard .guac-keyboard-gap {
     display: inline-block;
 }
@@ -115,9 +159,6 @@
 .guac-keyboard:not(.guac-keyboard-modifier-caps)
 .guac-keyboard-cap.guac-keyboard-requires-caps,
 
-.guac-keyboard:not(.guac-keyboard-modifier-numsym)
-.guac-keyboard-cap.guac-keyboard-requires-numsym,
-
 .guac-keyboard:not(.guac-keyboard-modifier-shift)
 .guac-keyboard-cap.guac-keyboard-requires-shift,
 
@@ -127,10 +168,6 @@
 .guac-keyboard-key.guac-keyboard-uses-shift
 .guac-keyboard-cap:not(.guac-keyboard-requires-shift),
 
-.guac-keyboard.guac-keyboard-modifier-numsym
-.guac-keyboard-key.guac-keyboard-uses-numsym
-.guac-keyboard-cap:not(.guac-keyboard-requires-numsym),
-
 .guac-keyboard.guac-keyboard-modifier-caps
 .guac-keyboard-key.guac-keyboard-uses-caps
 .guac-keyboard-cap:not(.guac-keyboard-requires-caps) {
diff --git a/guacamole/src/main/webapp/layouts/en-us-qwerty-mobile.xml b/guacamole/src/main/webapp/layouts/en-us-qwerty-mobile.xml
deleted file mode 100644
index a61ec4c2b..000000000
--- a/guacamole/src/main/webapp/layouts/en-us-qwerty-mobile.xml
+++ /dev/null
@@ -1,316 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!DOCTYPE keyboard PUBLIC
-    "-//Guacamole/Guacamole Onscreen Keyboard DTD 0.6.0//EN"
-    "http://guac-dev.org/pub/dtd/guacamole-osk-0.6.0.dtd">
-
-<!--
-   Copyright (C) 2013 Glyptodon LLC
-
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
--->
-
-<keyboard lang="en_US" layout="qwerty" size="16.3">
-    <row>
-        <key size="1.5">
-            <cap keysym="0xFF09">Tab</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>q</cap>
-            <cap if="numsym">1</cap>
-            <cap if="shift">Q</cap>
-            <cap if="numsym,shift">q</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>w</cap>
-            <cap if="numsym">2</cap>
-            <cap if="shift">W</cap>
-            <cap if="numsym,shift">w</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>e</cap>
-            <cap if="numsym">3</cap>
-            <cap if="shift">E</cap>
-            <cap if="numsym,shift">e</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>r</cap>
-            <cap if="numsym">4</cap>
-            <cap if="shift">R</cap>
-            <cap if="numsym,shift">r</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>t</cap>
-            <cap if="numsym">5</cap>
-            <cap if="shift">T</cap>
-            <cap if="numsym,shift">t</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>y</cap>
-            <cap if="numsym">6</cap>
-            <cap if="shift">Y</cap>
-            <cap if="numsym,shift">y</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>u</cap>
-            <cap if="numsym">7</cap>
-            <cap if="shift">U</cap>
-            <cap if="numsym,shift">u</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>i</cap>
-            <cap if="numsym">8</cap>
-            <cap if="shift">I</cap>
-            <cap if="numsym,shift">i</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>o</cap>
-            <cap if="numsym">9</cap>
-            <cap if="shift">O</cap>
-            <cap if="numsym,shift">o</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>p</cap>
-            <cap if="numsym">0</cap>
-            <cap if="shift">P</cap>
-            <cap if="numsym,shift">p</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>[</cap>
-            <cap if="shift">{</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>]</cap>
-            <cap if="shift">}</cap>
-        </key>
-        <gap size="0.1"/>
-        <key size="1.5">
-            <cap keysym="0xFF08">Back</cap>
-        </key>
-    </row>
-
-    <row><gap size="0.1"/></row>
-
-    <row>
-        <key size="1.85" class="numsym">
-            <cap modifier="numsym" sticky="true">?123</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>a</cap>
-            <cap if="numsym">#</cap>
-            <cap if="shift">A</cap>
-            <cap if="numsym,shift">a</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>s</cap>
-            <cap if="numsym">$</cap>
-            <cap if="shift">S</cap>
-            <cap if="numsym,shift">s</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>d</cap>
-            <cap if="numsym">%</cap>
-            <cap if="shift">D</cap>
-            <cap if="numsym,shift">d</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>f</cap>
-            <cap if="numsym">&amp;</cap>
-            <cap if="shift">F</cap>
-            <cap if="numsym,shift">f</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>g</cap>
-            <cap if="numsym">*</cap>
-            <cap if="shift">G</cap>
-            <cap if="numsym,shift">g</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>h</cap>
-            <cap if="numsym">-</cap>
-            <cap if="shift">H</cap>
-            <cap if="numsym,shift">h</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>j</cap>
-            <cap if="numsym">+</cap>
-            <cap if="shift">J</cap>
-            <cap if="numsym,shift">j</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>k</cap>
-            <cap if="numsym">(</cap>
-            <cap if="shift">K</cap>
-            <cap if="numsym,shift">k</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>l</cap>
-            <cap if="numsym">)</cap>
-            <cap if="shift">L</cap>
-            <cap if="numsym,shift">l</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>;</cap>
-            <cap if="shift">:</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>'</cap>
-            <cap if="shift">"</cap>
-        </key>
-        <gap size="0.1"/>
-        <key size="2.25">
-            <cap keysym="0xFF0D">Enter</cap>
-        </key>
-    </row>
-
-    <row><gap size="0.1"/></row>
-
-    <row>
-        <key size="2.1" class="shift">
-            <cap modifier="shift" keysym="0xFFE1">Shift</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>z</cap>
-            <cap if="numsym">&lt;</cap>
-            <cap if="shift">Z</cap>
-            <cap if="numsym,shift">z</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>x</cap>
-            <cap if="numsym">&gt;</cap>
-            <cap if="shift">X</cap>
-            <cap if="numsym,shift">x</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>c</cap>
-            <cap if="numsym">=</cap>
-            <cap if="shift">C</cap>
-            <cap if="numsym,shift">c</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>v</cap>
-            <cap if="numsym">'</cap>
-            <cap if="shift">V</cap>
-            <cap if="numsym,shift">v</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>b</cap>
-            <cap if="numsym">;</cap>
-            <cap if="shift">B</cap>
-            <cap if="numsym,shift">b</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>n</cap>
-            <cap if="numsym">,</cap>
-            <cap if="shift">N</cap>
-            <cap if="numsym,shift">n</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>m</cap>
-            <cap if="numsym">.</cap>
-            <cap if="shift">M</cap>
-            <cap if="numsym,shift">m</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>,</cap>
-            <cap if="numsym">!</cap>
-            <cap if="shift">!</cap>
-            <cap if="numsym,shift">!</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>.</cap>
-            <cap if="numsym">?</cap>
-            <cap if="shift">?</cap>
-            <cap if="numsym,shift">?</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap>/</cap>
-            <cap if="shift">?</cap>
-        </key>
-        <gap size="0.1"/>
-        <key size="3.1" class="shift">
-            <cap modifier="shift" keysym="0xFFE2">Shift</cap>
-        </key>
-    </row>
-
-    <row><gap size="0.1"/></row>
-
-    <row>
-        <key size="1.6" class="control">
-            <cap modifier="control" keysym="0xFFE3">Ctrl</cap>
-        </key>
-        <gap size="0.1"/>
-        <key size="1.6" class="super">
-            <cap modifier="super" keysym="0xFFEB">Super</cap>
-        </key>
-        <gap size="0.1"/>
-        <key size="1.6" class="alt">
-            <cap modifier="alt" keysym="0xFFE9">Alt</cap>
-        </key>
-        <gap size="0.1"/>
-        <key size="6.1">
-            <cap> </cap>
-        </key>
-        <gap size="0.1"/>
-        <key size="1.6" class="alt">
-            <cap modifier="alt" keysym="0xFFEA">Alt</cap>
-        </key>
-        <gap size="0.1"/>
-        <key size="1.6">
-            <cap keysym="0xFF67">Menu</cap>
-        </key>
-        <gap size="0.1"/>
-        <key size="1.6" class="control">
-            <cap modifier="control" keysym="0xFFE4">Ctrl</cap>
-        </key>
-    </row>
-</keyboard>
diff --git a/guacamole/src/main/webapp/layouts/en-us-qwerty.json b/guacamole/src/main/webapp/layouts/en-us-qwerty.json
new file mode 100644
index 000000000..fc7cdfcea
--- /dev/null
+++ b/guacamole/src/main/webapp/layouts/en-us-qwerty.json
@@ -0,0 +1,400 @@
+{
+
+    "language" : "en_US",
+    "type"     : "qwerty",
+    "width"    : 22,
+
+    "keys" : {
+
+        "Back"  : 65288,
+        "Tab"   : 65289,
+        "Enter" : 65293,
+        "Esc"   : 65307,
+        "Home"  : 65360,
+        "PgUp"  : 65365,
+        "PgDn"  : 65366,
+        "End"   : 65367,
+        "Ins"   : 65379,
+        "F1"    : 65470,
+        "F2"    : 65471,
+        "F3"    : 65472,
+        "F4"    : 65473,
+        "F5"    : 65474,
+        "F6"    : 65475,
+        "F7"    : 65476,
+        "F8"    : 65477,
+        "F9"    : 65478,
+        "F10"   : 65479,
+        "F11"   : 65480,
+        "F12"   : 65481,
+        "Del"   : 65535,
+
+        "Space" : " ",
+
+        "Left" : [{
+            "title"  : "←",
+            "keysym" : 65361
+        }],
+        "Up" : [{
+            "title"  : "↑",
+            "keysym" : 65362
+        }],
+        "Right" : [{
+            "title"  : "→",
+            "keysym" : 65363
+        }],
+        "Down" : [{
+            "title"  : "↓",
+            "keysym" : 65364
+        }],
+
+        "Menu" : [{
+            "title"    : "Menu",
+            "modifier" : "super",
+            "keysym"   : 65383
+        }],
+        "LShift" : [{
+            "title"    : "Shift",
+            "modifier" : "shift",
+            "keysym"   : 65505
+        }],
+        "RShift" : [{
+            "title"    : "Shift",
+            "modifier" : "shift",
+            "keysym"   : 65506
+        }],
+        "LCtrl" : [{
+            "title"    : "Ctrl",
+            "modifier" : "control",
+            "keysym"   : 65507
+        }],
+        "RCtrl" : [{
+            "title"    : "Ctrl",
+            "modifier" : "control",
+            "keysym"   : 65508
+        }],
+        "Caps" : [{
+            "title"    : "Caps",
+            "modifier" : "caps",
+            "keysym"   : 65509
+        }],
+        "LAlt" : [{
+            "title"    : "Alt",
+            "modifier" : "alt",
+            "keysym"   : 65513
+        }],
+        "RAlt" : [{
+            "title"    : "Alt",
+            "modifier" : "alt",
+            "keysym"   : 65514
+        }],
+        "Super" : [{
+            "title"    : "Super",
+            "modifier" : "super",
+            "keysym"   : 65515
+        }],
+
+        "`" : [
+            { "title" : "`", "requires" : [         ] },
+            { "title" : "~", "requires" : [ "shift" ] }
+        ],
+        "1" : [
+            { "title" : "1", "requires" : [         ] },
+            { "title" : "!", "requires" : [ "shift" ] }
+        ],
+        "2" : [
+            { "title" : "2", "requires" : [         ] },
+            { "title" : "@", "requires" : [ "shift" ] }
+        ],
+        "3" : [
+            { "title" : "3", "requires" : [         ] },
+            { "title" : "#", "requires" : [ "shift" ] }
+        ],
+        "4" : [
+            { "title" : "4", "requires" : [         ] },
+            { "title" : "$", "requires" : [ "shift" ] }
+        ],
+        "5" : [
+            { "title" : "5", "requires" : [         ] },
+            { "title" : "%", "requires" : [ "shift" ] }
+        ],
+        "6" : [
+            { "title" : "6", "requires" : [         ] },
+            { "title" : "^", "requires" : [ "shift" ] }
+        ],
+        "7" : [
+            { "title" : "7", "requires" : [         ] },
+            { "title" : "&", "requires" : [ "shift" ] }
+        ],
+        "8" : [
+            { "title" : "8", "requires" : [         ] },
+            { "title" : "*", "requires" : [ "shift" ] }
+        ],
+        "9" : [
+            { "title" : "9", "requires" : [         ] },
+            { "title" : "(", "requires" : [ "shift" ] }
+        ],
+        "0" : [
+            { "title" : "0", "requires" : [         ] },
+            { "title" : ")", "requires" : [ "shift" ] }
+        ],
+        "-" : [
+            { "title" : "-", "requires" : [         ] },
+            { "title" : "_", "requires" : [ "shift" ] }
+        ],
+        "=" : [
+            { "title" : "=", "requires" : [         ] },
+            { "title" : "+", "requires" : [ "shift" ] }
+        ],
+        "," : [
+            { "title" : ",", "requires" : [         ] },
+            { "title" : "<", "requires" : [ "shift" ] }
+        ],
+        "." : [
+            { "title" : ".", "requires" : [         ] },
+            { "title" : ">", "requires" : [ "shift" ] }
+        ],
+        "/" : [
+            { "title" : "/", "requires" : [         ] },
+            { "title" : "?", "requires" : [ "shift" ] }
+        ],
+        "[" : [
+            { "title" : "[", "requires" : [         ] },
+            { "title" : "{", "requires" : [ "shift" ] }
+        ],
+        "]" : [
+            { "title" : "]", "requires" : [         ] },
+            { "title" : "}", "requires" : [ "shift" ] }
+        ],
+        "\\" : [
+            { "title" : "\\", "requires" : [         ] },
+            { "title" : "|",  "requires" : [ "shift" ] }
+        ],
+        ";" : [
+            { "title" : ";", "requires" : [         ] },
+            { "title" : ":", "requires" : [ "shift" ] }
+        ],
+        "'" : [
+            { "title" : "'",  "requires" : [         ] },
+            { "title" : "\"", "requires" : [ "shift" ] }
+        ],
+
+        "q" : [
+            { "title" : "q", "requires" : [                 ] },
+            { "title" : "Q", "requires" : [ "caps"          ] },
+            { "title" : "Q", "requires" : [ "shift"         ] },
+            { "title" : "q", "requires" : [ "caps", "shift" ] }
+        ],
+        "w" : [
+            { "title" : "w", "requires" : [                 ] },
+            { "title" : "W", "requires" : [ "caps"          ] },
+            { "title" : "W", "requires" : [ "shift"         ] },
+            { "title" : "w", "requires" : [ "caps", "shift" ] }
+        ],
+        "e" : [
+            { "title" : "e", "requires" : [                 ] },
+            { "title" : "E", "requires" : [ "caps"          ] },
+            { "title" : "E", "requires" : [ "shift"         ] },
+            { "title" : "e", "requires" : [ "caps", "shift" ] }
+        ],
+        "r" : [
+            { "title" : "r", "requires" : [                 ] },
+            { "title" : "R", "requires" : [ "caps"          ] },
+            { "title" : "R", "requires" : [ "shift"         ] },
+            { "title" : "r", "requires" : [ "caps", "shift" ] }
+        ],
+        "t" : [
+            { "title" : "t", "requires" : [                 ] },
+            { "title" : "T", "requires" : [ "caps"          ] },
+            { "title" : "T", "requires" : [ "shift"         ] },
+            { "title" : "t", "requires" : [ "caps", "shift" ] }
+        ],
+        "y" : [
+            { "title" : "y", "requires" : [                 ] },
+            { "title" : "Y", "requires" : [ "caps"          ] },
+            { "title" : "Y", "requires" : [ "shift"         ] },
+            { "title" : "y", "requires" : [ "caps", "shift" ] }
+        ],
+        "u" : [
+            { "title" : "u", "requires" : [                 ] },
+            { "title" : "U", "requires" : [ "caps"          ] },
+            { "title" : "U", "requires" : [ "shift"         ] },
+            { "title" : "u", "requires" : [ "caps", "shift" ] }
+        ],
+        "i" : [
+            { "title" : "i", "requires" : [                 ] },
+            { "title" : "I", "requires" : [ "caps"          ] },
+            { "title" : "I", "requires" : [ "shift"         ] },
+            { "title" : "i", "requires" : [ "caps", "shift" ] }
+        ],
+        "o" : [
+            { "title" : "o", "requires" : [                 ] },
+            { "title" : "O", "requires" : [ "caps"          ] },
+            { "title" : "O", "requires" : [ "shift"         ] },
+            { "title" : "o", "requires" : [ "caps", "shift" ] }
+        ],
+        "p" : [
+            { "title" : "p", "requires" : [                 ] },
+            { "title" : "P", "requires" : [ "caps"          ] },
+            { "title" : "P", "requires" : [ "shift"         ] },
+            { "title" : "p", "requires" : [ "caps", "shift" ] }
+        ],
+        "a" : [
+            { "title" : "a", "requires" : [                 ] },
+            { "title" : "A", "requires" : [ "caps"          ] },
+            { "title" : "A", "requires" : [ "shift"         ] },
+            { "title" : "a", "requires" : [ "caps", "shift" ] }
+        ],
+        "s" : [
+            { "title" : "s", "requires" : [                 ] },
+            { "title" : "S", "requires" : [ "caps"          ] },
+            { "title" : "S", "requires" : [ "shift"         ] },
+            { "title" : "s", "requires" : [ "caps", "shift" ] }
+        ],
+        "d" : [
+            { "title" : "d", "requires" : [                 ] },
+            { "title" : "D", "requires" : [ "caps"          ] },
+            { "title" : "D", "requires" : [ "shift"         ] },
+            { "title" : "d", "requires" : [ "caps", "shift" ] }
+        ],
+        "f" : [
+            { "title" : "f", "requires" : [                 ] },
+            { "title" : "F", "requires" : [ "caps"          ] },
+            { "title" : "F", "requires" : [ "shift"         ] },
+            { "title" : "f", "requires" : [ "caps", "shift" ] }
+        ],
+        "g" : [
+            { "title" : "g", "requires" : [                 ] },
+            { "title" : "G", "requires" : [ "caps"          ] },
+            { "title" : "G", "requires" : [ "shift"         ] },
+            { "title" : "g", "requires" : [ "caps", "shift" ] }
+        ],
+        "h" : [
+            { "title" : "h", "requires" : [                 ] },
+            { "title" : "H", "requires" : [ "caps"          ] },
+            { "title" : "H", "requires" : [ "shift"         ] },
+            { "title" : "h", "requires" : [ "caps", "shift" ] }
+        ],
+        "j" : [
+            { "title" : "j", "requires" : [                 ] },
+            { "title" : "J", "requires" : [ "caps"          ] },
+            { "title" : "J", "requires" : [ "shift"         ] },
+            { "title" : "j", "requires" : [ "caps", "shift" ] }
+        ],
+        "k" : [
+            { "title" : "k", "requires" : [                 ] },
+            { "title" : "K", "requires" : [ "caps"          ] },
+            { "title" : "K", "requires" : [ "shift"         ] },
+            { "title" : "k", "requires" : [ "caps", "shift" ] }
+        ],
+        "l" : [
+            { "title" : "l", "requires" : [                 ] },
+            { "title" : "L", "requires" : [ "caps"          ] },
+            { "title" : "L", "requires" : [ "shift"         ] },
+            { "title" : "l", "requires" : [ "caps", "shift" ] }
+        ],
+        "z" : [
+            { "title" : "z", "requires" : [                 ] },
+            { "title" : "Z", "requires" : [ "caps"          ] },
+            { "title" : "Z", "requires" : [ "shift"         ] },
+            { "title" : "z", "requires" : [ "caps", "shift" ] }
+        ],
+        "x" : [
+            { "title" : "x", "requires" : [                 ] },
+            { "title" : "X", "requires" : [ "caps"          ] },
+            { "title" : "X", "requires" : [ "shift"         ] },
+            { "title" : "x", "requires" : [ "caps", "shift" ] }
+        ],
+        "c" : [
+            { "title" : "c", "requires" : [                 ] },
+            { "title" : "C", "requires" : [ "caps"          ] },
+            { "title" : "C", "requires" : [ "shift"         ] },
+            { "title" : "c", "requires" : [ "caps", "shift" ] }
+        ],
+        "v" : [
+            { "title" : "v", "requires" : [                 ] },
+            { "title" : "V", "requires" : [ "caps"          ] },
+            { "title" : "V", "requires" : [ "shift"         ] },
+            { "title" : "v", "requires" : [ "caps", "shift" ] }
+        ],
+        "b" : [
+            { "title" : "b", "requires" : [                 ] },
+            { "title" : "B", "requires" : [ "caps"          ] },
+            { "title" : "B", "requires" : [ "shift"         ] },
+            { "title" : "b", "requires" : [ "caps", "shift" ] }
+        ],
+        "n" : [
+            { "title" : "n", "requires" : [                 ] },
+            { "title" : "N", "requires" : [ "caps"          ] },
+            { "title" : "N", "requires" : [ "shift"         ] },
+            { "title" : "n", "requires" : [ "caps", "shift" ] }
+        ],
+        "m" : [
+            { "title" : "m", "requires" : [                 ] },
+            { "title" : "M", "requires" : [ "caps"          ] },
+            { "title" : "M", "requires" : [ "shift"         ] },
+            { "title" : "m", "requires" : [ "caps", "shift" ] }
+        ]
+
+    },
+
+    "layout" : [
+
+        [ "Esc", 0.7, "F1", "F2",  "F3",  "F4",
+                 0.7, "F5", "F6",  "F7",  "F8",
+                 0.7, "F9", "F10", "F11", "F12" ],
+
+        [ 0.1 ],
+
+        {
+            "main" : {
+                "alpha" : [
+
+                    [ "`", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "-", "=", "Back" ],
+                    [ "Tab", "q", "w", "e", "r", "t", "y", "u", "i", "o", "p", "[", "]", "\\" ],
+                    [ "Caps",  "a", "s", "d", "f", "g", "h", "j", "k", "l", ";", "'", "Enter" ],
+                    [ "LShift", "z", "x", "c", "v",  "b", "n",  "m", ",", ".", "/",  "RShift" ],
+                    [ "LCtrl", "Super", "LAlt",       "Space",        "RAlt", "Menu", "RCtrl" ]
+
+                ],
+
+                "movement" : [
+                    [ "Ins",  "Home", "PgUp"  ],
+                    [ "Del",  "End",  "PgDn"  ],
+                    [           1             ],
+                    [          "Up"           ],
+                    [ "Left", "Down", "Right" ]
+                ]
+            }
+        }
+
+    ],
+
+    "keyWidths" : {
+
+        "Back"   : 2,
+        "Tab"    : 1.5,
+        "\\"     : 1.5,
+        "Caps"   : 1.85,
+        "Enter"  : 2.25,
+        "LShift" : 2.1,
+        "RShift" : 3.1,
+
+        "LCtrl" : 1.6,
+        "Super" : 1.6,
+        "LAlt"  : 1.6,
+        "Space" : 6.1,
+        "RAlt"  : 1.6,
+        "Menu"  : 1.6,
+        "RCtrl" : 1.6,
+
+        "Ins"  : 1.6,
+        "Home" : 1.6,
+        "PgUp" : 1.6,
+        "Del"  : 1.6,
+        "End"  : 1.6,
+        "PgDn" : 1.6
+
+    }
+
+}
diff --git a/guacamole/src/main/webapp/layouts/en-us-qwerty.xml b/guacamole/src/main/webapp/layouts/en-us-qwerty.xml
deleted file mode 100644
index 8cf8bb5e0..000000000
--- a/guacamole/src/main/webapp/layouts/en-us-qwerty.xml
+++ /dev/null
@@ -1,500 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!DOCTYPE keyboard PUBLIC
-    "-//Guacamole/Guacamole Onscreen Keyboard DTD 0.6.0//EN"
-    "http://guac-dev.org/pub/dtd/guacamole-osk-0.6.0.dtd">
-
-<!--
-   Copyright (C) 2013 Glyptodon LLC
-
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
--->
-
-<keyboard lang="en_US" layout="qwerty" size="22">
-    <row>
-        <key>
-            <cap keysym="0xFF1B">Esc</cap>
-        </key>
-        <gap size="0.8"/>
-        <key>
-            <cap keysym="0xFFBE">F1</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap keysym="0xFFBF">F2</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap keysym="0xFFC0">F3</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap keysym="0xFFC1">F4</cap>
-        </key>
-        <gap size="0.8"/>
-        <key>
-            <cap keysym="0xFFC2">F5</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap keysym="0xFFC3">F6</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap keysym="0xFFC4">F7</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap keysym="0xFFC5">F8</cap>
-        </key>
-        <gap size="0.8"/>
-        <key>
-            <cap keysym="0xFFC6">F9</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap keysym="0xFFC7">F10</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap keysym="0xFFC8">F11</cap>
-        </key>
-        <gap size="0.1"/>
-        <key>
-            <cap keysym="0xFFC9">F12</cap>
-        </key>
-    </row>
-    <row>
-        <gap size="0.25"/>
-    </row>
-    <column>
-        <row>
-            <key>
-                <cap>`</cap>
-                <cap if="shift">~</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>1</cap>
-                <cap if="shift">!</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>2</cap>
-                <cap if="shift">@</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>3</cap>
-                <cap if="shift">#</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>4</cap>
-                <cap if="shift">$</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>5</cap>
-                <cap if="shift">%</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>6</cap>
-                <cap if="shift">^</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>7</cap>
-                <cap if="shift">&amp;</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>8</cap>
-                <cap if="shift">*</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>9</cap>
-                <cap if="shift">(</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>0</cap>
-                <cap if="shift">)</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>-</cap>
-                <cap if="shift">_</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>=</cap>
-                <cap if="shift">+</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="2">
-                <cap keysym="0xFF08">Back</cap>
-            </key>
-        </row>
-
-        <row><gap size="0.1"/></row>
-
-        <row>
-            <key size="1.5">
-                <cap keysym="0xFF09">Tab</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>q</cap>
-                <cap if="caps">Q</cap>
-                <cap if="shift">Q</cap>
-                <cap if="caps,shift">q</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>w</cap>
-                <cap if="caps">W</cap>
-                <cap if="shift">W</cap>
-                <cap if="caps,shift">w</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>e</cap>
-                <cap if="caps">E</cap>
-                <cap if="shift">E</cap>
-                <cap if="caps,shift">e</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>r</cap>
-                <cap if="caps">R</cap>
-                <cap if="shift">R</cap>
-                <cap if="caps,shift">r</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>t</cap>
-                <cap if="caps">T</cap>
-                <cap if="shift">T</cap>
-                <cap if="caps,shift">t</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>y</cap>
-                <cap if="caps">Y</cap>
-                <cap if="shift">Y</cap>
-                <cap if="caps,shift">y</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>u</cap>
-                <cap if="caps">U</cap>
-                <cap if="shift">U</cap>
-                <cap if="caps,shift">u</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>i</cap>
-                <cap if="caps">I</cap>
-                <cap if="shift">I</cap>
-                <cap if="caps,shift">i</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>o</cap>
-                <cap if="caps">O</cap>
-                <cap if="shift">O</cap>
-                <cap if="caps,shift">o</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>p</cap>
-                <cap if="caps">P</cap>
-                <cap if="shift">P</cap>
-                <cap if="caps,shift">p</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>[</cap>
-                <cap if="shift">{</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>]</cap>
-                <cap if="shift">}</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="1.5">
-                <cap>\</cap>
-                <cap if="shift">|</cap>
-            </key>
-        </row>
-
-        <row><gap size="0.1"/></row>
-
-        <row>
-            <key size="1.85">
-                <cap modifier="caps" keysym="0xFFE5" sticky="true">Caps</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>a</cap>
-                <cap if="caps">A</cap>
-                <cap if="shift">A</cap>
-                <cap if="caps,shift">a</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>s</cap>
-                <cap if="caps">S</cap>
-                <cap if="shift">S</cap>
-                <cap if="caps,shift">s</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>d</cap>
-                <cap if="caps">D</cap>
-                <cap if="shift">D</cap>
-                <cap if="caps,shift">d</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>f</cap>
-                <cap if="caps">F</cap>
-                <cap if="shift">F</cap>
-                <cap if="caps,shift">f</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>g</cap>
-                <cap if="caps">G</cap>
-                <cap if="shift">G</cap>
-                <cap if="caps,shift">g</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>h</cap>
-                <cap if="caps">H</cap>
-                <cap if="shift">H</cap>
-                <cap if="caps,shift">h</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>j</cap>
-                <cap if="caps">J</cap>
-                <cap if="shift">J</cap>
-                <cap if="caps,shift">j</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>k</cap>
-                <cap if="caps">K</cap>
-                <cap if="shift">K</cap>
-                <cap if="caps,shift">k</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>l</cap>
-                <cap if="caps">L</cap>
-                <cap if="shift">L</cap>
-                <cap if="caps,shift">l</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>;</cap>
-                <cap if="shift">:</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>'</cap>
-                <cap if="shift">"</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="2.25">
-                <cap keysym="0xFF0D">Enter</cap>
-            </key>
-        </row>
-
-        <row><gap size="0.1"/></row>
-
-        <row>
-            <key size="2.1" class="shift">
-                <cap modifier="shift" keysym="0xFFE1">Shift</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>z</cap>
-                <cap if="caps">Z</cap>
-                <cap if="shift">Z</cap>
-                <cap if="caps,shift">z</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>x</cap>
-                <cap if="caps">X</cap>
-                <cap if="shift">X</cap>
-                <cap if="caps,shift">x</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>c</cap>
-                <cap if="caps">C</cap>
-                <cap if="shift">C</cap>
-                <cap if="caps,shift">c</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>v</cap>
-                <cap if="caps">V</cap>
-                <cap if="shift">V</cap>
-                <cap if="caps,shift">v</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>b</cap>
-                <cap if="caps">B</cap>
-                <cap if="shift">B</cap>
-                <cap if="caps,shift">b</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>n</cap>
-                <cap if="caps">N</cap>
-                <cap if="shift">N</cap>
-                <cap if="caps,shift">n</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>m</cap>
-                <cap if="caps">M</cap>
-                <cap if="shift">M</cap>
-                <cap if="caps,shift">m</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>,</cap>
-                <cap if="shift">&lt;</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>.</cap>
-                <cap if="shift">&gt;</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap>/</cap>
-                <cap if="shift">?</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="3.1" class="shift">
-                <cap modifier="shift" keysym="0xFFE2">Shift</cap>
-            </key>
-        </row>
-
-        <row><gap size="0.1"/></row>
-
-        <row>
-            <key size="1.6" class="control">
-                <cap modifier="control" keysym="0xFFE3">Ctrl</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="1.6" class="super">
-                <cap modifier="super" keysym="0xFFEB">Super</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="1.6" class="alt">
-                <cap modifier="alt" keysym="0xFFE9">Alt</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="6.1">
-                <cap> </cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="1.6" class="alt">
-                <cap modifier="alt" keysym="0xFFE3">Alt</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="1.6" class="super">
-                <cap modifier="super" keysym="0xFF67">Menu</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="1.6" class="control">
-                <cap modifier="control" keysym="0xFFE4">Ctrl</cap>
-            </key>
-        </row>
-    </column>
-        <column>
-        <row>
-            <gap size="0.25"/>
-        </row>
-    </column>
-    <column align="center">
-        <row>
-            <key size="1.75">
-                <cap keysym="0xFF63">Ins</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="1.75">
-                <cap keysym="0xFF50">Home</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="1.75">
-                <cap keysym="0xFF55">PgUp</cap>
-            </key>
-        </row>
-        <row><gap size="0.1"/></row>
-        <row>
-            <key size="1.75">
-                <cap keysym="0xFFFF">Del</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="1.75">
-                <cap keysym="0xFF57">End</cap>
-            </key>
-            <gap size="0.1"/>
-            <key size="1.75">
-                <cap keysym="0xFF56">PgDn</cap>
-            </key>
-        </row>
-        <row>
-            <gap/>
-        </row>
-        <row>
-            <key>
-                <cap keysym="0xFF52">&#x2191;</cap>
-            </key>
-        </row>
-        <row><gap size="0.1"/></row>
-        <row>
-            <key>
-                <cap keysym="0xFF51">&#x2190;</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap keysym="0xFF54">&#x2193;</cap>
-            </key>
-            <gap size="0.1"/>
-            <key>
-                <cap keysym="0xFF53">&#x2192;</cap>
-            </key>
-        </row>
-    </column>
-</keyboard>
diff --git a/guacamole/src/main/webapp/translations/en_US.json b/guacamole/src/main/webapp/translations/en_US.json
index 2ea7b6f78..79e5a6db6 100644
--- a/guacamole/src/main/webapp/translations/en_US.json
+++ b/guacamole/src/main/webapp/translations/en_US.json
@@ -117,7 +117,7 @@
         "TEXT_RECONNECT_COUNTDOWN"        : "Reconnecting in {REMAINING} {REMAINING, plural, one{second} other{seconds}}...",
         "TEXT_FILE_TRANSFER_PROGRESS"     : "{PROGRESS} {UNIT, select, b{B} kb{KB} mb{MB} gb{GB} other{}}",
 
-        "URL_OSK_LAYOUT" : "layouts/en-us-qwerty.xml"
+        "URL_OSK_LAYOUT" : "layouts/en-us-qwerty.json"
 
     },