Reepolee Framework · MIT licensed · Beta

A business application you can understand and keep running

Build from the database outward. Reepolee generates visible TypeScript routes, SQL, validation, forms, and translations, then leaves the application in your hands.

Get started
View source
Read the docs
A modern office building exterior reflected in glass

For the work behind your organisation

Reepolee is an open-source Bun application framework for backoffices, internal tools, member systems, administrative workflows, and other long-lived business software. It is designed for one developer or a small team carrying real operational responsibility.

Reepolee Framework is in beta. APIs, generators, and project conventions may still change before 1.0. The source is public so you can evaluate the current implementation directly.

Build the application, not its foundations

Reepolee provides the repeatable parts of database-backed software in one inspectable project. Clone it under the MIT License, adapt the source, and keep the application with the code your organisation already maintains.

  • A complete Bun application

    Server, routes, `.ree` templates, configuration, static assets, and project scripts live together in a repository you can inspect and change.

  • Database-first generators

    Generate schema metadata, validation, CRUD routes, queries, templates, translations, and navigation from the database model.

  • Business-application foundations

    Users, invitations, authentication, authorization, localization, images, modules, and administration routes are already represented.

  • Operational documentation

    Installation, generators, project structure, security, deployment, logs, and upgrades are documented from first run to production operation.

Start static when static is enough

ReeWeb is a complete MIT-licensed static-site generator. Use it alone for sites and documentation, or run it alongside Reepolee when a site later needs managed content, users, or workflows.

Explore ReeWeb
Read the integration guide

The parts a working application needs

Each capability links to implementation documentation, so you can inspect the real workflow instead of relying on a feature list.

Bun application runtime

Server-rendered routes, .ree templates, and plain TypeScript on Bun, organised so you can follow a request from URL to response.

Inspect the implementation

Database-first CRUD

Generate routes, SQL, validation, templates, translations, and navigation from tables, then adapt the result as the domain grows.

Inspect the implementation

Security foundations

Authentication, authorization, invitations, CSRF protection, profiles, and rate limiting are documented framework parts.

Inspect the implementation

No frontend framework

The server sends complete HTML. Browser-native JavaScript handles the interactions that need it, with no hydration layer to maintain.

Inspect the implementation

Agent-ready development

A local-only agent mode and an in-tree MCP server expose application workflows without hiding the project behind another platform.

Inspect the implementation

Owned deployment

Run SQLite or MySQL and deploy on a VPS or on-premise, with queues, caching, and object storage available when needed.

Inspect the implementation

Start from your actual model

The generator makes stable, repetitive decisions consistently. Its output lives beside your domain code, where you can review it, test it, and change it without waiting for a framework extension point.

  1. 1

    Model the data

    Begin with the tables, columns, constraints, and relationships that represent the organisation.

  2. 2

    Generate the first surface

    Use `reeman` and the resource generators to create the schema and CRUD starting point consistently.

  3. 3

    Make it your application

    Adjust routes, validation, queries, templates, and workflows in ordinary project files.

A real generator workflow

bun reeman
bun reeman schema members
bun reeman crud members --translate

The database remains the source of truth. Generation handles stable, repeatable decisions while application-specific behavior stays in code you review.

Read the generator reference

12-minute walkthrough

Watch a fresh project become a working backoffice

This is the complete first run, without a prepared application hidden behind the edit: create the project with bun create, execute the supplied SQL, generate CRUD routes, create an authorised user, and open the resulting indexes and forms.

  1. 1

    Create the project with bun create and verify it with bun dev

  2. 2

    Run the SQL and bulk-generate three CRUD routes with bun reeman

  3. 3

    Log in and use the generated indexes, search, sorting, pagination, and forms

Generated backoffice

A working index route, not an empty scaffold

This authors index was generated from a database table. Pagination, sorting, search, row selection, creation, navigation, and route structure arrive together; the query, handler, template, and translations remain ordinary files.

Generated Reepolee authors index with pagination, sorting, search, row selection, and a create action
See how CRUD generation works

The deployment stays deliberately direct

Reepolee has no production package installation between the code you reviewed and the process serving it. Bun runs the core application, while vendored third-party code is versioned with the project.

  • No production `node_modules` or transitive package upgrades.
  • Vendored code is versioned and maintained with the application.
  • SQLite works as the default database; MySQL is available when the application calls for it.
  • The application runs wherever you can run a Bun process.

The operational model

git pull
bun start

Built for bounded audiences and important daily work

Reepolee is aimed at applications whose staff, members, clients, or customers depend on a system maintained by one developer or a small team. It does not claim to be the answer for every traffic pattern or product category.

  • Membership and association systems
  • Internal administration tools
  • Training and certification records
  • Scheduling and booking backoffices
  • Clinic and veterinary operations
  • Municipal and volunteer networks

Why it is built this way

The product choices are not hidden conventions. These notes explain why we generate visible code, keep the runtime small, choose predictable interfaces, and operate on infrastructure we control.

Read why we built Reepolee

Start with the source

Reepolee is open source under the MIT License. Create a project with bun create reepolee/reepolee, follow the installation guide, and inspect every part of the resulting application. Expect APIs and generators to evolve while the project moves toward 1.0.

Get started
View source
Read the docs