Model or dataset
Chainlit/chainlit avatar
Chainlit/chainlit

Chainlit: a decorator based chat UI framework for Python, now archived after its community handover

Build Conversational AI in minutes ⚡️

12,504 stars1,766 forksPythonApache-2.0

At a glance

What is it?
Chainlit turns async Python functions into a browser chat app with visible tool steps. The GitHub repository is archived, its last release is 2.12.0 from August 25, 2026, and the company behind it gives no warranty on future updates.
Who is it for?
Chainlit fits a Python developer who wants a chat interface around an LLM or agent loop quickly and can live with a frozen codebase: pip install chainlit, write an on_message handler, run it. It does not fit a team that needs security fixes or new releases from upstream, because the repository is archived with its last push on September 18, 2026.
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?
No. The owners have archived the repository on GitHub, so it is read-only and no longer receives changes.
What is it written in?
Mainly Python, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 13, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • Chainlit/chainlit12,504 ★ · +61
Star history
Repository2026-09-102026-11-13
Chainlit/chainlit12.4k12.5k

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

Editorial analysis

The repository is archived, a year and a half after the original team stepped back

The README carries a notice that changes how to read everything else on the page. As of May 1, 2025, the original Chainlit team stepped back from the project, and the code passed to a GitHub team, Chainlit/chainlit-maintainers, working under a formal Maintainer Agreement. Those maintainers took on code review, releases and security, and Chainlit SAS states it provides no warranties on future updates.

That arrangement produced releases for a while: 2.11.0 on April 7, 2026, 2.11.1 on April 22, 2026, and 2.12.0 on August 25, 2026. The repository has since been archived, and the last push to main was on September 18, 2026. An archived GitHub repository is read-only, so new issues and pull requests cannot be filed there. The consequence for adopters is direct: if a vulnerability turns up in Chainlit or in one of its pinned dependencies, no fix will land in this repository. The "Apply here" link for would-be maintainers still sits in the README, but it now points toward a codebase that accepts no changes.

pip install chainlit, then chainlit hello as the smoke test

The release package installs from PyPI and ships its own command line entry point. The README pairs the install with a check:

sh
pip install chainlit
chainlit hello

If chainlit hello opens the hello app in your browser, the install worked. That is a useful habit for a framework that bundles a web frontend inside a Python package: a successful pip install alone does not prove the UI assets are present and served, while the hello app exercises the whole path from the Python process to a browser tab.

The root pyproject.toml sets mypy to python_version 3.10 and ruff to target-version py310. Those are settings for the repository's own type checking and linting, not a published support matrix, so the README gives no explicit minimum Python version for the PyPI package. Check the package metadata for 2.12.0 before installing it into an older interpreter.

Installing from GitHub needs Node and pnpm, and main is frozen anyway

The development install pulls the Python package from the backend/ subdirectory of the repository:

sh
pip install git+https://github.com/Chainlit/chainlit.git#subdirectory=backend/

This path requires Node and pnpm on the system, since the source tree carries the JavaScript frontend next to the Python backend. A Python only machine or a slim CI image without Node will fail here, even though the PyPI install works on the same machine. The root package.json enforces the package manager too: its preinstall script runs npx only-allow pnpm, so npm or yarn are refused for the JavaScript side.

With the repository archived, the cost of this route no longer buys anything new. The development version used to mean features ahead of the next release. Now main stopped moving on September 18, 2026, so installing from GitHub gets you whatever sat on main at that point, with an extra Node toolchain to install and nothing on PyPI tracking it.

Decorators turn async functions into chat handlers and visible steps

Chainlit is a framework in the sense that you write functions and it calls them. The quickstart builds a demo.py around two decorators. The first marks a function as a step, which the UI shows as an intermediate action:

python
import chainlit as cl

@cl.step(type="tool")
async def tool():
    # Fake tool
    await cl.sleep(2)
    return "Response from the tool!"

The second, @cl.on_message, registers an async function that receives a cl.Message every time the user types into the UI. In the example it awaits the tool step and then sends a final answer, so the user sees the intermediate tool response followed by the reply. Everything is async, and the example uses cl.sleep rather than a blocking call, so code that does slow synchronous work inside a handler needs restructuring. The app starts with:

sh
chainlit run demo.py -w

The README does not explain the -w flag, so look it up in the documentation at docs.chainlit.io before relying on it in a deployment script.

A Python backend wrapped around a pnpm frontend workspace

The repository splits into backend/, frontend/ and libs/, tied together by two workspace systems. On the Python side, uv manages a workspace whose only member is backend, with chainlit resolved from the workspace and a backend dependency group selected by default. Pytest runs from backend/tests with asyncio_mode set to auto, which matches the async handler model. Ruff enforces a long list of rule families, from E and F to FURB and RUF, with isort configured to treat chainlit as first party.

On the JavaScript side, pnpm runs build, test and type-check recursively across packages, and end to end tests run through Cypress with cypress run or cypress open. The pnpm overrides block pins patched floors for transitive packages such as braces, micromatch, postcss, form-data, lodash and undici. Each entry forces a minimum version, such as undici at 6.28.0 or above. Since the repository is archived, that list will not grow, and any advisory published after September 2026 is yours to patch in a fork.

Cloud storage and Bot Framework hooks sit behind untyped imports

The mypy configuration names modules it should not try to type check: boto3.dynamodb.types, botbuilder, azure.storage.blob, azure.storage.filedatalake, google-cloud-storage, google.auth, google.oauth2, langflow, plotly and socketio among them. Code in the repository imports these, which points to integrations with DynamoDB, Microsoft's Bot Framework, Azure and Google Cloud storage, Langflow and Plotly charts.

The README itself names none of these integrations. Its examples section sends readers to the separate Chainlit/cookbook repository, which holds apps built with OpenAI, Anthropic, LangChain, LlamaIndex, ChromaDB, Pinecone and more. For a team choosing Chainlit because of one integration, the consequence is that the GitHub front page will not confirm support. You have to read docs.chainlit.io or the backend source, and with ignore_missing_imports set to true, type checking will not catch a mismatch between Chainlit's calls and a newer release of one of those SDKs.

No Streamlit or Gradio comparison anywhere in the repository

People weighing Chainlit against Streamlit or Gradio will not find that comparison on the Chainlit side. The README makes one positioning claim, that you can build production-ready conversational AI applications in Python in minutes rather than weeks, and it shows a chat loop rather than a general dashboard. That is the clearest signal of scope: the API surface on the page is about messages, steps and a chat UI.

The production-ready line deserves a second look given the repository's state. It was written while a company stood behind the project. Today the same README says Chainlit SAS provides no warranties on future updates, and the code is archived. Production use is still possible, since the Apache 2.0 license lets you fork, patch and redistribute. The burden of keeping the dependency tree patched moves entirely to you, and the cookbook, docs site and help site are external resources whose upkeep the archived repository does not guarantee.

Editorial conclusion

Chainlit fits a Python developer who wants a chat interface around an LLM or agent loop quickly and can live with a frozen codebase: pip install chainlit, write an on_message handler, run it. It does not fit a team that needs security fixes or new releases from upstream, because the repository is archived with its last push on September 18, 2026. Before building on it, check whether a fork with recent commits exists, confirm 2.12.0 works on your Python version, and plan to own any patches yourself.

Frequently asked questions

What is Chainlit?

Chainlit is an open source Python framework for building conversational AI applications with a browser chat UI. You write async handlers such as @cl.on_message and start the app with chainlit run.

How do you install Chainlit?

Run pip install chainlit, then chainlit hello; if the hello app opens in your browser, the install worked. Installing from GitHub instead requires Node and pnpm.

Is Chainlit open source?

Yes. Chainlit is licensed under Apache 2.0. The GitHub repository is archived, so the code remains available but no longer accepts changes.

Is Chainlit production ready?

The README describes it as production-ready, but the repository is archived, its last release is 2.12.0 from August 25, 2026, and Chainlit SAS provides no warranties on future updates. Production users have to handle fixes themselves.

Is Chainlit a framework?

Yes. You register async functions with decorators such as @cl.on_message and @cl.step, and Chainlit calls them as users send messages in its chat UI.

Official sources

  1. Chainlit/chainlit on GitHub
  2. License: Apache-2.0
  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/chainlit-chainlit.svg)](https://hysenlabs.com/projects/chainlit-chainlit)

Star history chart for your README

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

Was this useful?