Tech News
← Home  ·  All topics

Webgpu

14 GoKawiil briefs on this topic

Chrome runs origin trial for HTML-in-Canvas API letting DOM render inside Canvas

Google engineers Thomas Nattestad and Natalia Markoborodova announced an experimental HTML-in-Canvas API, now available via origin trial, that lets developers draw DOM content directly into a 2D canvas or a WebGL/WebGPU texture. The API aims to keep that embedded UI interactable and accessible while retaining browser features such as text selection, translate, dark mode and autofill.

Developer fine-tunes 360M model to simulate a Linux terminal

A developer built WorldTUI, a 360-million-parameter model based on Qwen2.5-Coder-0.5B, fine-tuned on recorded terminal sessions from real programs run in Docker. The model has no actual shell or filesystem behind it; it predicts screen changes in response to each keypress, and can simulate file creation, vim, tmux, and even the game snake. A browser demo lets users test it, including typing a misspelled command to reveal it's not a genuine shell.

Show HN project compiles JavaScript into WebGPU kernels for parallel search

A developer showcased on Hacker News a tool that converts regular JavaScript—including regex matching, JSON parsing, and highlighting logic—into WebGPU kernels. The demo applies this approach to search across 100,000 JSON documents, running the workload in parallel on the GPU instead of the CPU.

Microsoft launches Xbox Labs to explore AI-driven game porting and remixing

Microsoft is forming a new internal group called Xbox Labs, led by Scott (a games executive), tasked with turning emerging AI techniques—like decompiling and rebuilding games for new hardware, porting PC titles to browsers via WebAssembly and WebGPU, and remixing one game's code into another—into experiences for players and developers. The initiative follows recent community experiments that rapidly ported and transformed major titles using AI tools.

New npm package 'shaders' brings WebGPU effects to React, Vue, Svelte, Solid

A new library called Shaders has launched as an npm package offering over 200 WebGPU-based visual effects—gradients, noise, glass, metal, distortions, blurs and cursor effects—as drop-in components for React, Vue, Svelte, Solid and plain JavaScript. It includes a companion design tool at shaders.com that lets users build effects on a visual canvas and export matching framework code, and the maker says it is already used on thousands of sites by more than 16,000 design engineers.

Gitframes launches as npm package combining Photoshop, After Effects and Blender tools for AI coding agents

Gitframes is a new npm package that bundles compositing, motion graphics, typography and 3D scene rendering into a single lightweight tool meant to be driven by code rather than desktop software. It lets an AI coding agent write a TypeScript composition and render an MP4 directly on GPU hardware via WebGPU, Dawn, Metal or Vulkan, without using a headless browser or screenshot pipeline. The project is currently in beta, with APIs and some features still subject to change.

Matt Keeter releases Halfspace, an experimental IDE for distance-field solid modeling

Developer Matt Keeter has published Halfspace, an experimental IDE for solid modeling using distance fields, along with a browser-based WebGPU demo. The app serves as a showcase for his Fidget kernel, which handles rasterization and meshing, letting users view real-time renders and export models as images or triangle meshes.

OpenDLSS project claims bit-exact Vulkan clone of Nvidia's DLSS 5 neural renderer

A new open-source project called OpenDLSS reimplements the neural network behind Nvidia's DLSS 5, reproducing the same 71-block transformer architecture used in DLSS-NR build 310.8.0, down to matching intermediate outputs at all 75 block boundaries. The project runs on Vulkan using FP8 tensor-core computation, and includes a separate WebGPU browser port that reproduces identical results without tensor cores or FP8 support. Users must supply their own copy of Nvidia's trained model weights to run it.

Developer builds Facet-based unit tests to catch Rust/WGSL struct layout mismatches

A developer working on GPU compute shaders describes a recurring bug class: Rust structs annotated with zerocopy for byte-level serialization can silently diverge from WGSL struct layout rules, causing shader crashes severe enough to require rebooting the machine. Rather than adopt existing tools like wgsl_to_wgpu, wgsl_bindgen, or encase, they built a custom approach using naga to parse WGSL struct layouts and compare them against Rust struct layouts via unit tests, avoiding extra build-script dependencies.

Modder MAAN ports Nvidia DLSS 5 to run inside web browsers via WebGPU

A developer known as MAAN built a browser-based demo that reimplements Nvidia's DLSS 5 neural rendering network using WebGPU compute shaders, hosted on Cloudflare Workers with adjustable settings and sample scenes. The port reportedly works on non-Nvidia GPUs and even macOS, using roughly 147MB of extracted model weights alongside a small JavaScript runtime, though each rendered frame currently takes one to two seconds. MAAN says the weights came from a leaked DLSS 5 library file and plans to release the source code on GitHub soon.

Researcher shows single WebGPU shader can freeze any Mac browser

A security researcher published a proof-of-concept called the Deathray, a tiny WebGPU program that locks up a Mac's graphics pipeline after a single click on a malicious webpage. The bug reproduces across Chrome, Firefox and Safari on Apple Silicon Macs running macOS Tahoe, but does not cause the same lasting freeze on other operating systems. An infinite compute-shader loop feeding a shared buffer into a render shader appears to be the trigger, forcing victims to hard-restart their machine.

New open-source library gpu-lexer brings AI-based syntax highlighting to WebGPU

A developer released gpu-lexer, a 27.5KB JavaScript package that uses a small WebGPU-run neural model to perform syntax highlighting without relying on language-specific grammars. It tokenizes code into words, whitespace and symbols, then predicts each token's category—such as keyword, string or function—based on surrounding context, aiming to work even on languages it has never seen before.