# frepple forecasts demand and schedules production around the bottleneck

> frePPLe is an open source supply chain planning application with a C++ planning core, a Django back end and a Vue front end, sold in Community, Enterprise and Cloud editions. The planning logic is built on theory of constraints, pull-based planning and lean manufacturing, and the community edition is released under the MIT licence.

**frePPLe/frepple** — frePPLe - open source supply chain planning

- Repository: https://github.com/frePPLe/frepple
- Website: https://frepple.com
- Stars: 770 · Forks: 338
- Language: C++
- License: NOASSERTION
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/frepple-frepple

## The point where spreadsheets stop being enough

frePPLe describes itself as an easy-to-use and easy-to-implement open source demand forecasting and advanced planning and scheduling tool for manufacturing companies. The framing sentence in the README is about spreadsheets: when spreadsheets no longer suffice to adequately plan and schedule your production, frePPLe offers an easy and cost-efficient way to generate a more optimized plan.

That is a specific audience. This is not a general ERP system, and it is not a warehouse management tool. It is the planning layer: what to make, when to make it, and on what equipment, given a set of constraints and a demand forecast.

The project is published by frePPLe bv from the Netherlands, and the repository is the Community Edition of the product. The homepage is frepple.com, which also carries the documentation, screencasts and build instructions.

The two halves of the product are worth separating early, because they are covered by different documents and they fail in different ways. Demand forecasting reads sales history and computes forecast sales for the future. Production planning and scheduling then turns that forecast into a plan, using rules drawn from well known manufacturing practice. If your problem is a bad forecast, a scheduling tool will not fix it, and frePPLe is explicit about the order of operations here.

## Planning built on constraints, pull and lean

The README names the planning philosophies the algorithms implement, and it spells out what each one means, which is more than most projects do.

Theory of constraints means planning around the bottleneck. Rather than levelling every resource, the plan is organised around the single constraint that limits throughput, which is the practical version of the idea that the constraint decides the schedule.

Pull-based planning means starting production as late as possible and directly triggered by demand. Production is not pushed into the future on a forecast; it is pulled by actual need, which keeps work out of the system until it is required.

Lean manufacturing means avoiding intermediate delays and inventory. That is a direct statement about what the planner is optimising for: less waiting and less stock, not fuller schedules.

These three together describe a planner with a strong opinion about how manufacturing should work, which is a feature when you agree with it and a constraint when you do not. A company with a different planning culture, for example one that builds to forecast with long lead-time buffers, will find some defaults fighting their process.

The forecasting half implements time series algorithms over sales history. The README does not enumerate which algorithms, so the choice of method is something to look at in the documentation and in the source rather than assume from the summary.

## A C++ core, a Django application and a Vue front end

The repository layout makes the architecture clear, and it is a three-language project.

The planning engine is C++. The top level has src/, include/ and a CMakeLists.txt, which is the shape of a native extension, and the project metadata lists a setuptools-rust dependency, which is the bridge used to build and ship that extension into the Python package. C++ is the right choice for a constraint solver that has to run repeatedly over a large data set.

The application around it is Django. There is djangosettings.py at the root, a freppledb/ package holding the models, a frepplectl.py command line entry point, and the standard Django layout with app/ and templates under freppledb/. The classifier in the project metadata says Framework :: Django.

The front end is Vue, and it is a pnpm workspace with a Gruntfile.js, a vue.config.js, a package.json for the frepplejs package, and translation tooling: an extract-vue-translations.js script, a vue-i18n-extract config, and a translations.sh shell script. The gettext and easygettext dependencies in the JavaScript packages show a gettext-based translation workflow for the interface.

The Python and JavaScript sides are versioned separately, which is worth noting. The JavaScript package is version 4.0.0 and marked private, meaning it is not published to a registry, while the Python package version in pyproject.toml reads 10.0.0.

## Install from Docker, from a tarball, or not from the deb package

The README lists four download formats, and one of them carries a warning.

The Ubuntu 24 .deb package on the releases page is marked deprecated. The Docker container is published on the GitHub packages container registry for frepple-community. The source tarball or zip file is on the releases page, as is a documentation zip file.

The Docker route is the shortest path to a running instance, and the fact that the community image is published to a package registry rather than only as a tarball means you can pull a specific version instead of tracking a moving branch.

The source route is the one that needs the documentation. The README defers to frepple.com for documentation, screencasts and build instructions, and given the mix of C++, Python and JavaScript with a pnpm workspace, a build from source is a real project rather than a one liner. The repository has a .devcontainer directory and a continuous integration badge for an ubuntu24 workflow, so there is a containerised development environment to model your own on.

One thing to keep straight when following the instructions: the two languages are versioned independently, so the version of the front end in the repository is not the version of the release you are deploying.

## Pinned Python dependencies and a fork of Django

The Python dependency list is pinned exactly, which tells you a lot about how the project treats reproducibility. A slice of it:

```bash
djangorestframework == 3.17.2
psycopg2 == 2.9.12
daphne == 4.2.2
uvicorn == 0.54.0
```

The list continues with django-bootstrap3, django-filter, openpyxl, lxml, PyJWT, requests, python-dateutil, pillow, psutil, paramiko, autobahn, channels, attrs, Twisted with tls and http2, django-allauth, and portend.

Two entries deserve attention. psycopg2 is pinned, so PostgreSQL is the database in practice, and the pinned version of a database driver decides which PostgreSQL versions you can build against. The second is the last line, a URL rather than a package name: a Django tarball pulled from the frePPLe GitHub organisation at tag frepple-10.0. So the application runs on a fork of Django maintained by frePPLe, not on upstream Django, and the fork version tracks the 10.0 line.

The asynchronous stack is there as well, with daphne and uvicorn alongside channels and Twisted, which is what a real time planning interface needs to push updates to a browser rather than poll.

The project metadata is more permissive than the requirements file: requires-python is >=3.8, and the build backend is setuptools with a requirement of setuptools >= 61.0. The black configuration targets py312, so the development environment is on a much newer Python than the minimum the metadata advertises.

## Three editions, and the licence that separates them

frePPLe is not a single licensed artefact, and the README describes the split plainly.

The Community Edition is released under the MIT licence. The Enterprise Edition can be purchased from frePPLe bv, and it provides additional functionality and professional support. The Cloud Edition provides the same capabilities as the Enterprise Edition, but is hosted as a service in the cloud, fully supported and maintained by frePPLe bv.

The practical consequence is that the open source repository gives you the Community Edition, and the features you might expect from a mature planning suite may not all be in it. The README does not enumerate what the Enterprise edition adds, so the boundary has to be checked with the vendor rather than inferred from the repository.

On the licence file itself, the repository holds a COPYING file, and the project metadata points the licence at that file, while the classifier says MIT License. The licence identifier GitHub shows for the repository is a custom one that it cannot classify, which is a common outcome when a project ships its licence text in a file with a non-standard name or an extra clause. If the MIT grant matters to you, read COPYING rather than trusting the badge.

Everything else in the repository, the C++ engine, the Django application, the front end, is open, and the source is on GitHub under the frePPLe organisation.

## Regular community releases and a fast moving main branch

The release record shows a project on a steady cadence. The recent Community Edition releases are 9.19.0 on 2026-10-09, 9.18.1 on 2026-08-30 and 9.18.0 on 2026-08-28, and the last push to the master branch was on 2026-10-20.

The version numbering deserves one note. The release tags are in the 9.x line, while the Python project metadata in the repository reads 10.0.0 and the Django dependency is pinned to a frepple-10.0 tarball. The 10.0 line is therefore in development on master, and the 9.x tags are the published Community releases. If you deploy from a tag you get 9.x, and if you build from master you get 10.0.0 in development.

The repository also carries the usual signs of a long-lived project with a large contributor base. There is an AUTHORS file, a CONTRIBUTING.md, a SECURITY.md with a vulnerability disclosure policy, a doc/ directory, a test/ directory, a contrib/ directory for contributed extensions, and a .github/ directory with the CI workflows. The JavaScript side uses husky with lint-staged so that formatting and linting run on staged files before a commit, and the lint-staged configuration applies eslint --fix to JavaScript and TypeScript files and prettier to everything else.

The translation tooling is a decent proxy for the project's reach. Extracting strings with gettext and easygettext, and maintaining a vue-i18n extraction configuration, is work that only a project with a genuinely international user base ends up doing.

## Conclusion

frepple fits a manufacturing company whose planning has outgrown spreadsheets but whose budget rules out a commercial planning suite, and it fits teams that want the forecast, the constraint plan and the detailed schedule in one application they can extend. It is the wrong choice if you need a feature that only the Enterprise edition ships, since the Community edition is the one published under the MIT licence, and it is the wrong choice if your team cannot run a Django application with PostgreSQL and a compiled C++ extension. Verify first that the Docker image or source tarball you plan to deploy matches the 9.x Community release line, that your PostgreSQL version is supported by the pinned psycopg2 build, and that the features you actually need are present in the Community edition rather than planned for the Enterprise one.

## FAQ

### What does frePPLe do?

It is an open source demand forecasting and advanced planning and scheduling tool for manufacturing companies. It implements time series forecasting over sales history, and planning algorithms based on theory of constraints, pull-based planning and lean manufacturing.

### How do I install frePPLe?

The README lists a Docker container published for frepple-community, a source tarball or zip and a documentation zip on the releases page, and an Ubuntu 24 deb package that is marked deprecated. Build instructions and screencasts are on frepple.com.

### Which database does frePPLe use?

The pinned dependency list includes psycopg2, the PostgreSQL adapter, so PostgreSQL is the database in practice. The project metadata also classifies the package as Framework :: Django and Intended Audience :: Manufacturing.

### What is the difference between the frePPLe editions?

The Community Edition is released under the MIT licence. The Enterprise Edition can be purchased from frePPLe bv and adds functionality and professional support, and the Cloud Edition provides the same capabilities as the Enterprise Edition but hosted as a service.

### What is the difference between a frePPLe 9.x release and the 10.0 version in the repository?

The published Community Edition tags are in the 9.x line, with 9.19.0 released on 2026-10-09, while the project metadata in the repository reads 10.0.0 and the Django dependency is pinned to a frepple-10.0 tarball, so the 10.0 line is what master carries.

## Sources

- [frePPLe/frepple on GitHub](https://github.com/frePPLe/frepple)
- [Issues](https://github.com/frePPLe/frepple/issues)
- [Project website](https://frepple.com)
- [README](https://github.com/frePPLe/frepple/blob/master/README.md)
- [Releases](https://github.com/frePPLe/frepple/releases)

---

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