SliceType Keyboard: Optimizing Gaze Typing

• SliceType is a soft keyboard that reconfigures key sizes dynamically to address gaze tracking imprecision and improve text entry.
• It employs a merging-key algorithm that redistributes inactive keys based on language model constraints, reducing text entry difficulty by up to 38.6%.
• The system integrates in-key predictions using unigram and bigram models to offer context-sensitive word completions, enhancing typing speed and user comfort.

SliceType is a soft keyboard designed specifically to optimize text entry for gaze-typing users, addressing the practical limitations imposed by gaze point jitter and the inefficiency of conventional soft keyboard layouts. By dynamically reallocating screen space and providing immediate, context-sensitive word predictions within individual keys, SliceType aims to increase typing speed and user comfort despite the inherent imprecision of eye tracking technology (Benligiray et al., 2017).

1. Design Principles and Rationale

The principal motivation behind SliceType’s design is the mitigation of two core bottlenecks in gaze typing: (a) random jitter and occasional bias in gaze estimation, which makes precise dwelling on small keys unreliable; and (b) the additional time cost for every gaze movement required to read word predictions or select subsequent letters, as formalized by Fitts’ law. To counter these issues, SliceType dynamically expands only the keys that may become relevant for the next input, thereby reducing both index of difficulty and the likelihood of cursor ejection due to jitter. The strategy stands on three foundational pillars:

1. Merging – Elimination of unlikely keys and redistribution of their screen area to neighboring keys through smooth animation.
2. In-key prediction – Presentation of highly probable continuations within each key itself, rather than a separate area.
3. Balanced layout – Frequent letters positioned close to the center, with rare letters on an outer ring, optimizing merging opportunities and minimizing average saccade distances.

2. Merging-Key Algorithmic Framework

SliceType’s merging-key mechanism utilizes LLM constraints to deactivate keys that have no feasible continuation given the input prefix. Unigram and bigram tries are maintained over the corpus, enabling real-time determination of which keys X are invalid after the current prefix (“no word in the model starts with prefix+X”). Keys so identified are removed, and their angular and radial spans are merged into adjacent slices; this transition is animated over approximately 200 ms for user continuity. Neighbor selection for merging prioritizes adjacent keys that are also unlikely to avoid disproportionate spatial distortions.

A pseudocode summary is as follows:

On each key-highlight or after character entry: prefix ← text_entered_so_far For each key k in [A–Z]: If no word in model starts with (prefix + k.letter): mark k for removal For each k marked for removal: neighbor ← choose_adjacent_key_for_merge(k) merge_slice(k, into=neighbor) redraw_keyboard_with_animation()

Each update requires computational cost linear in the number of keys plus the cost of prefix lookups.

3. Quantitative Modeling via Fitts’ Law

SliceType’s efficacy is analytically quantified using Shannon’s form of Fitts’ law:

$$\mathrm{MT} = a + b \cdot \log_2 \left(\frac{D}{W} + 1\right)$$

The index of difficulty (ID) is defined as $\log_2 (D/W + 1)$, where $D$ is the distance from the previous key’s center to the target center, and $W$ is the effective width along the line of movement (measured as the chord of intersection). In the context of SliceType, which uses pie-slice keys in a circular/ring layout, the "center" is positioned on the key’s radial bisector at its mean radius.

Empirical modeling yields the following comparative results for the phrase "The quick brown fox...":

Configuration	Index of Difficulty (ID)
No prediction, no merging	49.02
Prediction only (no merging)	40.40
Merging only (no prediction)	33.68
Prediction + merging	30.13

Merging yields a 31.3% reduction in ID, prediction alone delivers a 17.5% reduction, and the combined approach results in a 38.6% reduction relative to baseline. Moreover, integrating predictions into individual keys (rather than a standard prediction list) reduces ID by 63.1% versus conventional placement.

4. Per-Key Prediction and Word Completion

The prediction engine employs bigram and unigram tries. For every letter key $L$, the system calculates the most probable continuation for $(\text{prefix} + L)$ and displays the suggested word within the key. A single (e.g., 1000 ms) dwell enters the letter and updates the prefix, permitting real-time reading of the per-key prediction. If the user continues dwelling for another interval (double-dwell), the full predicted word is entered, and the keyboard resets to display all keys. This scheme allows seamless gaze-based selection without additional saccadic motion or dwell overhead for predictions.

5. Experimental Protocol and User Study

An empirical study evaluated SliceType against Dasher and GazeTalk using 37 novice engineering students with no prior gaze-typing experience. The apparatus was an LC Technologies MES eye-tracker (60 Hz, ~0.45° accuracy, ~50 cm viewing distance). Each participant underwent a 30-minute tutorial and calibration per keyboard, then gaze-typed dictated text (one paragraph per keyboard) for five minutes each in a fully counterbalanced design.

Collected metrics included:

• Text entry rate (characters per 5 min, converted to wpm).
• Error count (one error per consecutive wrong characters).
• Post-experiment user ranking.

6. Results: Text Entry Rate, Error, and Preference

Key empirical outcomes are summarized:

Keyboard	Characters (5 min)	WPM	Mean Errors	% Ranked #1
Dasher	42.00	1.68	1.03	23%
GazeTalk	73.14	2.93	0.54	23%
SliceType	86.30	3.45	0.68	54%

Statistical testing (one-way ANOVA, Bonferroni post-hoc):

• SliceType vs. Dasher: $p < 0.001$ (significant)
• SliceType vs. GazeTalk: $p = 0.193$ (ns)
• GazeTalk vs. Dasher: $p < 0.001$ (significant)

Error rates exhibited no significant difference ($p = 0.094$). Most SliceType users typed 50–100 chars with a significant group above 100 chars in 5 minutes, outpacing other keyboards in both mean and upper-quartile speed. Preference rankings broadly reflected objective performance, with ANOVA on aligned ranks showing preference for SliceType over Dasher ($p < 0.001$) and a trend over GazeTalk ($p = 0.074$).

7. Implications, Limitations, and Future Directions

The results confirm that SliceType’s merging and in-key prediction strategies lower Fitts’ law difficulty metrics and empirically improve text entry speed, even for untrained gaze typists. However, only 54% selected SliceType as most preferred, though 68% typed fastest with it, suggesting that comfort and learnability factors remain important alongside raw speed.

Documented limitations include testing solely with gaze-typing novices, the necessity to keep key merging local to preserve spatial memory, and use of a fixed dwell time. The merging mechanism does not adapt when non-corpus words are typed, invoking a non-merging fallback. Future enhancements could involve adaptive or user-tunable merging aggressiveness, advanced language modeling to further reduce mode switches, and dynamic dwell adaptation contingent on user stability or key size.

SliceType exemplifies the potential of screen-space optimization, dynamic key management, and context-sensitive prediction in mitigating the constraints of gaze-based text input, with demonstrable quantitative and user experience gains (Benligiray et al., 2017).