Open-source project
jupyterlite/jupyterlite avatar
jupyterlite/jupyterlite

JupyterLite: a JupyterLab distribution that runs entirely in the browser

Wasm powered Jupyter running in the browser 💡

4,916 stars458 forksTypeScriptBSD-3-Clause

At a glance

What is it?
JupyterLite rebuilds the Jupyter server-side pieces as browser components and ships them as static files. It is the right tool for hosted, zero-install notebooks and the wrong one for anything that needs a real Python process.
Who is it for?
Adopt JupyterLite if you need a zero-install notebook that can be served from static hosting, embedded in a larger application, or handed to readers as a link. Do not adopt it if your notebooks need a real filesystem, long-running processes, or packages that only build against a native CPython.
Can I use it commercially?
Yes. BSD-3-Clause 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 1 day 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.

From daily snapshots

Star history

  • jupyterlite/jupyterlite4,916 ★ · +16
Star history
Repository2026-09-232026-11-15
jupyterlite/jupyterlite4.9k4.9k

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

Editorial analysis

What problem JupyterLite solves, and for whom

Running a notebook normally means running a Python process somewhere and pointing a browser at it. That process needs a host, a port, a container or a supervisor, and it needs to stay alive while the reader is looking at the page. JupyterLite removes that process. The README describes it as "a JupyterLab distribution that runs entirely in the browser built from the ground-up using JupyterLab components and extensions", and the deployment notes say it is served as static HTTP(S) files with no dedicated application server and no container orchestrator.

The audience follows from that. Documentation sites that want runnable examples, course material that must work on a locked-down laptop, and product teams embedding a notebook inside a larger web application. The README frames the goal as "a lightweight computing environment accessible in a matter of seconds with a single click, in a web browser and without having to install anything". Anyone who needs pandas against a 40 GB Parquet file is not the audience.

How the browser replaces the Jupyter server

The repository is not one application. The root package.json declares Yarn workspaces over app, app/consoles, app/edit, app/lab, app/notebooks, app/repl, app/tree and packages/*, so the same core is assembled into several front ends. The README states the design intent plainly: most packages "focus on providing server-like components that run in the browser (to manage kernels, files and settings), so existing JupyterLab extensions and plugins can be reused out of the box". The contents manager, the settings registry and the kernel manager are reimplemented in TypeScript rather than proxied to a Python process.

Kernels run inside a Web Worker. The README lists two Python options: Pyodide, provided by jupyterlite-pyodide-kernel, and Xeus Python, provided by jupyterlite-xeus. Both compile a Python runtime to WebAssembly and execute it in the browser tab. File persistence goes to IndexedDB, with localStorage as the fallback, which means a notebook saved in one browser profile is not visible in another and is not on any disk you control.

The compatibility table in the README is the part worth reading twice. jupyterlite-core 0.7.0 bundles JupyterLab 4.5.0 and Notebook 7.5.0, and 0.6.0 bundles 4.4.3 and 7.4.3. Every release older than those is marked unsupported, and the note under the table says only the last two releases are actively supported. If you pin an old core because a downstream extension has not caught up, you are outside the supported set.

Installing JupyterLite and building a site with jlpm build

The README points at two paths. For a development install it sends you to CONTRIBUTING.md. For a site of your own it points at the deploy quickstart in the documentation.

The root package.json defines the build scripts. build:lib compiles the library packages through the @jupyterlite/metapackage workspace, and build:app rebuilds each front end. Running build does both in order.

Serving the built site locally

The dev:serve script is the intended way to look at the output. It serves the _site directory on 127.0.0.1, and since the whole distribution is static files, that is genuinely all the server you need.

Watching content changes during development

Editing a notebook and rebuilding by hand gets old quickly. The repository ships a watcher that rebuilds the content and serves it alongside the front end. dev:watch runs the front-end watch and the content watch together, and dev:watch:content calls scripts/dev-build.py with --watch.

Where JupyterLite stops being the right tool

The README is direct that "not all the features available in JupyterLab and the Classic Notebook will work with JupyterLite". That sentence covers more ground than it first appears to.

Anything requiring a subprocess is out. The README describes kernel and session management as basic, and nothing in the project claims a terminal. A notebook that shells out to git, runs a compiler, or starts a server will not work, because there is no operating system underneath the kernel, only the browser sandbox.

The package situation is the second constraint. The demo dependency group in pyproject.toml is a long list of pure-Python or wheel-friendly libraries: altair, bqplot, folium, ipywidgets, matplotlib-inline, plotly, seaborn, tenacity, vega-datasets. That list is the shape of what works. A package whose install step compiles C or Fortran against CPython headers has no path here unless someone publishes a prebuilt WebAssembly wheel for it.

Memory is the third. The kernel, the interpreter and the data all live in one browser tab. A tab that gets closed loses the running state, and the README does not document any recovery mechanism for that beyond the IndexedDB persistence of saved files.

Finally, the version table matters for planning. Only the last two core releases are supported, so a JupyterLite deployment inherits a faster upgrade cadence than a pinned JupyterLab server would.

JupyterLite compared with a hosted JupyterHub

The obvious alternative is a server-backed deployment, JupyterHub or a plain JupyterLab instance behind a reverse proxy. The difference is where execution happens. On JupyterHub the kernel is a real CPython process on a machine you control, with a real filesystem, real subprocesses and the full package ecosystem. It also costs a machine per concurrent user, needs authentication, and needs someone to keep it patched.

JupyterLite inverts every one of those properties. Deployment cost approaches zero because the files are static and cacheable, the README notes it can be embedded in larger applications, and there is nothing to authenticate because there is nothing to protect. In exchange you give up the process model. A user's code runs on their own machine, which is fine for a tutorial and unacceptable if the code needs your data.

The README also lists narrower projects in the same space: Starboard Notebook for in-browser literal notebooks, Basthon for a Pyodide-based notebook, p5-notebook for a minimal p5.js UI, and Notebook.link, described as a cloud-backed in-browser notebook platform based on JupyterLite. The distinction is that JupyterLite is built from JupyterLab components, so existing JupyterLab extensions can be reused.

Licence and upgrade cost

JupyterLite is BSD-3-Clause, both in the repository LICENSE and in the license field of the root package.json. That is a permissive licence and it permits redistribution and modification, including in commercial products. Nothing here is legal advice, and the licence file is the authority if you need to know how attribution must appear in a bundled site.

The upgrade cost is the part teams underestimate. The README ties each jupyterlite-core release to a specific JupyterLab and Notebook version, and supports only the last two. A deployment therefore tracks JupyterLab's release train rather than sitting still. The practical consequence is that a custom federated extension, or a pinned pyodide lock file, needs re-checking on roughly the same schedule as the core releases, which the repository has been publishing about monthly through the 0.8.x line.

Editorial conclusion

Adopt JupyterLite if you need a zero-install notebook that can be served from static hosting, embedded in a larger application, or handed to readers as a link. Do not adopt it if your notebooks need a real filesystem, long-running processes, or packages that only build against a native CPython. Before committing, open the hosted lab at jupyterlite.rtfd.io/en/stable/try/lab and check that your required wheels exist in the pyodide lock file, because a missing wheel is the failure you will hit first.

Frequently asked questions

What is JupyterLite?

It is a JupyterLab distribution that runs entirely in the browser, built from JupyterLab components and extensions. It is part of the Project Jupyter Frontends subproject.

Does JupyterLite execute in the browser?

Yes. Python kernels run in a Web Worker, using Pyodide or Xeus Python, and files are saved to the browser's IndexedDB or localStorage rather than to a server.

Is JupyterLite a static website?

It is served as well-cacheable static HTTP(S) files, locally or on most static web hosts, and needs no dedicated application server. The kernel still runs, but it runs in the visitor's browser rather than on the host.

How do I install JupyterLite?

For a development install the README points at CONTRIBUTING.md, and for a site of your own it points at the deploy quickstart in the documentation. The repository's own build path is jlpm followed by jlpm build, then jlpm dev:serve to serve the _site directory.

How does JupyterLite differ from Jupyter Notebook?

JupyterLite reuses the JupyterLab and Notebook interfaces but replaces the server-side components with browser equivalents for kernels, files and settings. The README notes that not all features available in JupyterLab and the Classic Notebook work with JupyterLite.

Official sources

  1. jupyterlite/jupyterlite on GitHub
  2. License: BSD-3-Clause
  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/jupyterlite-jupyterlite.svg)](https://hysenlabs.com/projects/jupyterlite-jupyterlite)

Star history chart for your README

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

Was this useful?