# rbx: a YAML driven problem setting pipeline for programming contests

> A Python command line tool that carries a competitive programming problem from a YAML structure through testset generation, verdict checking and packaging for a judge. Published to PyPI as rbx-cp, version 1.4.2, with a mise driven development workflow.

**rsalesc/rbx** — A competitive programming tool to accelerate user journeys of competitive programmers and setters.

- Repository: https://github.com/rsalesc/rbx
- Website: https://rbx.rsalesc.dev/
- Stars: 25 · Forks: 7
- Language: Python
- License: Apache-2.0
- Published: 2026-08-24 · Updated: 2026-08-24 · Language: en
- Canonical page: https://hysenlabs.com/projects/rsalesc-rbx

## Six verbs cover the path from problem to judge package

The feature set maps onto the stages of setting a problem. Structure: problems and contests are described with YAML configuration files, so the shape of the problem lives in a file rather than in a database. Generation: the whole testset is described in one place, mixing manually added testcases with generated ones. Testing: commands run both correct and incorrect solutions against those testcases and judge automatically whether each verdict was the expected one. Verify: testcases and solutions are checked for strict conformance using validators and unit tests. Statements: tooling writes and builds the statement and keeps it in step with the testset. Package: one command packages the problem for whichever judge system you prefer.

## The execution engine is the part kept away from AI

The project states its own policy on generated code, and it draws the line at the engine. Roughly 1400 commits up to 2026 were written without AI assistance. After that, the owner found AI more efficient and less error prone when a human stays in the loop, so AI produced user interface work and other useful additions, all of which pass pull request review and are reviewed by the owner. What is off limits is the execution engine: running solutions and generating tests. Those parts are treated as critical, not expected to change much, and meant to stay stable.

## One console script, rbx, pointing at rbx.box.main:app

The packaging is small on the surface. The distribution on PyPI is `rbx-cp` at version 1.4.2, and a single console entry point wires the CLI:

```
rbx = "rbx.box.main:app"
```

The dependency list is where the scope shows. Terminal work is handled by typer, rich, textual and textual-serve, with pyte for terminal emulation and questionary for prompts. Document building pulls in latexbuild, pypandoc and texsoup. Parsing and configuration rely on lark, pyyaml, ruyaml, ruamel-yaml and yamlfix, with pydantic and pydantic-xml for structured data, gitpython for repository access, and tree-sitter with tree-sitter-cpp for source handling. fastapi, uvicorn and openai-agents are in the runtime dependencies too.

## The prerequisite note says 3.9, the manifest says 3.10

Two version statements disagree. The contributing prerequisites ask for Python 3.9+ alongside uv as the package manager and mise as the task runner. The project metadata sets `requires-python = ">=3.10"` and declares classifiers for Python 3.10, 3.11, 3.12, 3.13 and 3.14, with the operating system marked independent. The manifest is the one your installer will enforce, so a 3.9 interpreter fails at install rather than at some later point. Another pin in the same block carries an inline reason: `requests>=2.34.0` is required because anything below 2.34 warns about chardet 6 through its compatibility check. Pinning notes like that one are the fastest way to understand why a version floor exists at all.

## Every development command is a mise task

Nothing in the contributor workflow is a bare script. Setup clones the repository, enters it, syncs dependencies and installs hooks:

```bash
git clone https://github.com/rsalesc/rbx.git
cd rbx
mise run sync
pre-commit install
```

After that, work happens through the task runner: `mise run sync` installs and syncs, `mise run lock` regenerates `uv.lock`, `mise run lint` and `mise run lint-fix` cover the linter, `mise run format` and `mise run format-check` handle formatting, `mise run check` runs lint and format together, and `mise run test` runs the tests while excluding e2e, slow and docker cases. `mise run test-cov` adds coverage, `mise run test-e2e` runs the end to end suite, and `mise run build` does a clean build. `mise tasks` lists everything available.

## Hooks police quotes, imports and commit messages

The style rules are short and all three are automated. Strings use single quotes. Imports are absolute only, with no relative imports. Commits follow Conventional Commits, and the format is enforced rather than suggested. The pre-commit hooks run ruff check, ruff format and commitizen, so a commit that breaks any of these does not land as written. The submission path matches: create a branch from `main`, make the change, run `mise run check` and `mise run test`, commit in Conventional Commits format, then open a pull request. Contributors who want the local editable install have `activate-venv.sh` at the root.

## A test report is committed at the repository root

The root layout explains how the project is developed. `mise.toml` drives the tasks, `uv.lock` pins the environment, `pytest.ini` and `conftest.py` configure the suite, and `codecov.yml` covers reporting. Alongside them sit two scripts you would not expect in a library: `activate-venv.sh` and `install_prerelease.sh`, plus `run-extension.sh`. A `junit.xml` is committed at the top level, which means a test report from one machine can end up in version control. There is also a `casts/` directory, `docs/` with `mkdocs.yml` for the published documentation, and both a `.claude/` and a `.vscode/` directory next to a `vscode/` folder. Despite a version of 1.4.2 on PyPI, the repository itself has no GitHub releases.

## Conclusion

rbx fits setters who already think in problems.yaml and want generating, verdict checking and packaging in one tool, rather than anyone who just wants a place to run submissions. Verify your Python version against the manifest rather than the prerequisite note, and read the judge configuration expectations before committing a testset.

## FAQ

### What is the definition of a sales tax?

Sales tax is not something this project covers. The project is rbx, a CLI tool for competitive programming setters published on PyPI as rbx-cp, which describes problems in YAML and packages them for a judge system.

### How to explain sales tax to a kid?

Nothing in this repository explains sales tax. The similarity to that phrase comes from the package author, Roberto Sales, who is credited in the project metadata for rbx-cp.

### Which is an example of sales tax?

There is no example of sales tax here, and no tax content of any kind. rbx handles problem statements, testsets and judge packages, with commands for generating, testing, verifying, building statements and packaging.

## Sources

- [Official documentation](https://rbx.rsalesc.dev/)
- [Official README](https://github.com/rsalesc/rbx#readme)
- [Project repository](https://github.com/rsalesc/rbx)

---

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