Plasmo reads your manifest off your filenames
🧩 The Browser Extension Framework
At a glance
- What is it?
- PlasmoHQ/plasmo is a TypeScript framework that derives a browser extension's manifest from the names of your entry files, scaffolds projects through pnpm, and hands publishing to separate services. It ships as alpha software, the newest tagged release is v0.90.5 from 2025-05-17, and the last push to main is dated 2026-10-31.
- Who is it for?
- Pick Plasmo if your team already works in pnpm and wants React and TypeScript entry files to replace a hand-written manifest. Walk away if you need a documented store submission path, a version-pinned list of supported browsers, or a framework you can describe as stable, because none of those are settled inside the repository.
- 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 2 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 November 15, 2026, and from our analysis. They are not legal advice.
Star history
- PlasmoHQ/plasmo13,177 ★ · +21
| Repository | 2026-09-22 | 2026-11-15 |
|---|---|---|
| PlasmoHQ/plasmo | 13.2k | 13.2k |
21 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The filename is the config: popup.tsx, options.tsx, content.ts, background.ts
Plasmo does not ask you to hand-write a manifest for the common surfaces. It reads entry points by name off the disk. The four names it names are popup.tsx for popup changes, options.tsx for the options page, content.ts for the content script, and background.ts for the background service worker. That is the declarative promise reduced to a naming rule: the build derives the manifest from what exists in the project.
The same convention works one directory deeper, which is where a real extension with several sites on it starts to earn its keep:
ext-dir
├───assets
| └───icon.png
├───popup
| ├───index.tsx
| └───button.tsx
├───options
| ├───index.tsx
| ├───utils.ts
| └───input.tsx
├───contents
| ├───site-one.ts
| ├───site-two.ts
| └───site-three.ts
...Notice the shift in form. In the flat layout the entry file is popup.tsx at the root; in the directory layout it is index.tsx inside a folder called popup. And site-one.ts, site-two.ts and site-three.ts are three separate content scripts, not three modules imported by one.
Scaffolding is pnpm create plasmo, and pnpm is not an optional detail
The documented path from an empty directory to a running dev server is three lines:
pnpm create plasmo example-dir
cd example-dir
pnpm devThere is no global install step and no npm or yarn equivalent in the usage section, so the framework is consumed as a scaffolder that writes a project into a directory you choose, and the dev server runs from inside that project. The system requirements ask for Node.js 16.x or later and MacOS, Windows, or Linux, and then mark pnpm as strongly recommended rather than required.
That hedge does not survive contact with the command itself. A team standardized on npm has three lines to translate before anything else works, and the lockfile the scaffolder writes is not the one their other repositories use. The framework's own repository is a pnpm workspace, with pnpm-lock.yaml, pnpm-workspace.yaml and filtered pnpm commands throughout the root scripts, but those files govern the framework's monorepo rather than a scaffolded project. If your organization forbids pnpm, budget for rewriting the toolchain assumptions before the first commit.
Node 16.x is the floor, and the root manifest pins two transitive packages
Beneath the friendly README, the repository's own root package.json does two things worth reading before you adopt the framework. It is a private workspace root named p1asm0, and it carries a pnpm overrides block that forces two transitive dependencies to exact versions:
"@parcel/source-map": "2.1.1",
"react-refresh": "0.16.0"Neither package is part of any API you call. Both hold the toolchain steady: the source map package because the bundler pulls it in transitively, react-refresh because the advertised live-reloading and React HMR loop runs on it. Because the root package.json is private, these pins govern the framework's own monorepo builds.
Anyone auditing how the framework itself is built should read those two lines.
A src sub-directory moves your code but not your assets
Plasmo lets you push source files into a src sub-directory so the project root stops being a wall of tsx files, and the constraint arrives in the same sentence as the permission: assets and other config files will still need to be in the root directory. The reorganization is partial by design, and the root keeps the icon and the configuration no matter how much of the code you relocate.
That boundary is the whole section, and the consequence is that your folder layout will lie to you about what the build requires. A project with everything under src still needs a root level assets directory, and the natural cleanup move of dragging that one directory into src is precisely the change that breaks the build. Config files behave the same way, so a manifest fragment or an env file relocated during the move is not a harmless tidying step either.
Two practical rules fall out of it. Treat the root directory as reserved for assets and configuration, and treat src as the only place source code may live or be moved to. If your team relies on a lint rule or a CI check that scans the root for source files, that check has to be reconfigured after the move, because the assumption that code can be found anywhere in the tree is exactly what this layout retires.
Behind the framework sits a turbo monorepo with five workspace globs
The repository is not one package. Its root package.json declares workspaces of cli/*, api/*, core/*, packages/* and examples/*, and the build scripts for the CLI, packages, api and core are routed through turbo, while the examples build and test scripts and every publish script run through pnpm --filter. Building only the CLI is turbo run dev --filter=plasmo in the dev script and turbo run build --filter=plasmo for its build; the packages, api and core each get their own filtered turbo variant, and the examples are built with pnpm --filter. The top-level entries match that split exactly: api/, cli/, core/, packages/, examples and scripts/, alongside turbo.json, renovate.json, eslint.config.mjs and .prettierrc.mjs.
Publishing is split the same way, and one branch is deliberately looser than the rest. The lab script publishes the CLI workspace with --no-git-checks --tag lab, which means a lab build can leave the repository without passing the git checks that the ordinary publish path runs. That is useful for pre-release distribution and it is also a version you can install by accident if a tag filter is too broad.
Versioning is filtered per workspace too, with v:packages, v:core, v:api and v:cli each bumping a slice, and the manifest carries its own example line: pnpm v:cli patch. For a reader, the practical read is that the monorepo is a maintainer concern, not something a consuming extension inherits, but the publish and lab scripts are how a given version reached the registry you installed.
Remote code bundling is listed, and its limits are not
Remote code bundling appears in the highlighted feature list with Google Analytics given as the example use. Nothing else in the repository narrows it. No rule is stated about which hosts may serve the bundle, no note describes what a failed fetch does at runtime, and no default behavior is documented. The consequence is that the feature's contract has to come from somewhere outside this repository, and a team shipping analytics or any other remotely fetched script through it has to define its own failure path before the first request misses in production, because nothing in the project will define it for them.
The rest of the highlighted list does have boundaries, and they are worth separating. First-class React and TypeScript support, Content Scripts UI, Tab Pages, the Storage API, the Messaging API, .env* files, live-reloading with React HMR, and targeting multiple browser and manifest pairs are all named as built in. Svelte and Vue are named separately as optional support delivered through with-svelte and with-vue packages.
The word carrying that distinction is optional. React and TypeScript are the supported path with the tooling wired in; the other two are bridges living outside the core repository, which means their update cadence and their compatibility with a given Plasmo version are not governed by the core's own release cycle. If your team has already standardized on Svelte or Vue, that gap is the first thing to price.
Publishing is delegated to BPP and Itero, browser support to the docs site
Shipping is not described by the framework. Automated deployment is attributed to BPP, the Browser Platform Publisher, and a separate production cloud called Itero is offered for instant beta testing. What the repository does not state is which store accounts either of those cover, what a review cycle costs, what happens to a build that fails submission, or how a rejected package is diagnosed. The consequence is that a team assuming a deploy pipeline comes with the framework is reading past the end of the documentation.
Browser support is handled the same way, and the delegation is the tell. There is no list of supported browser targets anywhere in the repository. The answer is a pointer to an FAQ page on the documentation site, which means the set of browsers and manifest versions you can target is versioned on a website rather than pinned in the package you depend on. An upgrade of the dependency can therefore change your target surface without a corresponding code change, and the only way to know what a given version emits is to read a page whose contents are not pinned to that version.
For an extension you are about to publish, that is the gap to close first. Write down your target list from the docs page yourself, keep it in your own repository, and treat any divergence between it and what the build actually emits as a bug in your configuration rather than something the framework guarantees.
Alpha software, a 2025 tag, and a push dated 2026-10-02
The repository's own disclaimer is unusually blunt about what it is: Plasmo is currently alpha software, and some things might change from version to version, so please be mindful and use it at your own risk. That sentence sits in the shipping product's README and it is the most important line in it for anyone putting an extension in front of end users.
The release history and the branch activity do not line up, and the gap is the part a careful adopter should notice. The tagged releases recorded for the repository are v0.90.5 from 2025-05-17, v0.90.2 from 2025-02-09 and v0.90.1 from 2025-02-09. Every one of them sits below 1.0, and the three named releases span three months in early 2025 while the branch kept moving afterward: the last push recorded on the default branch, main, is 2026-10-31.
So a team pinning a version tag and a team tracking main are running materially different code, and the surface area of that difference is not described anywhere in the repository. The repository is not archived; check recent commit and issue activity when assessing maintenance. It does not settle which build your extension should depend on. Pin an exact version, record what that version emitted when you built, and treat the disclaimer as a real operational constraint rather than a legal formality.
Editorial conclusion
Pick Plasmo if your team already works in pnpm and wants React and TypeScript entry files to replace a hand-written manifest. Walk away if you need a documented store submission path, a version-pinned list of supported browsers, or a framework you can describe as stable, because none of those are settled inside the repository.
Frequently asked questions
how to install plasmo
There is no global install step. The stated requirements are Node.js 16.x or later on MacOS, Windows, or Linux, with pnpm strongly recommended, and installation happens through the pnpm create plasmo scaffolding command that writes a project into a directory you name.
how to use plasmo
Three commands: pnpm create plasmo example-dir, then cd example-dir, then pnpm dev. After that, popup changes go in popup.tsx, options page changes in options.tsx, content script changes in content.ts, and background service worker changes in background.ts.
Does Plasmo support anything other than React and TypeScript?
React and TypeScript are the first-class support. Svelte and Vue are named as optional support and arrive through separate with-svelte and with-vue packages rather than as integrations built into the core, so their compatibility is not governed by the core's own release cycle.
Where does a Plasmo-built extension get deployed and tested?
Automated deployment is attributed to BPP, the Browser Platform Publisher, and a production cloud called Itero is offered for instant beta testing. The repository does not document which store accounts they cover, what a review cycle costs, or how a failed submission is diagnosed.
What Node.js version does Plasmo require, and is Plasmo stable?
Node.js 16.x or later is required, on MacOS, Windows, or Linux. Stability is answered by the project's own disclaimer, which calls it alpha software, warns that some things might change from version to version, and tells you to use it at your own risk.
Official sources
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.
[](https://hysenlabs.com/projects/plasmohq-plasmo)Star history chart for your README
[](https://hysenlabs.com/projects/plasmohq-plasmo)Was this useful?