Open-source project
openwebf/webf avatar
openwebf/webf

webf claims sub-100ms cold starts and 20x cheaper DOM updates, and its build matrix has two identical macOS scripts

Bring JavaScript and Web Dev to Flutter

2,518 stars163 forksC++GPL-3.0

At a glance

What is it?
webf is a Flutter package that puts a QuickJS runtime, a DOM and a CSS engine inside a native app instead of a system WebView, so JavaScript and Flutter widgets meet in one view hierarchy. The pitch is aggressive and the packaging is GPL, while the repository itself is a private workspace that ships two lockfiles and three sets of agent instruction files.
Who is it for?
Use it when you want web components inside a shipped Flutter app and can accept a GPL-3.0 dependency plus a JS runtime that implements part of the platform rather than all of it.
Can I use it commercially?
Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
Is it still maintained?
Yes. The repository last received commits 144 days ago.
What is it written in?
Mainly C++, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • openwebf/webf2,518 ★ · +5
Star history
Repository2026-09-302026-11-15
openwebf/webf2.5k2.5k

5 Stars in the last 46 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Every performance number arrives without a device or a method

The deployment section promises production cold start under 100 milliseconds with development at 200 to 300 milliseconds, 60fps and 120fps transform animations with hardware acceleration, and a typical JavaScript heap of 10 to 30MB. The developer experience section adds that batched DOM updates are twenty times cheaper than browser implementations. Further down, the same sub-100ms figure reappears in the performance list with the phrase fast startup. Nowhere in the file is there a device, a build configuration, a Flutter version, a payload size or a named comparison target for any of it. The rendering pipeline description does give a real mechanism, that dirty nodes are tracked so only affected subtrees recalculate and updates are batched into the next frame to prevent layout thrashing, and that JavaScript runs on a dedicated thread. The mechanisms are described; the numbers attached to them are not measured in the file.

It is a runtime, not a browser, and it says so twice

The definition paragraph makes an unusual pair of claims in the same sentence: WebF is a W3C and WHATWG compliant web runtime for Flutter implementing HTML, CSS and the DOM, and it is explicitly not a browser, being an application runtime optimized for building native apps. The architecture section then lists what that runtime contains. QuickJS as the JavaScript engine, supporting ES6+ with async and await, promises, modules, optional chaining and template literals, in a single persistent context per instance. A DOM implementation with capture and bubble event phases, query selectors, classList, custom elements and MutationObserver. A CSSOM layer doing parsing and rule calculation following web standards. The distinction matters for what a framework will and will not find, because the compliance claim covers the parts named and stops there.

You cannot try it in a browser tab

The getting started path is written entirely for web developers, and its first dependency is not a package. You install a preview application called WebF Go, downloaded from a page on the project's own site for macOS, Windows or Linux, or from the App Store and Google Play for mobile, with Node.js latest LTS as the only stated prerequisite. Then you scaffold a normal Vite project:

bash
npm create vite@latest

choose React, Vue, Svelte or another framework when prompted, and run:

bash
cd <your-project-name>
npm install
npm run dev

The step after that instructs you to copy a Network address into the preview app, and there the instructions stop mid-sentence. Nothing in the file shows how a WebF page runs inside an application you build yourself; that part lives in the Add WebF to Flutter documentation. So the first run of this runtime is mediated by a separate binary that has to be fetched before anything happens.

Two lockfiles and a private root sit above the published package

The root manifest is marked private and carries no name and no version. Its entire content is scripts, and they are bridge build recipes: separate entries for macOS, for macOS arm64, for macOS x86_64, for a universal macOS build, for Android, for Linux, for Windows and for iOS, most of them duplicated into a release variant that sets `WEBF_BUILD=Release`. Two of those macOS entries are the same command with different names, since the plain macOS script and the universal one both run `node scripts/build_darwin_dylib` with nothing added. There are also switches for a separate QuickJS build on Android, dynamic STL linking, and profiling enabled through `ENABLE_PROFILE` on Linux and Android. Alongside `package-lock.json` the tree carries `pnpm-lock.yaml`, so two package managers each have a lock, and the actual Dart package lives below in its own directory rather than at the root.

The repository ships agent instructions and a memory directory

Among the top-level entries are `.agents/`, `.claude/` and `.codex/`, three separate configuration directories for three different coding assistants, alongside an `AGENTS.md`, a `CLAUDE.md`, a `.mcp.json` file and a directory called `claude_memory/`. There is also a `skills/` directory. That is a large amount of surface area devoted to how automated tools should approach the codebase rather than to the runtime itself, and none of it is referenced from the README. The rest of the tree is similarly split: a `bridge/` for the native side, a `webf/` for the Flutter package, `native_plugins/` and `native_uis/` for platform integrations, `cli/`, `integration_tests/`, `use_cases/` and a separate `vue_usecases/`, plus `debug-symbols/`, `third_party/`, `licenses/` and a `THIRD_PARTY_NOTICES` file. Submodules are in use, given a `.gitmodules` at the root.

Over-the-air updates are claimed compliant with two store policies

One deployment bullet states that updates can be deployed instantly through a CDN without app store review, and adds in parentheses that this is compliant with Apple App Store and Google Play Store policies. The parenthesis carries no citation, no policy document name and no version of either policy, and the mechanism that would make such a deployment possible is not described anywhere in the file. The same section also claims an application sandbox, keychain and keystore encrypted storage with biometric protection, and HTTPS enforcement, again without saying how any of the three is configured or which platform each covers. For a runtime whose whole purpose is executing JavaScript inside an app, those three are the lines worth reading twice, and they are the lines with the least detail behind them.

Framework and styling support is a list of names, not a compatibility matrix

The compatibility section names React, Vue, Svelte, Preact, Solid and Qwik with the claim that existing components and hooks work without modification. Build tools listed are Vite, marked recommended, plus Webpack, esbuild, Rollup and Parcel, with hot module replacement, tree shaking and code splitting described as supported. Styling lists Tailwind CSS v3, Sass and SCSS, PostCSS, CSS modules, styled components and Emotion. None of these carries a version other than the Tailwind line, none carries a note about which feature of the framework is affected by the runtime implementing part of the DOM, and hot module replacement is asserted in the developer experience section as full support that preserves state across updates. Flutter widgets as HTML custom elements, gestures through `FlutterGestureDetector` and Cupertino components are the native side of the same claim, and they are the part with no web equivalent to check against.

Version 0.24.19 shipped in March while the branch moved in June

The release tags are plain three-part numbers without a leading letter: 0.24.19 on 2026-03-20, then 0.24.18 and 0.24.17 on the same day two weeks earlier, an hour and a half apart. The branch itself was last pushed on 2026-06-24, three months after the newest tag, so the published version and the head of the tree are three months apart with no release in between. The licence is GPL-3.0, which sits next to a `THIRD_PARTY_NOTICES` file and two directories of third-party material, and that matters more here than for a typical Flutter package because this one is linked into the application binary. The pub package is published as `webf`, linked from a badge in the header next to the project's Discord and its X account.

Editorial conclusion

Use it when you want web components inside a shipped Flutter app and can accept a GPL-3.0 dependency plus a JS runtime that implements part of the platform rather than all of it. Do not plan a launch schedule around the performance figures: sub-100ms cold start, 20x cheaper DOM updates, 60fps and a 10 to 30MB heap all appear as bare claims with no device, no build flag and no comparison named, and the same README hedges elsewhere by promising sub-100ms in production and 200 to 300ms in development. Before you start, plan for the tooling rather than the code, because the quickstart needs a separate preview binary from a website or an app store and your own Flutter app must be wired to a native bridge built per platform and architecture. And read the licence before you link it: this is GPL-3.0, not the permissive licence most Flutter packages carry.

Frequently asked questions

What is WebF?

A W3C and WHATWG compliant web runtime for Flutter that implements HTML, CSS and the DOM and runs JavaScript in a browser-like environment. The README is explicit that it is not a browser but an application runtime, with its own Flutter based rendering engine instead of a system WebView.

Which JavaScript engine does WebF use?

QuickJS, supporting ES6+ with async and await, promises, modules, optional chaining and template literals, in a single persistent context per instance. JavaScript runs on a dedicated thread so it does not block the Flutter UI thread.

How do I test a WebF app without building a Flutter app?

Install the WebF Go preview app from the project's download page or the app stores, have Node.js latest LTS available, then scaffold a Vite project with `npm create vite@latest` and run it with `npm install` and `npm run dev`. You load the development server address into the preview app.

What layouts and CSS does WebF render?

A Flutter based layout engine supporting Flexbox, which the README marks recommended, plus positioned layouts in absolute, relative, fixed and sticky forms, and flow layouts. CSS coverage listed includes colours, gradients, 2D and 3D transforms, transitions, animations, variables, media queries and pseudo-classes.

What licence is WebF released under?

GPL-3.0, with a `LICENSE` file at the repository root alongside `THIRD_PARTY_NOTICES`, a `licenses/` directory and a `third_party/` directory. The Dart package is published on pub.dev as `webf`.

Official sources

  1. License: GPL-3.0
  2. openwebf/webf on GitHub
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/openwebf-webf.svg)](https://hysenlabs.com/projects/openwebf-webf)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/openwebf-webf.svg)](https://hysenlabs.com/projects/openwebf-webf)

Was this useful?