Onlook maps a click back to a line of code, and admits it only works on Next.js
The Cursor for Designers • An Open-Source AI-First Design tool • Visually build, style, and edit your React App with AI
At a glance
- What is it?
- Onlook is an Apache-2.0 visual editor that loads a Next.js and Tailwind project into a sandbox, instruments the running code so elements map back to their source, and lets you edit either side. The README is honest about its ceiling and about its status: the hosted product is behind a waitlist, and the open-source editor in this repository is the one that came before it.
- Who is it for?
- Onlook suits a designer or engineer who wants to adjust a real Tailwind component visually without hand-editing utility classes, on a project that is already Next.js. Do not adopt it for a Vite or Create React App codebase, for shared editing, or expecting an AI tool you can wire your own MCP servers into, because the project lists non-NextJS support, comments and MCP setup as unticked.
- Can I use it commercially?
- Yes. Apache-2.0 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 25 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
- onlook-dev/onlook27,221 ★ · +460
| Repository | 2026-09-18 | 2026-11-15 |
|---|---|---|
| onlook-dev/onlook | 26.8k | 27.2k |
460 Stars in the last 58 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
This repository is the editor that came before the waitlist
The README draws a line between two things, and the line is easy to miss if you arrive from a search result.
It calls itself the design tool for AI-native designers, now in early access, with a prominent link to join a waitlist. Then a block quote clarifies what you are actually looking at: this is the open-source visual editor that started Onlook, built on Next.js and Tailwind, and the hosted product being built next for AI-native designers is in early access via that waitlist.
So the code in this repository is the foundation the company came from, not the shipping product. The pitch underneath it is an open-source alternative to Bolt.new, Lovable, V0, Replit Agent, Figma Make and Webflow, and that comparison is about the older editor.
For anyone evaluating this, the distinction decides what questions to ask. If you want the open-source editor, you are evaluating this repository. If you want the early-access product, you are waiting on a hosted app, and this code is not what you will be given access to.
The repository also links a separate Onlook Desktop project, and marks component detection as previously in Onlook Desktop, which tells you the surface has already been split once.
The newest release tag is from July 2025 while commits landed in August 2026
The version history and the commit history disagree, and the gap is large.
The three most recent releases are v0.2.32 on 2025-07-17, v0.2.31 on the same day earlier, and v0.2.29 on 2025-04-24. The last push to the default branch is dated 2026-10-21.
So the release feed stopped more than a year before development did. Whatever has changed in `main` since mid-2025 is not in a tagged release, and the version numbering in the two 0.2.3x tags does not reflect the current state of the tree.
The root `package.json` does not help you tell versions apart either. It is `@onlook/repo`, version `0.0.0`, marked private, describing itself as the Onlook Monorepo. That number is a placeholder for a workspace root, not a release identifier.
The practical consequence is that choosing how to install this is a decision with real risk. Track `main` and you get code that is roughly a year ahead of any tag and that nobody has cut a release around. Pin a tag and you pin to 2025, with none of the work that has landed since.
Step five is the whole idea: instrument the code to map elements to their place in code
The how-it-works section lists seven steps, and the fifth and sixth are where the product lives.
The sequence: when you create an app, the code is loaded into a web container. The container runs and serves the code. The editor receives the preview link and displays it in an iFrame. The editor reads and indexes the code from the container. Then the code is instrumented in order to map elements to their place in code. When the element is edited, the element is edited in the iFrame and then in code. And the AI chat has code access and tools to understand and edit the code.
Read that as two representations kept in step. You can right-click any element to open the exact location of the element in code. You can draw in new divs and re-arrange them within their parent containers by dragging and dropping. You can adjust Tailwind styles from a toolbar, manipulate objects and experiment with layouts, previewing the code side by side with the design.
Everything the editor can do depends on that mapping existing. No instrumentation, no element-to-source link, and the visual side degenerates into a preview you cannot edit.
The architecture states its own ceiling, and two of its own checkboxes confirm it
One sentence after the seven steps is the most useful thing in the README:
This architecture can theoretically scale to any language or framework that displays DOM elements declaratively, for example jsx, tsx or html. We are focused on making it work well with Next.js and TailwindCSS for now.
Theorically, in practice, and the last clause is the honest one. The reason is visible in the mechanism: instrumentation maps DOM elements to their place in code, which only works when the framework's output is a declarative DOM tree rather than an opaque render.
The feature checklist agrees. Under Advanced project support, both Support non-NextJS projects and Support non-Tailwind projects are unticked, and they are the only two entries in that group.
So the two constraints are separate and both real. Bring a Vite or Create React App project and the DOM is still declarative, so the mapping is plausible, but the project marks it unsupported. Bring a Next.js project that does not use Tailwind and you lose the styling layer the toolbar is built on. Onlook will run on any Next.js and TailwindCSS project, and the import path is either an existing project or starting from scratch inside the editor.
A third of the feature list is unticked, and the gaps are the collaborative ones
The what-you-can-do list is a status board rather than a feature list, with `[x]` and `[ ]` marks, and reading the unticked entries tells you what the tool cannot do yet.
Collaboration is the clearest gap. The group Collaborate with your team has Real-time editing ticked and Leave comments unticked. Without comments, there is no place to leave a note next to a change, so a design review that needs to say something about one specific element has to happen in chat with a screenshot. Real-time editing without comments is simultaneous editing, not review.
Advanced AI capabilities is mostly unticked. Queue multiple messages at once is ticked. Use Images as references and as assets in a project, Setup and use MCPs in projects, and Allow Onlook to use itself as a toolcall for branch creation and iteration are all unticked. The MCP entry is the one to notice if you planned to give Onlook your own tooling, because there is no supported path to it in this repository.
One more unticked item sits inside an otherwise complete group: Drag-and-drop Components Panel. Component detection itself is ticked, and the note says it was previously in Onlook Desktop.
Branching is ticked, so you can experiment with designs without committing to one.
network_mode: host sits next to a ports mapping, and the network must already exist
The compose file is short, and two of its four settings will bite you on a fresh machine.
The service is `web-client`, built from the repository `Dockerfile` with `env_file` pointing at `apps/web/client/.env`, and it declares `ports` mapping 3000 to 3000 with `restart: unless-stopped`. It also sets `network_mode: host`.
Under host networking the container shares the host's network namespace, which makes the `ports` mapping inert. The process listens on the host's port 3000 directly because of `HOSTNAME=0.0.0.0` and `PORT=3000` in the Dockerfile, not because of the mapping. If you change the port you have to change it in two places, and any firewall rule you wrote against the mapping is describing behaviour that is not happening.
The second setting is the compose network declaration:
networks:
supabase_network_onlook-web:
external: true`external: true` tells Docker Compose the network already exists and must not create it. Compose will fail at startup if a network of that name is not present. This is a Supabase network, so on a machine that does not already have Supabase running you have to create it yourself before `docker compose up` will work.
The scripts in the root `package.json` wrap this: `docker:build`, `docker:up`, `docker:down`, `docker:logs` and `docker:restart`, where restart is a full `down` followed by `up -d --build`.
COPY . . before bun install means every file edit invalidates the dependency layer
The Dockerfile is ten meaningful lines and the ordering is the story. It starts `FROM oven/bun:1`, sets `WORKDIR /app`, then sets the build environment: `NODE_ENV=production`, `NEXT_TELEMETRY_DISABLED=1`, `STANDALONE_BUILD=true`, `HOSTNAME=0.0.0.0` and `PORT=3000`.
Then it copies the entire repository in:
COPY . .
RUN bun install --frozen-lockfile
RUN cd apps/web/client && bun run build:standaloneBecause the copy happens before the install, the install layer's cache key includes every file in the working tree. Editing a README, a docs page or a single component invalidates it, and `bun install` re-runs on the next build. A `.dockerignore` sits at the repository root, so what belongs in that context is tunable, but the default is the whole monorepo.
The build is a Next.js standalone build, and the entry point reflects that: `CMD ["bun", "apps/web/client/server.js"]`, a generated file rather than a source entry. `EXPOSE 3000` documents the port, and the healthcheck fetches `http://localhost:3000` on a 30 second interval with a 5 second start period and 3 retries.
`FROM oven/bun:1` is a floating major tag rather than a pinned digest, so the base image is not reproducible across rebuilds either. Pin it if your builds need to be.
The monorepo behind this is declared in the root `package.json` with five workspace globs, `packages/*`, `apps/*`, `tooling/*`, `apps/web/*` and `docs`, which is why several scripts `cd` into a subdirectory before running.
Editorial conclusion
Onlook suits a designer or engineer who wants to adjust a real Tailwind component visually without hand-editing utility classes, on a project that is already Next.js. Do not adopt it for a Vite or Create React App codebase, for shared editing, or expecting an AI tool you can wire your own MCP servers into, because the project lists non-NextJS support, comments and MCP setup as unticked. Verify two things before you commit: which commit you are actually running, since the newest release tag is v0.2.32 from 2025-07-17 while the last push to main is dated 2026-10-21, and whether the external Docker network named in the compose file exists in your environment.
Frequently asked questions
What are the alternatives to Onlook?
The README positions Onlook as an open-source alternative to Bolt.new, Lovable, V0, Replit Agent, Figma Make and Webflow. It also links a separate Onlook Desktop project, and notes that component detection was previously in Onlook Desktop.
Does Onlook work with any React project?
Not quite. Onlook will run on any Next.js and TailwindCSS project, but the feature checklist leaves Support non-NextJS projects and Support non-Tailwind projects unticked. The README says the architecture could theoretically scale to any framework that renders a declarative DOM, but that the team is focused on Next.js and TailwindCSS for now.
How do I run Onlook locally?
The repository ships a Dockerfile and a compose file, and the root package.json wraps them as docker:build, docker:up, docker:down and docker:logs. The compose file expects an env file at apps/web/client/.env and an external Docker network named supabase_network_onlook-web, which has to exist before startup.
Is Onlook still open source?
This repository is, under Apache-2.0. The README separates it from the hosted product, describing itself as the open-source visual editor that started Onlook and saying the hosted product for AI-native designers is in early access through a waitlist.
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/onlook-dev-onlook)Star history chart for your README
[](https://hysenlabs.com/projects/onlook-dev-onlook)Was this useful?