In This Article
Open the settings in a browser game in Google Chrome on a phone and you might find a perfectly clear button that Android’s built-in TalkBack screen reader never announces. The game probably drew that button as part of its graphics. You can see the label and the shape, but the screen reader only knows about a control if the browser tells it those pixels are one.
Chrome 157 gives web developers another way to build those screens. Google shipped HTML-in-Canvas in the stable release, and the Android build 157.0.8103.50 rolled out on November 9. For casino-style browser titles, which lean on animated canvas scenes more than most web games, it is one of the more useful accessibility changes in a while.
Why a game menu can be hard to read with TalkBack

A canvas is an area of a web page where the browser draws graphics. Games use it for moving scenes because the code decides what appears in every frame: where each object sits, which layer is in front, what moves next. At 60 fps that means a fresh frame roughly every 16.7 ms, painted from scratch.
The trouble starts when the game draws an interactive item into that same image. A rectangle marked “Settings” can look and behave like a button for someone who taps it. For TalkBack to announce what it does, though, the browser has to expose that control to the screen reader. It also needs to know which controls can take keyboard focus, and in what order.
The button beside the reels

Browser-based slot games make the difference easy to see. The reels spin as part of an animated scene, while the button that opens the paytable has to work as a control. A player using TalkBack needs to hear what that button does, read the rules it opens and get back to the game screen when they close it. Card tables and live game-show titles have the same split between scenery and controls.
One common answer is to lay regular HTML controls over the canvas. For a menu pinned to the top of the screen, that overlay is fairly simple. It gets harder when a control has to stay attached to a moving object, slip behind another layer or change position when the phone rotates. Teams also have to keep any separate accessibility controls in step with what the game actually shows, which is easy to break with every redesign.
What HTML-in-Canvas gives developers
Chrome’s API lets developers draw HTML elements into scenes built with Canvas 2D, WebGL or WebGPU. A button can appear as part of the scene and still be a button in the browser’s accessibility tree. Text drawn from an HTML element can keep browser features such as selection and translation, too.
That means familiar web controls can go where position, depth and timing matter. Picture a game-show title where a rules panel slides in beside the wheel. The panel can move with the scene while its controls keep meaningful labels and a logical focus order, as long as the developer sets those up.
Here is how the three approaches compare for a typical game menu:
| Approach | What TalkBack gets | Where it gets hard |
|---|---|---|
| Controls drawn as pixels only | Nothing to announce unless the team adds hidden controls | Every label and focus stop has to be rebuilt by hand, and it drifts out of sync |
| HTML overlay on the canvas | Real buttons with roles and labels | Keeping controls aligned with moving objects, layers and rotation |
| HTML-in-Canvas | Real buttons drawn inside the scene | Browser support, plus the same label and focus work as any HTML |
Which parts still need careful design?
A screen reader announces whatever label it receives. The developer still has to write one that tells the player what happens when the control is activated. A small gear icon may be obvious to someone looking at the display; its spoken label should say it is the settings button.
Focus needs attention whenever a panel opens or closes. When a help panel opens, the first thing TalkBack reads should make sense in that new context. When it closes, sending focus back to the original button gives the player a clear place to pick up again. India’s government web accessibility guidelines tackle a related problem by asking developers to make sure keyboard users can move focus away from any element they can reach. The W3C’s focus order success criterion makes the broader point: focus should move in an order that keeps the screen’s meaning intact.
Before a canvas menu ships
- Spoken labels say what happens, such as “Open paytable” rather than “Icon 3”.
- Focus lands on the panel when it opens, and returns to the button that opened it when it closes.
- No focus traps: a keyboard or TalkBack user can always move on from any control.
- Rotation keeps controls reachable in both portrait and landscape.
A practical check on an Android phone
Any Android user can try this on a site that has implemented the feature. If TalkBack isn’t on yet, Google’s TalkBack setup guide walks through turning it on and the basic gestures. Then pick a short task you can repeat, which takes about 5 minutes in most games:
- Open the settings. Listen for whether the button is announced as a button, with a name that matches what it does.
- Find one control inside. A volume or sound toggle works well. Check that you can change it and hear the new state.
- Close the panel. Note where focus lands. Back on the settings button is a good sign; the top of the page is not.
- Rotate the phone and repeat. If the game supports both orientations, the layout may shift and expose controls that are no longer reachable.
Where a game supports keyboard input, a connected keyboard is a quick second test. Either way, notice whether the order you move through the controls matches the order you would use them in. The browser update gives developers the API; what a player experiences still depends on each individual game.
Why browser support still matters
A game can reach Android players through several browsers, and the same people may open it on other devices. Not every browser engine supports HTML-in-Canvas yet, so a team adopting it needs a plan for how visitors reach essential controls when the feature isn’t there. Chrome’s own developer guide for HTML-in-Canvas recommends checking for support first and falling back to an HTML overlay when it’s missing.
A standard HTML menu remains a practical option in those cases. It is less elegant inside an animated scene, but it works in every browser and with every screen reader, which matters more to a player than how seamlessly the menu blends into the artwork.
💡 For players
- If a game’s menus stay silent under TalkBack, the studio probably hasn’t adopted HTML-in-Canvas or an accessible overlay yet. Updating Chrome won’t fix that on its own, but telling the studio which control failed often helps more than you’d expect.
Frequently asked questions
What is HTML-in-Canvas?
A Chrome API that lets developers draw real HTML elements, such as buttons and text, into a canvas scene built with Canvas 2D, WebGL or WebGPU. The elements keep their meaning for the browser, so screen readers and features like translation still work.
Does HTML-in-Canvas make every browser game work with TalkBack?
No. It gives developers the tool. A game only improves if its studio uses the API, writes clear labels and manages focus when panels open and close.
Which Chrome version added it?
Chrome 157 brought it to the stable channel. On Android, build 157.0.8103.50 rolled out on November 9.
How can I tell if a game supports TalkBack properly?
Turn on TalkBack, open the settings, change one control and close the panel again. If every button is announced with a sensible name and focus returns to where you started, the game is in good shape.
What a good implementation feels like
For Android players, the clearest sign of a successful implementation is a routine interaction that feels predictable. You can find a button, understand what it does and keep your place after using it, even while the game scene keeps moving around it.
✅ Key takeaways
- Canvas-drawn buttons are just pixels to TalkBack unless the browser exposes them as controls.
- HTML-in-Canvas in Chrome 157 lets real HTML controls live inside 2D, WebGL and WebGPU scenes.
- Labels, focus order and focus return are still the developer’s responsibility.
- Test with TalkBack by opening a panel, using one control, closing it and rotating the phone.
- Keep a plain HTML menu as a fallback for browsers without support.











