<canvas>. The Register's coverage frames it as a creative leap and a possible gift to annoying advertisers. The practical story for developers is more specific than that: what works, what breaks, and where Edge fits.
What actually shipped
The API is on by default in Chrome 157 and later, and Chromium 147–156 and Brave have it behind the canvas-draw-element flag. Google's Chrome for Developers announcement, dated October 26, 2026, says Chrome 157 is the stable release that follows an origin trial. The Register reports that Chrome for Android also supports it from 157.
The problem it addresses is old. A canvas is a bitmap, so developers who wanted rich text or controls had two bad options:
- Draw text as pixels. Screen readers can't see it, and users lose Find-in-Page, copy and paste, translation and context menus unless the developer rebuilds a hidden fallback DOM.
- Float HTML overlays on top. Camera movement or zooming can make overlays drift or jitter against the canvas, and the overlay can't sit "inside" a 3D scene.
HTML-in-Canvas lets the browser lay out the HTML, then lets the developer draw that result as an image, a texture or a shader input.
How it works
Two attributes opt content in. According to Chrome's documentation, the <canvas> gets content="drawable", and each element you want to draw gets a drawable attribute. A drawable element and its descendants form a paint root. Nested drawable children are excluded and drawn separately.
In a 2D context, the core call is ctx.drawElementImage(element, x, y). The WebGL and WebGPU paths copy the element into a texture. The spec also adds a paint event, which fires when drawable descendants change visually, and requestPaint() for continuous animation. One catch: DOM changes made inside a paint handler don't appear until the next frame.
A minimal 2D setup looks like this:
- Put
content="drawable"on the canvas. - Put
drawableon the child element. - Call
drawElementImage()inside the canvas's paint handler. - Size the canvas grid with a
ResizeObserveranddevicePixelContentBoxSize, or the result may look blurry.
Chrome's documentation lists the units to watch. Draw coordinates are in canvas grid pixels, while DOM measurements such as offsetWidth are in CSS pixels. Developers have to convert between them.
The 3D accessibility catch
The Register notes that developers must handle bounding boxes so screen readers and click targets keep working in 3D. Chrome's documentation explains why.
- 2D canvas:
drawElementImage()updates the element's geometry automatically by default. - WebGL and WebGPU: The browser can't know where your shader puts the texture. Developers must pass a transform to
updateElementGeometry(). - What failure looks like: In Chrome's own phrasing, the card keeps turning in its example, but clicks still land where it used to be. That quote is from Chrome's docs, not the search results, so treat it as a paraphrase of the documented behavior.
- Accessibility tree: Drawable content is generally exposed like normal DOM. An element with no established geometry is reported without geometry information. Screen readers can still reach the semantics, but visual aids such as magnifiers can filter it out.
So the Chrome team's claim that the API removes the trade-offs needs a qualifier. It removes the need for a shadow DOM, but it doesn't remove the developer's responsibility to keep geometry current.
Security and silent failures
The WICG explainer says rendered snapshots must not expose anything page scripts couldn't otherwise observe. Excluded material includes:
- cross-origin content in iframes and images
- URL-referenced resources
- tainted canvases
- some SVG references
- visited-link state
- spelling markers
- captions and video controls
The Register adds that the API doesn't signal when it declines to copy such data. It says the community has filed bug reports about apparent silent failures. I couldn't independently confirm that report in the primary documents. Still, the spec's exclusion list makes blank or missing content from cross-origin resources a plausible thing to test for.
A related silent failure showed up in the ecosystem. A PlayCanvas engine pull request says Chrome 157 removed the API names the engine had used, so HTML textures stayed blank with nothing logged. The fix moved to the new content="drawable" markup instead of the earlier layoutsubtree, and kept the old path as a fallback for Chrome 150–154. The html-in-canvas.dev site says the same rename applies: Chrome 157 requires the drawable attribute on every element passed to drawElementImage(). If you built against flagged builds, expect to revisit your code.
Edge: likely, not officially confirmed
The Register says Edge 157 "unofficially appears" to support at least some of the actions. The independent evidence is community testing, not a Microsoft statement:
- A GitHub pull request in the underglass project, a React layer for WebGPU effects, reports testing unflagged Edge 157.0.4341.42 on Windows 11 on November 11, 2026. It found all HTML-in-Canvas methods present.
- The html-in-canvas.dev documentation says Edge and other Chromium forks usually follow Chromium's defaults, so expect the API on Chromium 157+ builds.
For Windows developers, that means Edge is probably a working target alongside Chrome. Plan on feature detection anyway, since I found no Microsoft documentation confirming it. Edge enterprise admins should note that the API arrives with Chromium updates, not as a separate setting.
Cross-browser reality
Neither Firefox nor Safari supports it yet, according to html-in-canvas.dev. That makes fallbacks mandatory, and Google's guidance agrees. Its Modern Web Guidance page calls checking for support mandatory. Chrome's suggested feature test creates a canvas, sets content to drawable, and checks whether the property reads back as drawable. Fallbacks include an alternative UI, floating HTML overlays, or libraries such as html2canvas, dom-to-image and three-html-render.
Framework support is already broad. Chrome lists Three.js (experimental, via THREE.HTMLTexture), PlayCanvas, Babylon.js, PixiJS (v8.19.0 and later) and CanvasUI.
Standards status
The Register says the API has been submitted for inclusion in the WHATWG HTML Living Standard. It began as a WICG incubation. That is not the same as being a finished cross-vendor standard. Right now it is a Chrome-and-Chromium feature.
Creative or "stupider"?
The Register's examples are fun:
- Wes Bos's notes app turned into a Duck Hunt target.
- A "Margin Dragon" demo that reflows book text, built in 881 lines of vanilla code.
- An elastic cursor-following displacement effect.
The prediction that marketers will use it to make web pages more irritating is commentary, not a finding. It is plausible, though. Any API that lets pixels bend also lets banners bend.
The same capabilities also help serious work:
- Text-heavy 3D scenes become searchable and translatable.
- Charts built with D3.js get HTML labels.
- Creative tools can export composites that include live DOM.
Practical checklist
- Test for support before use. Never assume a browser version.
- Use
content="drawable"and per-elementdrawable, not the older flag-era names. - In WebGL or WebGPU, call
updateElementGeometry()every frame the object moves. - Hide or remove undrawn views from the DOM, as the spec advises, so assistive tools don't see stale content.
- Test cross-origin images and iframes for blank output.
- Keep a non-canvas fallback for Firefox and Safari.
The summary is that HTML-in-Canvas is a real upgrade for canvas-heavy apps and a ready-made playground for web experiments. It is also another browser capability that developers must adopt carefully, not just switch on.
References
- Say GPU mode needs Chrome or Edge 157, not Canary with flags by RaananW · Pull Request #290 · RaananW/underglass · GitHub github.com
- HTML-in-Canvas ships and could make the web a lot more creative...and a lot stupider The Register · 2026-11-16T19:33:00+00:00
- HTML-in-Canvas in Chrome 157: Interactive DOM inside 2D, WebGL, and WebGPU | Blog | Chrome for Developers developer.chrome.com