violit 0.8.29: a framework whose requirements.txt drops its own ORM, and a comparison page that stops before the product

requirements.txt is pyproject.toml minus the three database packages

The repository carries two dependency lists and they are maintained separately. `pyproject.toml` names seventeen packages in its `dependencies` array. `requirements.txt` names fourteen. The three that appear in only one of them are `sqlmodel>=0.0.21`, `aiosqlite>=0.20.0`, and `alembic>=1.13.0`, which is to say the entire ORM and migration layer. The order of the shared entries differs too: `websockets` and `bcrypt` come after `jinja2` in `pyproject.toml` and before `markdown` in `requirements.txt`. That matters because the feature list advertises a built-in ORM usable with `vl.App(db=...)`, and an environment assembled from `requirements.txt` has no SQL layer for it to import. Two files, three differences in content, and nothing in either one says which is authoritative.

The desktop runtime is a hard dependency in both files

Violit advertises three runtime modes: run in the browser, an HTMX Lite mode for higher concurrency, and desktop native apps. Only one of those needs a windowing toolkit, and it is declared unconditionally. `pywebview>=5.4` appears in the `pyproject.toml` dependency array and again in `requirements.txt`, with no extra marker and no optional group. Every installation, including a plain browser dashboard with no desktop plans, pulls in a native GUI bridge. The classifier beside it says `Operating System :: OS Independent`, which reads oddly next to a mandatory desktop dependency whose platform support follows whatever the underlying toolkit ships. The comparison table marks Violit as the only framework in its column with built-in desktop compilation, so the capability is real, but the packaging treats it as the default cost rather than an opt-in.

Version 0.8.29 exists in one file and nowhere else

There are no GitHub releases for this repository, and no tag to compare against. The single place the version appears is `version = "0.8.29"` in `pyproject.toml`. Twenty-nine patch iterations on a 0.8 line, with nothing published to mark where any of them landed, is an unusual shape for a package whose metadata declares `Development Status :: 3 - Alpha`. The same metadata sets `requires-python = ">=3.10"` and lists classifiers for 3.10, 3.11, and 3.12, while the README asks for nothing more than `pip install violit`. The version, the maturity claim, and the release record are three separate signals that do not corroborate each other, and a reader has no way to tell which build a given tutorial was written against.

The Python floor is open ended while the classifiers stop at 3.12

Every dependency bound in `pyproject.toml` is a floor with no ceiling. `pandas>=2.2.0` sits beside `numpy>=1.26.0`, and that pairing has a resolution wrinkle: the pandas release numbered 2.2.0 predates NumPy 2, so a resolver taking the newest NumPy available lands on a newer pandas than the one written down. `fastapi>=0.135.0`, `uvicorn>=0.44.0`, and `alembic>=1.13.0` behave the same way. On the interpreter side the classifiers name 3.10, 3.11, and 3.12 and stop there, while `requires-python = ">=3.10"` has no upper bound at all, so a resolver will happily build on a newer interpreter that nothing in the metadata claims to support. Nothing in the repository states a tested range beyond those three classifier lines.

The syntax comparison shows four rivals and stops before Violit

The README sets out to compare how much boilerplate each framework needs for the same tiny interaction, and it opens four snippets. The first is Streamlit:

import streamlit as st

name = st.text_input("Name", "Violit")
st.write(f"Hello, {name}")

The last is RIO, which is a class-based component with a `build` method returning a `rio.Column`. Then the comparison ends, part way through the trade-off line for that fourth framework, at the words "heavier compared to a simple proc". The framework being sold never gets its own snippet in the section written to prove it needs the least scaffolding. Each of the four that do appear is followed by a vibe line and a trade-off line, and Violit is the only entry in the comparison set without either. The install instruction is the one line of setup in the whole file:

pip install violit

An LLM chat example with no HTTP client or model client declared

Eight example directories ship with the source: `examples/01_demo_showcase/`, `examples/02_violit_blog/`, `examples/03_multi_db_sqlite_editor/`, `examples/04_llm_chat_application/`, `examples/05_orm/`, `examples/06_auth/`, `examples/07_shared_state/`, and `examples/99_github_issues/`. The numbering runs one through seven and then jumps to ninety-nine for an app built around the project's own issue tracker. The LLM chat example is the one that strains against the dependency lists. Neither `pyproject.toml` nor `requirements.txt` names a model SDK, and neither names an HTTP client such as `httpx` or `aiohttp`. Whatever transport that example uses, it is not something the package brings with it, so the example and the metadata describe different amounts of work.

The feature matrix claims zero JavaScript and HTML next to Plotly

The comparison matrix grades five frameworks across four axes, and the axes are No Full Rerun, Pure Python with zero JavaScript and HTML, SEO and SSR readiness, and desktop native builds. Violit's own row is marked positive on all four, with the desktop cell annotated as built-in pywebview. The zero JavaScript and HTML claim sits in the same repository as `plotly>=5.24.0` in both dependency lists, and Plotly draws to the browser rather than to a server-side image. It also sits beside a README that is largely raw HTML: a `<video>` element with poster and controls attributes, an anchor-based Product Hunt embed, and `<p align="center">` blocks used for spacing. The README does claim Tailwind-style utility styling through a `cls` parameter, which points at generated class names rather than hand-written markup, so the claim and the dependency list are answering different questions.

Three runtime modes, one console script, and a Repository link that stops at http

The packaging declares exactly one entry point, `violit = "violit.cli:main"`, while the runtime story describes three modes and the comparison table lists them as WebSocket, Lite, and Desktop Native. No flag, subcommand, or environment variable for choosing between them appears in either file, so the switch between a WebSocket app, an HTMX Lite app, and a native window has to live somewhere the README does not reach. The URLs have the same problem in reverse. `Homepage` is `https://violit.cloud` and `Documentation` is `https://doc.violit.cloud`, both matching the README, while the `Repository` entry stops at `http` before the value is readable, leaving open whether the metadata link uses the same scheme as the `https://github.com/violit-dev/violit` address printed a few lines above it. There is also a `README_KOR.md`, a `MANIFEST.in`, and a `doc/` directory, so documentation and packaging live in four places with no index tying them together.

Editorial conclusion

Violit is worth a try if you want Streamlit's top-down style without a full rerun on every click, and its signal design, the vl.App(db=...) entry point, and the HTMX Lite mode are the parts to evaluate first. Before you install, read the dependency list you actually plan to use: requirements.txt is missing sqlmodel, aiosqlite, and alembic, so the ORM only exists on the pyproject path, and pywebview is mandatory in both files even for a browser-only app. Pin the version yourself, because 0.8.29 is the only place it appears and there is no release to fall back on.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. violit-dev/violit on GitHub