Skip to content
Back to search

moli

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/lexmount/moli with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/lexmount/moli'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/lexmount--moli/badge.svg)](/listings/lexmount--moli)

HTML

<a href="/listings/lexmount--moli"><img src="/api/listings/lexmount--moli/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Give this prompt to your AI agent:

Install the skills under https://github.com/lexmount/moli/tree/main/skills,
follow their instructions to download and install the latest prebuilt Moli
binary, then use moli-webfetch to fetch https://example.com and show me the
result.

Direct installation

On Linux or macOS:

curl --proto '=https' --tlsv1.2 -fsSL \
  https://github.com/lexmount/moli/releases/latest/download/moli-installer.sh | sh

On Windows, run in PowerShell:

powershell -ExecutionPolicy ByPass -c "irm https://github.com/lexmount/moli/releases/latest/download/moli-installer.ps1 | iex"

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 495 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <picture>
  3. <source
  4. media="(prefers-color-scheme: dark)"
  5. srcset="assets/moli-browser-banner-dark.jpg"
  6. />
  7. <source
  8. media="(prefers-color-scheme: light)"
  9. srcset="assets/moli-browser-banner.jpg"
  10. />
  11. <img
  12. src="assets/moli-browser-banner.jpg"
  13. alt="Moli Browser — Structure first. Pixels on demand. Open source browser for AI agents."
  14. width="1086"
  15. />
  16. </picture>
  17. </p>
  18. <h1 align="center">Moli</h1>
  19. <p align="center">
  20. <strong>English</strong> |
  21. <a href="docs/README.zh-CN.md">简体中文</a> |
  22. <a href="docs/README.ja.md">日本語</a> |
  23. <a href="docs/README.de.md">Deutsch</a> |
  24. <a href="docs/README.fr.md">Français</a> |
  25. <a href="docs/README.es.md">Español</a> |
  26. <a href="docs/README.ko.md">한국어</a>
  27. </p>
  28. <p align="center">
  29. <a href="https://discord.gg/4eXGtdWWnq">
  30. <img src="https://img.shields.io/badge/Discord-Join%20Community-5865F2" alt="Discord" />
  31. </a>
  32. <a href="assets/moli-feedback-wechat-group.png">
  33. <img src="https://img.shields.io/badge/WeChat-Join%20Community-07C160" alt="WeChat" />
  34. </a>
  35. </p>
  36. <p align="center">
  37. <a href="https://www.producthunt.com/products/lexmount-browser?launch=moli-by-lexmount" target="_blank" rel="noopener noreferrer">
  38. <picture>
  39. <source media="(prefers-color-scheme: dark)" srcset="https://api.producthunt.com/widgets/embed-image/v1/top-post-badge.svg?post_id=moli-by-lexmount&amp;period=daily&amp;theme=dark" />
  40. <img src="https://api.producthunt.com/widgets/embed-image/v1/top-post-badge.svg?post_id=moli-by-lexmount&amp;period=daily&amp;theme=light" alt="Moli by Lexmount - #1 Product of the Day | Product Hunt" width="250" height="54" />
  41. </picture>
  42. </a>
  43. <a href="https://trendshift.io/repositories/128243?utm_source=trendshift-badge&amp;utm_medium=badge&amp;utm_campaign=badge-trendshift-128243" target="_blank" rel="noopener noreferrer">
  44. <img src="https://trendshift.io/api/badge/trendshift/repositories/128243/daily" alt="lexmount%2Fmoli | Trendshift" width="250" height="55" />
  45. </a>
  46. <a href="https://trendshift.io/repositories/128243?utm_source=trendshift-badge&amp;utm_medium=badge&amp;utm_campaign=badge-trendshift-128243" target="_blank" rel="noopener noreferrer">
  47. <img src="https://trendshift.io/api/badge/trendshift/repositories/128243/weekly?language=Rust" alt="lexmount%2Fmoli | Trendshift" width="250" height="55" />
  48. </a>
  49. </p>
  50. Moli is a production-ready headless browser for AI agents. Its on-demand layout
  51. and rendering design combines a complete browser runtime with a lightweight
  52. resource footprint.
  53. Moli helps your AI agent fetch and extract web pages, search the web, and
  54. automate browser tasks.
  55. Use it through the CLI, CDP, WebDriver Classic, or WebDriver BiDi.
  56. Moli supports Linux, macOS, and Windows.
  57. ## Quick start
  58. Give this prompt to your AI agent:
  59. ```text
  60. Install the skills under https://github.com/lexmount/moli/tree/main/skills,
  61. follow their instructions to download and install the latest prebuilt Moli
  62. binary, then use moli-webfetch to fetch https://example.com and show me the
  63. result.
  64. ```
  65. ### Direct installation
  66. On Linux or macOS:
  67. ```sh
  68. curl --proto '=https' --tlsv1.2 -fsSL \
  69. https://github.com/lexmount/moli/releases/latest/download/moli-installer.sh | sh
  70. ```
  71. On Windows, run in PowerShell:
  72. ```powershell
  73. powershell -ExecutionPolicy ByPass -c "irm https://github.com/lexmount/moli/releases/latest/download/moli-installer.ps1 | iex"
  74. ```
  75. ## Showcase
  76. <p align="center">
  77. <a href="assets/moli-game.jpg">
  78. <img
  79. src="assets/moli-game.jpg"
  80. alt="An HTML5 game rendered by Moli and inspected through Chrome DevTools"
  81. width="1200"
  82. />
  83. </a>
  84. </p>
  85. <p align="center">
  86. <sub>An HTML5 game rendered by Moli and inspected live through Chrome DevTools.</sub>
  87. </p>
  88. <p align="center">
  89. <a href="assets/moli-devtools-rust-lang.jpg">
  90. <img
  91. src="assets/moli-devtools-rust-lang.jpg"
  92. alt="rust-lang.org rendered by Moli and inspected through Chrome DevTools"
  93. width="1200"
  94. />
  95. </a>
  96. </p>
  97. <p align="center">
  98. <sub>rust-lang.org rendered by Moli, with its live DOM, CSS, and geometry available in Chrome DevTools.</sub>
  99. </p>
  100. ## CLI usage
  101. ### Extract a page
  102. Render the page as Markdown with Moli's default completion strategy:
  103. ```bash
  104. moli fetch \
  105. --dump markdown \
  106. --wait done \
  107. https://example.com
  108. ```
  109. Or directly return a compact, model-friendly semantic tree:
  110. ```bash
  111. moli fetch \
  112. --dump semantic_tree_text \
  113. --wait-selector body \
  114. https://example.com
  115. ```
  116. For visual output, enable on-demand layout and write a viewport PNG, a full-document PNG, or a paginated PDF:
  117. ```bash
  118. moli fetch --layout --dump screenshot https://example.com > page.png
  119. moli fetch --layout --dump screenshot_full https://example.com > full-page.png
  120. moli fetch --layout --dump pdf https://example.com > page.pdf
  121. ```
  122. To export a page after an explicit interaction, combine `--eval` (or
  123. `--eval-file`) with `--dump`. The expression runs after page readiness;
  124. promises are awaited, and any pending navigation is followed before export.
  125. Its return value is discarded without serialization. An exception fails the
  126. command without emitting a dump.
  127. ```bash
  128. moli fetch --eval 'document.querySelector("button.show-details").click()' \
  129. --dump markdown https://example.com
  130. ```
  131. Only the supplied expression performs interactions. Without `--dump`,
  132. `--eval` retains its expression-value output behavior.
  133. Run `fetch --help` for the complete option list, including output formats,
  134. page-load/response waits, profiles, proxy settings, resource policies, and
  135. tracing options.
  136. ### Start the automation server
  137. ```bash
  138. # Basic automation server for DOM-first workloads
  139. moli serve
  140. # Enable real geometry, coordinate input, and screenshot/screencast surfaces
  141. moli serve --layout
  142. # Also fetch optional image, font, audio, video, media, and text-track resources
  143. moli serve --layout --resource
  144. ```
  145. The same endpoint serves all three protocols: CDP, WebDriver Classic, and
  146. WebDriver BiDi. Playwright can connect directly over CDP:
  147. ```js
  148. import { chromium } from "playwright";
  149. const browser = await chromium.connectOverCDP("http://127.0.0.1:9222");
  150. const context = browser.contexts()[0];
  151. const page = context.pages()[0] ?? await context.newPage();
  152. await page.goto("https://example.com");
  153. console.log(await page.locator("body").innerText());
  154. await browser.close();
  155. ```
  156. The [WebMCP playground](moli-playground/webmcp/README.md) includes a CLI to list
  157. and call any site's native WebMCP tools, plus booking, restaurant, and pizza demos.
  158. ## Why Moli
  159. Three qualities matter most for agent workloads, and Moli brings them together:
  160. - **Full-featured** — real JavaScript, DOM, CSS, networking, storage, layout,
  161. screenshots, and standard automation protocols, all integrated into one
  162. headless browser.
  163. - **Fast** — most automation requests never need visual rendering, so
  164. structure-first operations skip layout and paint entirely.
  165. - **Resource-efficient** — layout and pixels are generated only when needed,
  166. so Moli does not have to continuously maintain and update a fully rendered
  167. visual state.
  168. What most browser automation tasks actually need is page structure, not a
  169. continuously rendered visual world. Moli treats the native DOM and style state
  170. as the single source of truth, triggering layout or software paint only for
  171. operations that genuinely require them.
  172. | Agent request | What Moli does |
  173. | --- | --- |
  174. | Extract HTML/Markdown, query the DOM, run JS, inspect network/storage | Reads browser runtime state directly — does not trigger layout or paint |
  175. | Read an element's box, hit-test coordinates, send coordinate input | Runs one layout calculation and retains only the latest frozen layout tree |
  176. | Capture a screenshot | Rebuilds from the current DOM/style, replaces the frozen tree, renders a fresh frame, and discards its paint state after use |
  177. | Poll a screencast | Compares generation metadata only; clean state emits no frame, while changed state rebuilds and emits one fresh frame |
  178. <p align="center">
  179. <a href="assets/moli_ondemand_rendering_flow.svg">
  180. <img
  181. src="assets/moli_ondemand_rendering_flow.svg"
  182. alt="How Moli handles a request: DOM-first by default, with layout and paint built fresh only on demand"
  183. width="680"
  184. />
  185. </a>
  186. </p>
  187. Moli still includes the complete set of capabilities: V8, CSS, layout, text
  188. shaping, hit-testing, software paint, and more. The only difference is *when*
  189. visual work runs and *how long* its results are retained. This cost model is
  190. especially well suited to crawling, browser-use agents, retrieval pipelines,
  191. evaluation environments, and reinforcement-learning workloads.
  192. ## Current capabilities
  193. - **Complete web runtime** — streaming HTML parsing, native DOM, V8 JavaScript,
  194. modules/timers/microtasks/events, iframes and workers, CSS cascade,
  195. Fetch/XHR/WebSocket, cookies, WebCrypto, and profile-scoped storage
  196. (localStorage, IndexedDB, OPFS).
  197. - **Extraction-optimized outputs** — the CLI directly produces HTML, Markdown,
  198. JSON, semantic text trees, and frame-aware serialization, with
  199. selector/script/response waits and network tracing.
  200. - **Unified automation binary** — CDP, WebDriver Classic, and WebDriver BiDi
  201. share the same kernel and scheduler. No separate ChromeDriver, geckodriver,
  202. or browser installation is required.
  203. - **Real visual capabilities on demand** — add `--layout` to enable complete box
  204. construction, Taffy layout, Parley text layout, layout-backed
  205. hit-testing/input, viewport
  206. screenshots, and low-frequency CPU-rendered DevTools screencast frames.
  207. - **Controllable operational options** — profiles, cookies, HTTP cache, proxies,
  208. resource families, connection limits, timeouts, private-network policy,
  209. user-agent overrides, diagnostic logging, and network diagnostics are all
  210. available.
  211. ## Moli's relationship with Lexmount
  212. Moli is Lexmount's open-source headless browser; Lexmount Browser is the managed
  213. cloud runtime and control plane built around it.
  214. **The open-source headless browser is fully usable without Lexmount Browser.**
  215. ## Cost controls
  216. Expensive browser operations in Moli require an explicit opt-in and are never
  217. enabled by default:
  218. | Mode or option | Behavior |
  219. | --- | --- |
  220. | Default | `LayoutPolicy::Mock` — deterministic geometry in a compatible format, with no real layout or paint |
  221. | `--layout` | `LayoutPolicy::OnDemand` — real layout, geometry, hit-testing, coordinate input, screenshots, screencast |
  222. | `--resource` | Fetch all optional visual/media resource families |
  223. | `--image`, `--font`, `--audio`, `--video`, `--media`, `--text-track` | Enable one specific optional resource family |
  224. | `--profile-dir`, `--http-cache-dir`, `--cookie` | Selectively enable the persistence required by the workload |
  225. Layout is an on-demand snapshot rather than continuously maintained state. The
  226. first geometry request (a cold start) builds a working layout tree from the
  227. current DOM/style, freezes its canonical geometry into an immutable,
  228. DOM-independent `FrozenLayoutTree`, and retains only that latest tree. Ordinary
  229. geometry reads may reuse it even if the page has changed. Screenshots always
  230. rebuild and replace the frozen tree. Each screencast subscription remembers
  231. only an opaque visual-state token: an unchanged token suppresses the poll,
  232. while a changed token triggers one fresh frame. Paint results are never reused.
  233. ## Architecture
  234. Moli is a standalone browser kernel, not a Chromium wrapper. It is built in
  235. Rust, has its own ownership and lifecycle rules, and relies on:
  236. - `libcurl` — network transport and multi-request runtime
  237. - `html5ever` — HTML parsing
  238. - `rusty_v8` / V8 — JavaScript execution
  239. - Servo/Stylo — selectors, cascade, computed style
  240. - Taffy + Parley — box and text layout
  241. - AnyRender/Vello CPU, `usvg`, and the Rust image ecosystem — software rendering
  242. Document and style have a single source of truth: the native DOM and its Stylo
  243. integration. Every real refresh builds a temporary working tree from that
  244. source, optionally produces and consumes one fresh paint snapshot, freezes the
  245. canonical box/fragment geometry into a compact `FrozenLayoutTree`, and discards
  246. the working tree, style borrows, layout caches, diagnostics, and paint state.
  247. Screencast tokens contain generation metadata, never layout or paint data.
  248. Source lookup and hit-test candidates are derived from the frozen tree when
  249. queried. The system has no incrementally maintained layout tree, damage graph,
  250. retained display list, GPU compositor, or persistent window.
  251. ## Benchmark
  252. The following measurements show Moli's current capability envelope. They cover
  253. real websites, automation clients, Chromium/WPT behavior checks, and a large
  254. nextest regression suite.
  255. | Theme | Tests | Moli |
  256. | --- | --- | --- |
  257. | [Web crawl and fetch](#web-crawl-and-fetch) | Mixed public-web crawl, 192 URLs; Web Fetch, 430 live-site tasks and 545 saved pages | 103 useful pages (53.6%); 89.8% pass rate and 39.27% extraction score, first of five browsers |
  258. | [Browser automation](#browser-automation) | Lexbench-Headless-Browser, 1,308 comparable tasks | 81.9% success; Chrome 99.8% |
  259. | [Resource use](#resource-use) | 557 tasks all four local engines completed; one sample agent episode | 15% of Chrome's CPU time and 13% of its peak memory |
  260. | [Web standards](#web-standards) | Selected WPT tests | 1.612 million tests passed |
  261. ### Web crawl and fetch
  262. #### Mixed public-web crawl test
  263. The test covers 192 public URLs from major Chinese and international sites. A
  264. page only counts as successful if it produces meaningful content after
  265. JavaScript runs — an HTTP 200, challenge page, login wall, empty response, or
  266. shell-only application does not count.
  267. | Browser | Useful pages | Success rate | Median time | Median RSS |
  268. | --- | ---: | ---: | ---: | ---: |
  269. | **Moli** | **103** | **53.6%** | **1.43 s** | **73 MiB** |
  270. | Chrome Headless | 101 | 52.6% | 1.43 s | 773 MiB |
  271. | Lightpanda | 85 | 44.3% | 0.97 s | 40 MiB |
  272. | Obscura | 57 | 29.7% | 1.30 s | 39 MiB |
  273. #### Web Fetch
  274. Moli is compared with four other browsers on live sites and on saved pages.
  275. Click a title to switch; each row shows Moli (green) against the range of the
  276. other four. [Full report](https://browser.lexmount.com/blog/webfetch-benchmark)
  277. · reproduce with [Webstone](https://github.com/lexmount/webstone)
  278. ([guide](https://github.com/lexmount/webstone/blob/main/src/harness/web_fetch/README.md)).
  279. <details name="web-fetch-chart" open>
  280. <summary><strong>Live sites · LexBench-Web-Fetch, 430 tasks</strong></summary>
  281. <picture>
  282. <source media="(prefers-color-scheme: dark)" srcset="assets/webfetch-live-dark.svg">
  283. <img alt="Pass rate on 430 live-site tasks. Overall: Moli 386/430 (89.8%), Chromium 234, Lightpanda 228, Obscura 223, Kitesurf 192. Anti-bot: Moli 88/100, best other 37. Popular: Moli 91, best other 58. Dynamic: Moli 90, best other 58. Static: Moli 97, Chromium 99. Documents and media: Moli 20/30, best other 17." src="assets/webfetch-live-light.svg" width="100%">
  284. </picture>
  285. A pass needs both site access and correct content
  286. ([dataset, v1.0.0 edition](https://huggingface.co/datasets/Lexmount/LexBench-Web-Fetch/tree/v1.0.0)).
  287. <details>
  288. <summary>Exact numbers</summary>
  289. | Method | Overall | Static /100 | Anti-bot /100 | Popular /100 | Dynamic /100 | Documents and media /30 |
  290. | --- | ---: | ---: | ---: | ---: | ---: | ---: |
  291. | Moli | **386/430 · 89.8%** | 97 | **88** | **91** | **90** | **20** |
  292. | Chromium | 234/430 · 54.4% | **99** | 5 | 58 | 58 | 14 |
  293. | Lightpanda | 228/430 · 53.0% | 92 | 37 | 38 | 44 | 17 |
  294. | Obscura | 223/430 · 51.9% | 94 | 16 | 53 | 43 | 17 |
  295. | Kitesurf | 192/430 · 44.7% | 90 | 10 | 40 | 41 | 11 |
  296. Cells show tasks passed. The last column combines document content, direct
  297. media, and media embedded in web pages.
  298. </details>
  299. </details>
  300. <details name="web-fetch-chart">
  301. <summary><strong>Saved pages · WebMainBench, 545 pages</strong></summary>
  302. <picture>
  303. <source media="(prefers-color-scheme: dark)" srcset="assets/webmainbench-dark.svg">
  304. <img alt="Extraction quality on 545 saved pages. Overall: Moli 39.27%, Lightpanda 35.00%, Kitesurf 33.43%, Obscura 31.03%, Chromium 27.02%. Code: Moli 91.06%, best other 84.71%. Moli trails the best other method on text, formula, table content and table structure." src="assets/webmainbench-light.svg" width="100%">
  305. </picture>
  306. Main-content extraction scored against human annotations, without live access
  307. ([dataset](https://github.com/lexmount/WebMainBench/tree/lex-main)).
  308. <details>
  309. <summary>Exact numbers</summary>
  310. | Method | Body produced | Overall | Text | Code | Formula | Table content | Table structure |
  311. | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
  312. | Moli | 545/545 | **39.27%** | 40.73% | **91.06%** | 28.20% | 22.62% | 13.75% |
  313. | Lightpanda | 545/545 | 35.00% | 41.52% | 84.71% | 12.97% | 21.81% | **14.00%** |
  314. | Obscura | 543/545 | 31.03% | **41.88%** | 81.82% | **31.39%** | 0.03% | 0.00% |
  315. | Chromium | 545/545 | 27.02% | 39.40% | 35.86% | 21.12% | **25.01%** | 13.73% |
  316. | Kitesurf | 524/545 | 33.43% | 36.99% | 80.70% | 19.32% | 18.25% | 11.87% |
  317. </details>
  318. </details>
  319. ### Browser automation
  320. #### Moli's performance in Lexbench-Headless-Browser
  321. The full [Lexbench-Headless-Browser](https://github.com/lexmount/Lexbench-Headless-Browser)
  322. corpus contains 1,928 tasks covering raw CDP, 13 pinned automation tools
  323. including Playwright, Puppeteer and Selenium, and web-platform semantics. To
  324. include Kitesurf, which is only available as a remote endpoint, the chart below
  325. uses 1,308 comparable tasks. All browsers use the same task selection rules.
  326. <picture>
  327. <source media="(prefers-color-scheme: dark)" srcset="assets/lexbench-five-engine-caliber-b-dark.jpg">
  328. <img alt="Task success rate of five headless browsers over 1,308 comparable tasks: Chrome 99.8%, Moli 81.9%, Kitesurf 62.1%, Lightpanda 53.3%, Obscura 44.9%" src="assets/lexbench-five-engine-caliber-b-light.jpg" width="100%">
  329. </picture>
  330. **Moli 0.1.1 passed 1,071 tasks, a success rate of 81.88%**, ahead of Kitesurf
  331. at 62.08%, Lightpanda at 53.29%, and Obscura at 44.88%; Chrome, the reference
  332. engine, reached 99.85%. Kitesurf ran at k=1, uncovered tasks count as not
  333. passed, and the reproduction conditions of a remote service differ from those
  334. of local binaries. See the benchmark's
  335. [five-engine report](https://github.com/lexmount/Lexbench-Headless-Browser/blob/kitesurf-eval/docs/reports/five-engine-report-20260813.md)
  336. for the full results.
  337. ### Resource use
  338. <picture>
  339. <source media="(prefers-color-scheme: dark)" srcset="assets/lexbench-efficiency-map-dark.jpg">
  340. <img alt="Task success rate plotted against median peak memory per task for the four local engines: Chrome at 99.9% and 697 MiB, Moli at 80.7% and 92 MiB, Lightpanda at 43.8% and 34 MiB, Obscura at 39.5% and 39 MiB" src="assets/lexbench-efficiency-map-light.jpg" width="100%">
  341. </picture>
  342. Kitesurf is a remote service, so its CPU, memory, and process counts cannot be
  343. measured. The resource comparison therefore covers only the four local
  344. engines. A separate 557-task run includes only work completed by all four.
  345. Moli's median CPU time per task was **100.6 ms** and its median peak memory was
  346. **92 MiB**; Chrome recorded **687 ms** and **697 MiB**, respectively. Moli used
  347. about 15% of Chrome's CPU time and 13% of its peak memory. See the benchmark's
  348. [resource card](https://github.com/lexmount/Lexbench-Headless-Browser/blob/main/docs/reports/resource-card-20260812.md)
  349. for the methodology and full data.
  350. #### Sample agent workload
  351. | Metric | Moli | Chromium |
  352. | --- | ---: | ---: |
  353. | CDP ready | 34.85 ms | 169.37 ms |
  354. | Episode active p50 | 33.40 ms | 57.13 ms |
  355. | Peak PSS | 102.46 MiB | 348.82 MiB |
  356. | Peak processes / threads | 1 / 24 | 11 / 123 |
  357. ### Web standards
  358. #### WPT tests
  359. In the current WPT selection used to validate Moli's agent-browser scope, one
  360. full run passed **1.612 million tests**.
  361. ## Project scope
  362. Within the agent-browser scenarios defined in its documentation, Moli is ready
  363. for production use and remains under active development.
  364. Its current intentional boundaries include:
  365. - No GUI browser, persistent window, GPU compositor, or retained multi-frame
  366. paint architecture.
  367. - It does not pursue pixel-for-pixel parity with Chrome or provide
  368. high-fidelity Canvas/WebGL/media playback.
  369. - `--layout` supports software screenshots and native CDP/CLI PDF with embedded fonts
  370. generation, but not every Chrome screenshot or print mode is implemented.
  371. Unsupported protocol paths return explicit errors — Moli never pretends that a
  372. browser action, event, network observation, or visual result occurred.
  373. ## Star history
  374. Generated hourly from the stargazer timeline by [lexmount/moli-metrics](https://github.com/lexmount/moli-metrics).
  375. <picture>
  376. <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/lexmount/moli-metrics/main/assets/star-history-dark.svg">
  377. <img alt="Star history of lexmount/moli" src="https://raw.githubusercontent.com/lexmount/moli-metrics/main/assets/star-history.svg" width="100%">
  378. </picture>
  379. ## License
  380. Unless a file or directory states otherwise, you may use Moli under either the
  381. [Apache License 2.0](LICENSE-APACHE) or the [MIT License](LICENSE-MIT), at your
  382. option. Separately licensed third-party components and fixtures remain subject
  383. to their own licenses and notices. [`license-metadata.json`](license-metadata.json)
  384. records the machine-readable default, and additional distributable notices are
  385. collected under [`licenses/`](licenses/).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.