# Mesop: a Python UI framework that is no longer maintained

> Mesop builds web apps and AI demos from plain Python functions with hot reload and no HTML, CSS or JavaScript. The README states it is no longer maintained as of September 30, 2026, so the question is whether the Apache-2.0 code is still worth adopting.

**mesop-dev/mesop** — Rapidly build AI apps in Python

- Repository: https://github.com/mesop-dev/mesop
- Website: https://mesop-dev.github.io/mesop/
- Stars: 6,590 · Forks: 349
- Language: Python
- License: Apache-2.0
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/mesop-dev-mesop

## What Mesop solves, and the notice that changes the decision

Mesop is a Python UI framework for building web apps such as demos and internal apps. The README says it was used at Google for rapid internal app development, and the same README carries a warning that Mesop is no longer maintained as of September 30, 2026, with no further updates, bug fixes, or support. That single line reframes everything else on this page. The framework is still on PyPI, the repository is not archived, and the last push was on 2026-09-18, but the maintainers have stated the end of the line.

The problem it targets is narrow and real. A data scientist or backend engineer has a Python function that does something interesting, usually streaming text through a model, and wants a browser page around it. The usual route means a web framework, a template language, some JavaScript, and a build step. Mesop's answer is that the page is a Python function decorated with me.page, and the UI is composed from Python components. The README describes it as intuitive for UI novices, with a reactive UI paradigm and ready to use components, and it claims you can build custom UIs without writing JavaScript, CSS or HTML. For an internal tool that a handful of colleagues will open, that trade is reasonable. For a public product, the maintenance notice above is the deciding fact.

## How the reactive Python model actually works

A Mesop app is a Python module. You decorate a function with me.page, give it a path and a title, and that function becomes the render function for that route. Inside it you call component functions imported from the mesop package. The README's example uses mesop.labs, a helper module that ships a text_to_text component, so a working chat-style page can be a handful of lines.

The reactive part works through state rather than callbacks. The README calls it an easy to understand reactive UI paradigm: components read from state, and when state changes the affected part of the UI re-renders. This is the same broad model as Streamlit and similar tools, and it is the reason the framework can promise hot reload that reloads the browser and preserves state. Preserving state across a reload matters more than it sounds. In a demo where you have typed a prompt and are watching a streamed answer, a reload that wipes the page is the difference between a usable iteration loop and a painful one.

The composition story is also plain Python. The README says you compose your UI into components, which are just Python functions. There is no separate component file format and no template syntax to learn. The cost of that choice is that everything the browser needs has to be expressible through the component set the framework provides. The repository's demo directory lists components such as button, checkbox, date_picker, date_range_picker, autocomplete, context_menu, card, box, badge and charts, plus chat and chat_inputs. That is a solid set for forms and dashboards. It is not a general-purpose widget toolkit, and the README does not claim otherwise.

## Installing Mesop and running a first app

The README gives a three-step local path. Install the package from PyPI, put the example into main.py, and run it with the mesop command. The package name and the command name are both mesop.

```bash
pip install mesop
```

Then copy the README's example into a file named main.py. It defines a page at the path /text_to_text and delegates rendering to mel.text_to_text, passing a generator function that echoes the input with a capitalized first letter.

```python
import mesop as me
import mesop.labs as mel


@me.page(path="/text_to_text", title="Text to Text Example")
def app():
  mel.text_to_text(
    upper_case_stream,
    title="Text to Text Example",
  )


def upper_case_stream(s: str):
  return "Echo: " + s.capitalize()
```

Start it from the directory containing main.py.

```bash
mesop main.py
```

The README does not state which port the development server binds to, but the repository's docker-compose.yml maps port 32123, which is the port the project's own development environment expects. If you want to try Mesop without installing anything, the README links a Colab notebook, mesop_colab_getting_started.ipynb, and the repository also ships mesop_layout_colab.ipynb. The demo directory contains dozens of single-topic files, from button.py to chat.py, which is the fastest way to see how a given component is called.

## The maintenance notice is not a footnote

The README states plainly that Mesop is no longer maintained as of September 30, 2026, and that no further updates, bug fixes, or support will be provided. The last push was on 2026-09-18 and the newest release in the list is v1.3.6 from the same day, so the project was still moving right up to the announced stop. That does not soften the practical consequence. A bug you hit in October 2026 stays your bug.

There is a second limitation that predates the notice. The README's own disclaimer says this is not an officially supported Google product, even though the README also says Mesop was used at Google for rapid internal app development. Those two statements together mean the framework never carried a support commitment, and now it carries none at all.

The third limitation is scope. Mesop is aimed at demos and internal apps. The README's framing is rapid app development for things like demos, and the components are the ones you need for forms, chat and simple charts. If your requirement is a public-facing site with SEO, accessibility guarantees, or a design system that a frontend team owns, the Python-only component model is the wrong shape, and that would be true even if the project were actively developed.

Finally, the repository layout signals a heavy contributor environment. There is a Bazel WORKSPACE, a Dockerfile based on python:3.10.15-bullseye that installs nvm, Node 18.19.1, Yarn, Bazelisk and ibazel, plus a docker-compose.yml and a Playwright config. Building the framework from source is a much larger undertaking than installing the wheel, and the README points contributors at a separate contributing guide rather than the getting-started page.

## Mesop vs Streamlit: the difference is in the component model

The comparison people reach for is Streamlit, and the two projects solve the same problem from different directions. Streamlit's model is a script that runs top to bottom and re-runs on interaction; the page is whatever the script produced. Mesop's model is a decorated page function plus state, with composition into Python functions that act as components. That difference shows up in how you structure anything larger than one screen. In Streamlit, a multi-section app tends to become functions that emit widgets in sequence. In Mesop, you can define a component function and call it from several pages, which is closer to how a frontend developer thinks about a component tree.

The second difference is the escape hatch. Mesop's README says you can build custom UIs without writing JavaScript, CSS or HTML. That is the pitch, and it is also the boundary: when you need something the component set does not cover, there is no documented path in the README to drop down into HTML or CSS. Streamlit has a broader third-party component ecosystem, though the README for Mesop does not discuss third-party components at all, so that comparison rests on what each project publishes rather than on anything in this material.

The third difference is the one that decides most evaluations today. Streamlit is a live project. Mesop's README states that it is no longer maintained as of September 30, 2026. If you are choosing a framework for work that starts next quarter, that is the whole argument.

## Licence, upgrade cost, and what you inherit

Mesop is licensed under Apache-2.0, and the repository contains a LICENSE file at the top level. Apache-2.0 is a permissive licence that includes an explicit patent grant, which matters if you vendor the code into a company repository and modify it. It also means you may fork the project and keep it alive yourself. This is not legal advice, and the LICENSE file is the authority on what you may do.

The upgrade cost is now fixed rather than ongoing. There will be no v1.3.7 to plan for. The relevant version is v1.3.6, released 2026-09-18, and the release history shows roughly one minor release per month through August and September 2026 before the stop. Pin that version in your dependency file, because a floating constraint buys you nothing when the package stops changing and costs you reproducibility if an unrelated transitive dependency shifts.

What you inherit is the whole surface: the mesop package, its bundled frontend assets, and the Python API. The pyproject.toml in the repository is a packaging stub with version 0.0.1 and a description of "Python UI framework"; it is not the source of the published version number, so do not read it as the version you will install. The practical upgrade question is not whether to move to a newer Mesop, but whether your own Python version still runs the wheel. The project's Dockerfile pins python:3.10.15-bullseye for its development environment, so Python 3.10 is the version the maintainers built against.

## Conclusion

Adopt Mesop only for internal demos and prototypes where a Python-only UI, hot reload and a small codebase matter more than support. Do not adopt it for customer-facing products or anything with a long support horizon, because the README states the project is no longer maintained as of September 30, 2026. Before committing, verify the pinned version on PyPI, run your target Python version against the installed wheel, and confirm the Apache-2.0 LICENSE file is present in the copy you vendor.

## FAQ

### What is Mesop?

Mesop is a Python UI framework for rapidly building web apps such as demos and internal apps. You write the UI as Python functions using components, run it with the mesop command, and the README states you can build custom UIs without writing JavaScript, CSS or HTML.

### Is Mesop still maintained?

No. The README carries a warning that Mesop is no longer maintained as of September 30, 2026, and that no further updates, bug fixes, or support will be provided. The last push to the repository was on 2026-09-18 and the newest release listed is v1.3.6.

### How do I install and run a Mesop app?

Install the package with pip install mesop, put your page code in a file such as main.py, and start it with mesop main.py. The README also links a Colab notebook if you prefer not to install anything locally.

### What licence does Mesop use?

The repository is licensed under Apache-2.0 and includes a LICENSE file at the top level. The README also states that Mesop is not an officially supported Google product.

### Does Mesop require JavaScript or HTML?

The README says you can build custom UIs without writing JavaScript, CSS or HTML, and that components are just Python functions. The README does not document a way to drop down into raw HTML or CSS when the built-in components do not cover a case.

## Sources

- [License: Apache-2.0](https://github.com/mesop-dev/mesop/blob/main/LICENSE)
- [mesop-dev/mesop on GitHub](https://github.com/mesop-dev/mesop)
- [Project website](https://mesop-dev.github.io/mesop/)
- [README](https://github.com/mesop-dev/mesop/blob/main/README.md)
- [Releases](https://github.com/mesop-dev/mesop/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/mesop-dev-mesop