<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Berkant</title>
    <description>The latest articles on DEV Community by Berkant (@berkantay).</description>
    <link>https://dev.to/berkantay</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F1446787%2Fa8b35218-e1d5-4f18-9c31-ce2338f85f54.jpeg</url>
      <title>DEV Community: Berkant</title>
      <link>https://dev.to/berkantay</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/berkantay"/>
    <language>en</language>
    <item>
      <title>gpucanvas: 5,000 Live React Screens on a WebGPU Infinite Canvas</title>
      <dc:creator>Berkant</dc:creator>
      <pubDate>Wed, 18 Nov 2026 11:32:29 +0000</pubDate>
      <link>https://dev.to/berkantay/gpucanvas-5000-live-react-screens-on-a-webgpu-infinite-canvas-2h6l</link>
      <guid>https://dev.to/berkantay/gpucanvas-5000-live-react-screens-on-a-webgpu-infinite-canvas-2h6l</guid>
      <description>&lt;p&gt;&lt;em&gt;Originally published on &lt;a href="https://berkant.me/blog/gpucanvas-webgpu-infinite-canvas" rel="noopener noreferrer"&gt;berkant.me&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/berkantay/gpucanvas" rel="noopener noreferrer"&gt;gpucanvas&lt;/a&gt; is an open-source TypeScript library that puts thousands of live DOM nodes on an infinite canvas. The GPU draws them. An editor selects, moves and resizes them. WGSL shaders and transitions run on them. An AI agent can read them and point at them.&lt;/p&gt;

&lt;p&gt;The nodes stay real DOM. React state, events, CSS and accessibility work as usual. Click a screen and type into it: the click and the keystrokes go to the real element.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://berkant.me/blog/gpucanvas-webgpu-infinite-canvas" rel="noopener noreferrer"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzp6qgj8yteiz46zgktza.jpg" alt="The same 5,000 live React screens as plain DOM on the left and in gpucanvas on the right" width="800" height="375"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;The same session on both sides: 5,000 live React screens, the same camera path, a message typed and sent. Left, plain DOM under a CSS transform. Right, gpucanvas. Chrome on a MacBook Pro, frame rates measured live. &lt;a href="https://berkant.me/blog/gpucanvas-webgpu-infinite-canvas" rel="noopener noreferrer"&gt;Watch the video on berkant.me&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;In the 30-second benchmark tour at 5,000 screens, gpucanvas runs at &lt;strong&gt;113 to 115 fps and plain DOM at 18 to 20 fps&lt;/strong&gt;. In a longer tour at 10,000 screens, it is 108 fps against 9.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm install gpucanvas
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight tsx"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nc"&gt;GpuCanvas&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;CanvasNode&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="s2"&gt;"gpucanvas/react"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;GpuCanvas&lt;/span&gt; &lt;span class="n"&gt;style&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;width&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"100vw"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;height&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"100vh"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
  &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;cards&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;map&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;card&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;CanvasNode&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;card&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;card&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;card&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;width&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="mi"&gt;240&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;height&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="mi"&gt;150&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
      &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nc"&gt;Card&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;card&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="nc"&gt;CanvasNode&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
  &lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="nc"&gt;GpuCanvas&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;






&lt;h3&gt;
  
  
  Why a DOM Infinite Canvas Slows Down
&lt;/h3&gt;

&lt;p&gt;There are two usual ways to put real HTML on an infinite canvas, and each gives something up.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Plain DOM:&lt;/strong&gt; camera moves → CSS transform on one container → the browser repaints every visible element.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Draw it yourself:&lt;/strong&gt; camera moves → redraw everything in a canvas → fast, but no inputs, focus, CSS or React.&lt;/p&gt;

&lt;p&gt;The first is fine for a hundred cards. With a few thousand full app screens, each a tree of real elements, the frame budget is gone. That is the left side of the video above. The second is fast, but you end up rebuilding a browser inside the browser.&lt;/p&gt;

&lt;p&gt;gpucanvas takes both: the elements stay in the DOM, and the GPU draws their pixels.&lt;/p&gt;




&lt;h3&gt;
  
  
  HTML-in-Canvas
&lt;/h3&gt;

&lt;p&gt;Chrome 157 implements &lt;a href="https://github.com/WICG/html-in-canvas" rel="noopener noreferrer"&gt;HTML-in-Canvas&lt;/a&gt;, a WICG proposal that lets a &lt;code&gt;&amp;lt;canvas&amp;gt;&lt;/code&gt; hold live DOM children and draw them. Two pieces matter here:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;&amp;lt;canvas content="drawable"&amp;gt;&lt;/code&gt; keeps its children as real, laid-out, interactive elements.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;GPUQueue.drawElementImageToTexture()&lt;/code&gt; rasterizes one of those elements straight into a WebGPU texture.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The DOM stays the source of truth, and WebGPU gets a texture of each element to draw however it wants.&lt;/p&gt;

&lt;p&gt;It is on by default in Chrome 157 and later on a computer. On older Chrome, turn on &lt;code&gt;chrome://flags/#canvas-draw-element&lt;/code&gt; and relaunch. Without it, gpucanvas falls back to a CSS-transformed container with the same API, and the demo runs 1,000 screens and says so.&lt;/p&gt;




&lt;h3&gt;
  
  
  Drawing 5,000 Screens in One Call
&lt;/h3&gt;

&lt;p&gt;Calling &lt;code&gt;drawElementImageToTexture&lt;/code&gt; once per element per frame would be far too slow. Each call allocates and fully rasterizes, and Chrome manages about 250 to 550 of them per second in total. Most of gpucanvas is about calling it as rarely as possible.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The pipeline:&lt;/strong&gt; live DOM nodes → pages of 2048 px (one call per page) → texture-array atlas → cull to the view → one instanced draw call. A &lt;code&gt;MutationObserver&lt;/code&gt; sends changed nodes back through a page; rasterized pages are parked with &lt;code&gt;content-visibility: hidden&lt;/code&gt;.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Pages.&lt;/strong&gt; Nodes are packed side by side into pages of 2048 CSS pixels inside the canvas. Chrome records a page as one snapshot, so one call rasterizes dozens of nodes at once.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Rasterize, then park.&lt;/strong&gt; A page with nodes waiting for pixels becomes &lt;code&gt;drawable&lt;/code&gt;. In the next paint event it is drawn into the atlas, whole, or one node at a time when only a few changed. Then it is parked with &lt;code&gt;content-visibility: hidden&lt;/code&gt;, which keeps layout but skips paint. The browser spends nothing on it per frame.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Thumbnails first.&lt;/strong&gt; Every node gets a 1/16 scale thumbnail in an atlas layer that is never evicted, so a zoomed-out view of thousands of screens is always filled in. Sharper snapshots go on top at power-of-two scales, so zooming reuses them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tiles up close.&lt;/strong&gt; Past 100% zoom on a 2x display, only the visible part of a node is rasterized, as sharp tiles, center first.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One draw call.&lt;/strong&gt; Each frame culls nodes against the view and draws every visible one with one instanced quad draw. Panning and zooming never touch the DOM. Raster work has a per-frame budget, so the camera stays smooth while pixels fill in.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Live updates.&lt;/strong&gt; A &lt;code&gt;MutationObserver&lt;/code&gt; marks a node dirty when its content changes. Loading images, web fonts and CSS transitions trigger a redraw too.&lt;/li&gt;
&lt;/ul&gt;




&lt;h3&gt;
  
  
  Clicks Still Reach the Real Element
&lt;/h3&gt;

&lt;p&gt;The pixels on screen come from the GPU, but input has to land on the DOM.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Input:&lt;/strong&gt; pointer or tap → only the page under it is registered for hit testing → Chrome hit tests it where the GPU drew it → the real element gets the click, the typing, the hover.&lt;/p&gt;

&lt;p&gt;Touch has no hover, so a tap makes the node under the finger live and hands the click to the element it landed on. A two-finger pinch zooms and pans the camera. A focused node keeps its page live.&lt;/p&gt;




&lt;h3&gt;
  
  
  What Chrome 157 Does Differently from the Explainer
&lt;/h3&gt;

&lt;p&gt;Building this meant finding where Chrome's implementation differs from the &lt;a href="https://github.com/WICG/html-in-canvas" rel="noopener noreferrer"&gt;WICG explainer&lt;/a&gt;. If you are building on HTML-in-Canvas, these will save you time:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Hit testing needs registration.&lt;/strong&gt; A drawable is hit-tested only after &lt;code&gt;canvas.updateElementGeometry(el, options)&lt;/code&gt; registers it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Hit testing follows &lt;code&gt;canvasTransform&lt;/code&gt;.&lt;/strong&gt; Chrome 157 hit tests at &lt;code&gt;options.canvasTransform&lt;/code&gt;, a matrix in CSS pixels from the element's border box to the canvas. Chrome 156 ignored it and hit tested at the CSS box, positioned with &lt;code&gt;el.style.transform = canvas.getElementTransform(el, drawMatrix)&lt;/code&gt;. gpucanvas handles both.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Newly drawable elements are not reported&lt;/strong&gt; in &lt;code&gt;changedElements&lt;/code&gt;. Their snapshot is available from the next paint event.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cropping still rasterizes everything.&lt;/strong&gt; A source rectangle rasterizes the whole element at the requested scale before cropping. That is why a zoomed-in node moves to a page of its own.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Recording cost scales with drawables.&lt;/strong&gt; It grows with the number of drawables on every &lt;code&gt;requestPaint&lt;/code&gt;. 10,000 always-drawable nodes run at 22 fps even when idle, which is why pages get parked.&lt;/li&gt;
&lt;/ul&gt;




&lt;h3&gt;
  
  
  An Editor, Shaders and an Agent View
&lt;/h3&gt;

&lt;p&gt;Once every node is a texture on the GPU, a lot comes cheap.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6ve2h7ahqrrjgr879ae5.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6ve2h7ahqrrjgr879ae5.gif" alt="Agent marks, a wipe and a dissolve, the glass lens and shockwaves on live components" width="720" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Marks from an agent, a wipe and a dissolve, the glass lens and shockwaves, all on live components.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Editor.&lt;/strong&gt; &lt;code&gt;bindEditor&lt;/code&gt; turns the canvas into a design-tool editor. Click to select, double-click to go a layer deeper, down to any element or React component. Move and resize with snapping guides. The GPU draws the selection outlines, 2 CSS pixels wide at any zoom.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Shader effects.&lt;/strong&gt; Run WGSL on live components: a glass lens, frost, shockwaves, glitch, VHS, or your own. An effect is a function over the node's pixels:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;defineEffect&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="s2"&gt;"gpucanvas"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;scanlines&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;defineEffect&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"scanlines"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;animated&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;params&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;wgsl&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="cm"&gt;/* wgsl */&lt;/span&gt; &lt;span class="sb"&gt;`
    fn effect(input: EffectInput) -&amp;gt; vec4f {
      let color = source(input.uv);
      let y = input.uv.y * input.size.y + input.time * 20.0;
      return color * (0.85 + 0.15 * step(0.5, fract(y / input.params.x)));
    }`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="n"&gt;canvas&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;setEffect&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;node&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;scanlines&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Effects draw from each node's snapshot in the same pass. With an effect on every one of the 5,000 screens, most cost nothing measurable. Glass, the heaviest, costs about 12%.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Snapshots.&lt;/strong&gt; Every node is already on the GPU, so its pixels are one call away, with no headless browser: &lt;code&gt;canvas.snapshot(node)&lt;/code&gt; returns &lt;code&gt;ImageData&lt;/code&gt;, &lt;code&gt;diffImages&lt;/code&gt; shows what changed between two versions, and &lt;code&gt;recordFilmstrip&lt;/code&gt; keeps a history.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Agent view.&lt;/strong&gt; An AI agent reads the canvas the way a person sees it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Agent view:&lt;/strong&gt; canvas → &lt;code&gt;describe&lt;/code&gt; → a JSON tree with ids, roles, text and rects → the agent can &lt;code&gt;capture&lt;/code&gt; an image of any element or region, and point with arrows, pins, notes and cursors.&lt;/p&gt;

&lt;p&gt;A sign-in screen comes back as about 35 entries and 3.5 KB of JSON, read in 3 ms. The agent can capture any element or region as an image, and point at things with marks that follow the camera.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Transitions.&lt;/strong&gt; Dissolve, wipe or fade one node out and another in on the GPU, while both stay live.&lt;/p&gt;




&lt;h3&gt;
  
  
  Benchmarks
&lt;/h3&gt;

&lt;p&gt;Measured on an M-series Mac, Chrome 157, 1600 × 900 window, DPR 1. The tour is a 94-second session from the overview into clusters of app screens, close-ups up to 500% zoom, 20 clicks and typed messages, then back out.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Screens&lt;/th&gt;
&lt;th&gt;gpucanvas avg&lt;/th&gt;
&lt;th&gt;gpucanvas p95&lt;/th&gt;
&lt;th&gt;DOM avg&lt;/th&gt;
&lt;th&gt;DOM p95&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;5,000&lt;/td&gt;
&lt;td&gt;117 fps&lt;/td&gt;
&lt;td&gt;9.2 ms&lt;/td&gt;
&lt;td&gt;23 fps&lt;/td&gt;
&lt;td&gt;50.2 ms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10,000&lt;/td&gt;
&lt;td&gt;108 fps&lt;/td&gt;
&lt;td&gt;16.7 ms&lt;/td&gt;
&lt;td&gt;9 fps&lt;/td&gt;
&lt;td&gt;133.8 ms&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;DOM is the same screens in one CSS-transformed container, which is also gpucanvas's fallback. Press &lt;code&gt;b&lt;/code&gt; in the &lt;a href="https://berkantay.github.io/gpucanvas/" rel="noopener noreferrer"&gt;demo&lt;/a&gt; to run the benchmark yourself.&lt;/p&gt;




&lt;h3&gt;
  
  
  Questions
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;Does gpucanvas work without WebGPU?&lt;/strong&gt; Yes. Where WebGPU and HTML-in-Canvas are missing, it falls back to a CSS-transformed DOM container with the same API. Effects with a CSS look become CSS filters there.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which browsers run the GPU path?&lt;/strong&gt; Chrome 157 or later on a computer, where HTML-in-Canvas is on by default. Firefox, Safari, and iPhone and iPad browsers have no HTML-in-Canvas yet, so they run the DOM version. Since 0.5, &lt;code&gt;snapshot&lt;/code&gt; works there too with a &lt;code&gt;snapshotFallback&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is it only for React?&lt;/strong&gt; No. The core API takes plain DOM elements. &lt;code&gt;gpucanvas/react&lt;/code&gt; adds &lt;code&gt;&amp;lt;GpuCanvas&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;CanvasNode&amp;gt;&lt;/code&gt;, &lt;code&gt;useEditor&lt;/code&gt; and a component picker.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is it ready for production?&lt;/strong&gt; It is early, version 0.5, and the API can still change. Two known gaps: Tab skips nodes on parked pages, so moving focus across pages needs a focus model, and compositing does not run in a worker yet.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What license?&lt;/strong&gt; MIT.&lt;/p&gt;




&lt;h3&gt;
  
  
  Try It
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Demo:&lt;/strong&gt; &lt;a href="https://berkantay.github.io/gpucanvas/" rel="noopener noreferrer"&gt;berkantay.github.io/gpucanvas&lt;/a&gt;. Thirty agent cursors build the first view, then the camera pulls out to all 5,000 screens. Switch the toolbar to Interact and every button works, like a clickable prototype. Try the &lt;a href="https://berkantay.github.io/gpucanvas/?effect=glass" rel="noopener noreferrer"&gt;glass&lt;/a&gt; or &lt;a href="https://berkantay.github.io/gpucanvas/?effect=shockwave" rel="noopener noreferrer"&gt;shockwave&lt;/a&gt; effect.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Code:&lt;/strong&gt; &lt;a href="https://github.com/berkantay/gpucanvas" rel="noopener noreferrer"&gt;github.com/berkantay/gpucanvas&lt;/a&gt;. If it is useful to you, a star helps other people find it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Package:&lt;/strong&gt; &lt;a href="https://www.npmjs.com/package/gpucanvas" rel="noopener noreferrer"&gt;gpucanvas on npm&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>webgpu</category>
      <category>javascript</category>
      <category>react</category>
      <category>opensource</category>
    </item>
    <item>
      <title>I built Lucius to make coding-agent sessions easier to understand</title>
      <dc:creator>Berkant</dc:creator>
      <pubDate>Wed, 29 Jul 2026 20:17:17 +0000</pubDate>
      <link>https://dev.to/berkantay/i-built-lucius-to-make-coding-agent-sessions-easier-to-understand-4677</link>
      <guid>https://dev.to/berkantay/i-built-lucius-to-make-coding-agent-sessions-easier-to-understand-4677</guid>
      <description>&lt;p&gt;Claude Code and Codex are powerful, but longer sessions can become surprisingly difficult to follow.&lt;/p&gt;

&lt;p&gt;The terminal quickly fills with:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;tool calls&lt;/li&gt;
&lt;li&gt;shell commands&lt;/li&gt;
&lt;li&gt;retries&lt;/li&gt;
&lt;li&gt;errors&lt;/li&gt;
&lt;li&gt;test output&lt;/li&gt;
&lt;li&gt;file changes&lt;/li&gt;
&lt;li&gt;long explanations&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;By the end of a session, the important questions are often still unclear:&lt;/p&gt;

&lt;p&gt;What actually changed? Why did it change? What failed? What should I review?&lt;/p&gt;

&lt;p&gt;That is why I built Lucius.&lt;/p&gt;

&lt;p&gt;Lucius is an open-source tool for exploring coding-agent sessions in a clearer, more structured way. Instead of scrolling through a long terminal transcript, you can inspect the session and understand the agent’s work more quickly.&lt;/p&gt;

&lt;p&gt;The goal is not to hide the raw output or blindly summarize everything. It is to make it easier to move between the high-level result and the underlying details.&lt;/p&gt;

&lt;p&gt;I am especially interested in improving the experience around:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;understanding the sequence of actions&lt;/li&gt;
&lt;li&gt;seeing which files were touched&lt;/li&gt;
&lt;li&gt;spotting failures and retries&lt;/li&gt;
&lt;li&gt;reviewing important decisions&lt;/li&gt;
&lt;li&gt;identifying what still needs human attention&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Lucius is still early, so feedback from people who regularly use Claude Code, Codex, or similar coding agents would be genuinely useful.&lt;/p&gt;

&lt;p&gt;How do you review longer agent sessions today? Do you read the full terminal output, inspect only the final diff, or use another tool?&lt;/p&gt;

&lt;p&gt;GitHub: &lt;a href="https://github.com/berkantay/lucius" rel="noopener noreferrer"&gt;https://github.com/berkantay/lucius&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Feedback, issues, contributions, and stars are appreciated.&lt;/p&gt;

</description>
      <category>agents</category>
      <category>opensource</category>
      <category>showdev</category>
      <category>tools</category>
    </item>
  </channel>
</rss>
