ChatLLM Web: a WebGPU model studio that keeps inference inside the browser tab
Private local model studio, AI chat, and agent workspace powered by WebGPU and WebLLM.
At a glance
- What is it?
- ChatLLM Web v3.2 bundles chat, a tool-calling agent workspace and a model catalog into a static site with no application backend. The interesting part is not that it runs LLMs locally, but where it draws the line between what a browser tab can hold and what it cannot.
- Who is it for?
- Adopt ChatLLM Web if you want a no-backend, installable PWA for local chat and file-grounded tool runs on a WebGPU machine, and you accept that every conversation is capped at a 4K context and that agent mode depends on one of three Hermes models. Skip it if you need long-context work, GPU-less laptops, or a server-side deployment you can audit.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 35 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem ChatLLM Web is aimed at
Most browser chat front ends are thin clients. The model sits behind an API, the key sits in the client, and the conversation leaves the device. ChatLLM Web takes the opposite position. The README describes it as a private local model studio, and the architecture backs that phrase: the static application is served by Cloudflare Pages, model assets come directly from their declared Hugging Face and WebLLM library URLs, and the project states it has no application backend, account, API key, analytics or telemetry. The audience is therefore narrow and specific. It is for engineers and technical users who have a WebGPU-capable browser, want to try or use open-weight models without provisioning a GPU host, and care that prompts, attached files and generated artifacts stay in IndexedDB on the machine. It is not aimed at teams that need a shared inference endpoint or a server-side audit trail, because there is no server to audit.
WebLLM in a dedicated worker, and what the catalog actually contains
Inference is handled by WebLLM running in a dedicated worker, according to the README. That worker boundary matters: model execution and token streaming do not compete with the React rendering thread, which is why the UI can show a run rail and a streaming Markdown pane at the same time. The catalog has two layers. The default view offers 20 curated models spanning chat, coding, reasoning, vision and tool use, from SmolLM2 360M at a declared 376 MB up to Qwen 3.5 9B at 6.3 GB. An Advanced switch exposes the full official catalog: 65 logical models backed by 163 official WebLLM records. Quantization variants and 1K variants are grouped under a single logical model, and the app picks q4f16 when the shader-f16 feature is available, falling back to the compatible q4f32 variant where the official catalog provides one. The original model ID stays attached to each conversation and generated message, which is the detail that makes the grouping safe rather than lossy. Every curated model uses a 4K context window, and the default recommendation logic is explicit: Qwen 3.5 2B when WebGPU is present and the browser reports at least 8 GB of device memory, otherwise Llama 3.2 1B.
Running it: static hosting and manifest import
There is no install command in the supplied material, and the project presents itself as a web application rather than a library. The documented entry points are the hosted instance at chatllm-web.pages.dev and the PWA install, which the README says lets you reuse cached models after the first successful load. If you host it yourself, the shape is a Vite and React build deployed to Cloudflare Pages, with the model weights never passing through your origin. The one configuration surface the README describes in any depth is model import: advanced MLC manifests can be imported from approved HTTPS model sources, which is how you add weights outside the shipped catalog. Everything else is in-app state rather than files. Temperature, top-p, max output and the system prompt are stored per conversation, so there is no global config file to edit. That is convenient for a single user and awkward for anyone who wants to pin settings across a team by committing a file.
The agent workspace and its eight-step ceiling
Agent mode is selected in the prompt bar and is bound to the conversation, so a chat thread keeps its mode and model. The tool surface is deliberately small: listing and reading selected context files, searching those files, arithmetic through a sandboxed parser, and listing or reading conversation artifacts are all automatic. Creating or updating an artifact requires diff approval, and the README states that approved Markdown, code, JSON and text artifacts are stored in IndexedDB. The Agent Run Rail records planning, tool calls, approvals, completion, stops and errors. Two constraints stand out. First, each run has an eight-step safety limit, which is a hard cap on multi-step work rather than a tunable. Second, if the current model lacks native function calling, the app asks to load Hermes 2 Pro Mistral 7B; native function calling is listed for three Hermes models only. In practice agent mode means a 3.9 GB or larger download and a model family chosen for you, not the model you were already chatting with. Stop preserves finished steps, while Retry starts a fresh run from the original task, so a partially completed run cannot be resumed from where it stopped.
Where the browser boundary bites
The 4K context is the limitation that shapes everything else. When the input budget is exceeded, the README says complete older turns are omitted and the activity trace reports it. Truncation is at least visible rather than silent, but a coding session over a large file, or a long reasoning chain, will lose early turns. There is no larger-context curated option to move up to. The second boundary is hardware. Compatibility and high-memory states are driven by WebGPU features, buffer limits and declared memory requirements, and the default recommendation drops to Llama 3.2 1B on unknown or lower-memory devices. A machine without WebGPU is not a degraded experience; it is no experience. The third is storage. Models are cached and artifacts live in IndexedDB, so clearing site data removes both, and the README does not describe an export path for artifacts. Compare this with a local runner such as Ollama, which serves models over an HTTP API on your own machine. Ollama decouples the model from the interface, so you can point any client at it, script it, and keep the model on disk outside a browser profile. ChatLLM Web trades that composability for zero installation and a UI that ships with the runtime.
Maintenance, licensing and what to verify
The code is MIT licensed, which permits reuse and modification with the usual attribution requirement; the model weights carry their own licences from their upstream sources, and the README does not restate them, so that is a check to make before any commercial use. Do not read the MIT badge as covering the weights. On maintenance, the release history is dense: v3.0.0, v3.1.0 and v3.2.0 all landed within roughly two days in August 2026, and the v3.2.0 release is titled Local Agent Workspace. Rapid minor releases at that cadence usually mean the agent surface is still moving, so pinning to a specific release is more sensible than tracking main if you depend on artifact diff behaviour. The upgrade cost is mostly re-downloading weights when the catalog changes, since the app caches models locally. Before adopting, verify four things in your own browser: that WebGPU is exposed, whether shader-f16 is available so you get q4f16 rather than q4f32, the device memory figure the browser reports against your intended model's declared VRAM, and whether the three Hermes models are acceptable as your only native function-calling path. If any of those fail, the fallback is not a smaller configuration of the same product. It is a different tool.
Editorial conclusion
Adopt ChatLLM Web if you want a no-backend, installable PWA for local chat and file-grounded tool runs on a WebGPU machine, and you accept that every conversation is capped at a 4K context and that agent mode depends on one of three Hermes models. Skip it if you need long-context work, GPU-less laptops, or a server-side deployment you can audit. Before committing, verify WebGPU and shader-f16 availability in your target browser, confirm the declared VRAM of your chosen model against the device memory the browser reports, and check whether the q4f16 or q4f32 variant is the one the catalog will actually pick.
Community notes