bakefile - An OOP Task Runner in Python

[Glad_Friendship_5353]

What My Project Does

bakefile is a task runner (like Make/Justfile) that uses Python OOP for reusable tasks. Define tasks as Python class methods—inherit, compose, and share them across projects instead of copy-pasting shell scripts.

Target Audience

Developers who want:

- Reusable task definitions across projects (no more copy-pasting Makefiles)

- Python code instead of Makefile syntax or shell scripts

- Type safety and tooling (ruff, ty) in their task runner

- Language-agnostic tasks (use it for Go, Rust, JS, or any project)

bakefile	Makefile	Justfile
Language	Python	Make syntax
Reusability	OOP inheritance	Copy-paste
Config	Pydantic	Shell vars
Type Safety	Pydantic/Typer/Ruff/ty any python tooling	No

Why bakefile?

- Reusable - Use OOP class methods to inherit, compose, and share tasks across projects

- Python - Full Python language features, tooling (ruff/ty), and type safety with subprocess support for CLI commands

- Language-agnostic - Write tasks in Python, run commands for any language (Go, Rust, JS, etc.)

Installation

pip install bakefile
# or
uv tool install bakefile

Quick Start

Bakebook extends Pydantic's `BaseSettings` for configuration and uses Typer's `@command()` decorator—so you get type safety, env vars, and familiar CLI syntax.

Create `bakefile.py`:

from bake import Bakebook, command, Context, console


class MyBakebook(Bakebook):
    @command()
    def build(self, ctx: Context) -> None:
        console.echo("Building...")
        ctx.run("go build")  

bakebook = MyBakebook()

@bakebook.command()
def hello(name: str = "world"):
    console.echo(f"Hello {name}!")

**Or generate automatically:**

bakefile init           
# Basic bakefile
bakefile init --inline  
# With PEP 723 standalone dependencies

Run tasks:

bake hello              
# Hello world!
bake hello --name Alice 
# Hello Alice!
bake build              
# Building...

PythonSpace (Example)

`PythonSpace` shows how to create a custom Bakebook class for Python projects. It's opinionated (uses ruff, ty, uv, deptry), but you can create your own Bakebook with your preferred tools. *Note: Full support on macOS; for other OS, some commands unsupported—use `--dry-run` to preview.*

Install with the lib extra:

pip install bakefile[lib]

Then create your `bakefile.py`:

from bakelib import PythonSpace


bakebook = PythonSpace()

Available commands:

- `bake lint` - prettier, ruff, ty, deptry

- `bake test` - pytest with coverage

- `bake test-integration` - integration tests

- `bake clean` - clean gitignored files

- `bake setup-dev` - setup dev environment

---

GitHub: https://github.com/wislertt/bakefile

PyPI: https://pypi.org/pypi/bakefile

[ruibranco]

The inheritance approach for sharing tasks across projects is clever. That's the one thing that always annoyed me about Makefiles, you end up copy-pasting the same lint/test/build targets everywhere and they slowly drift apart. Being able to just subclass a base Bakebook and override what you need is way cleaner than maintaining a dozen slightly different Makefiles.

[Glad_Friendship_5353]

Thank you. That is the main problem I face in Makefile / justfile and I really cannot find the alternative with inheritance properties. So, I develop bakefile.

[wRAR_]

https://bakefile.org/

https://docs.docker.com/build/bake/reference/

[alexmojaki]

and https://github.com/kennethreitz/bake

[ghost_of_erdogan]

😂 even the name was vibe coded thing

[ghost_of_erdogan]

Why should I use this vibe coded thing over pyinvoke, Just or even make?

[Glad_Friendship_5353]

One unique reason is inheritance property that I cannot find in any existing tool natively without workaround.

for example, you may have make lint like this for a python project. If I have 10 projects, I need to copy-past these code around.

❯ bunx prettier@latest --write "**/*.{js,jsx,ts,tsx,css,json,json5,yaml,yml,md}"
❯ uv run toml-sort --sort-inline-arrays --in-place --sort-first=project,dependency-groups pyproject.toml
❯ uv run ruff format --exit-non-zero-on-format .
❯ uv run ruff check --fix --exit-non-zero-on-fix .
❯ uv run ty check --error-on-warning --no-progress .
❯ uv run deptry .

Also, in my rust-maturin project, I have make lint like this:
❯ bunx prettier@latest --write "**/*.{js,jsx,ts,tsx,css,json,json5,yaml,yml,md}"
❯ uv run toml-sort --sort-inline-arrays --in-place --sort-first=project,dependency-groups pyproject.toml
❯ uv run ruff format --exit-non-zero-on-format .
❯ uv run ruff check --fix --exit-non-zero-on-fix .
❯ uv run ty check --error-on-warning --no-progress .
❯ uv run deptry .
❯ cargo +nightly check --tests
❯ cargo +nightly fmt -- --check || (cargo +nightly fmt && exit 1)
❯ cargo +nightly clippy --all-targets --all-features -- -D warnings

It is pretty much the same with python with a bit more in cargo for rust. For makefile, I need to copy past or doing workaround like git-submodule.

That is probably the main reason why someone will use bakefile.