Open-source project
GreaterWMS/GreaterWMS avatar
GreaterWMS/GreaterWMS

GreaterWMS: a warehouse backend written to be edited

This Inventory management system is the currently Ford Asia Pacific after-sales logistics warehousing supply chain process . After I leave Ford , I start this project . You can share your vacant warehouse space, use it for those in need, and generate income

4,461 stars1,180 forksPythonApache-2.0

At a glance

What is it?
GreaterWMS is an Apache-2.0 Django REST Framework warehouse system sold on one argument: commercial WMS vendors trap you in their secondary development, so this one is meant to be rewritten. The repository delivers that argument as a folder of business modules, and the README documents both a working quick start and a 3.0 rebuild that the quick start never mentions.
Who is it for?
Adopt GreaterWMS if your deployment is a single warehouse operation whose paperwork you need to change, and you have Django developers who will own the fork. Do not adopt it if you cannot accept an undocumented database path from SQLite to MySQL or PostgreSQL.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 27 days ago.
What is it written in?
Mainly Python, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • GreaterWMS/GreaterWMS4,461 ★ · +67
Star history
Repository2026-09-232026-11-21
GreaterWMS/GreaterWMS4.4k4.5k

67 Stars in the last 59 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

A WMS positioned as a starting point, not a finished product

The pitch is vendor lock-in in secondary development. Commercial WMS software is closed, so once a company picks one, every later feature request has to go through that vendor. The author states fifteen years in the supply chain industry and positions GreaterWMS as the flexible foundation a team edits directly, whether the scope is inventory alone or a wider platform that talks to IoT, ERP and distribution systems.

That framing decides who the project is for. The reader who wants a configured warehouse with a support contract is the wrong audience; the reader who can open Python and change a model field is the right one. The README also describes deployment cases: a 3PL running multi-warehouse clustering and cold-chain temperature control, a pharmaceutical distributor adding batch expiry alerts, a cross-border operator wiring customs declaration interfaces. These are descriptions of forks, and they read that way.

One Django app per warehouse document

The repository layout is the architecture. Directories such as asn/, dn/, stock/, warehouse/, cyclecount/, goods/, goodsbrand/, goodsclass/, goodsunit/, goodsspecs/, staff/, customer/, supplier/, capital/ and payment/ are separate Django applications, one per document or master record. ASN receiving and DN shipping are distinct apps rather than two modes of a single movement model, and the frontend in templates/ is a Quasar and Vue client that talks to them over RESTful endpoints from Django REST Framework.

Business logic stays inside the app it belongs to, which is what makes partial modification safe. Change a batch rule in one app and goods/ or stock/ are untouched. The backend exposes an OpenAPI surface through drf-spectacular, and djangorestframework-csv is pinned in requirements.txt, so exports are a first-class path rather than an afterthought.

Three processes to start: daphne on 8008, then a Quasar dev server

The quick start is a clone, a pip install, and two separate servers. The backend is served by daphne through the ASGI entry point:

bash
pip install -r requirements.txt
daphne -b 0.0.0.0 -p 8008 greaterwms.asgi:application

Port 8008 is the address to point a client at. The frontend is a separate npm and Quasar project inside templates/:

bash
cd templates
npm install
quasar dev

That dev server runs alongside the backend rather than replacing it. The connection between them is a file, not an environment variable: the request address is configured in `templates/public/statics/baseurl.txt`. Nothing in the README tells you to set a database URL, and the documented stack lists SQLite as the default, with MySQL and PostgreSQL also supported.

The compose file bind-mounts your whole working tree into the backend

docker-compose.yml runs two prebuilt images, greaterwms/greaterwms:front on port 8080 and greaterwms/greaterwms:backend on port 8008. Both build steps are commented out, so a compose run pulls images rather than building the code sitting next to the file. The backend service then bind-mounts the entire repository:

yaml
    volumes:
      - ./:/GreaterWMS/:rw
      - ./supervisord.conf:/etc/supervisor/supervisord.conf

Here is the first failure mode. The container image was built from some earlier copy of the repository, and the mount shadows that copy with whatever is on your host, including the local media/ directory and any .env you drop beside the code. A stale or partially checked out tree changes the running system without a rebuild. Both services also set privileged: true and restart: always, so a crashed supervisor process comes straight back and no manual stop is required before a fix.

The README describes two different versions of the same software

The top of README.md announces GreaterWMS 3.0, rebuilt on the Bomiot framework with a Rust core, a plugin architecture and an app marketplace extended by pip. Developer documentation has moved to Bomiot, and the README gives the install for it:

shell
pip install bomiot

Below that banner, the quick start still clones GreaterWMS and runs daphne against the Django ASGI application, and the tech stack section describes the Django build directly. The pip install line sits under the heading for developer documentation, so a reader can reasonably take it as the way to get the system rather than the way to get the docs.

The pin file sharpens the gap. The stack section says Django 3.1+ and Python 3.8+, but requirements.txt pins Django==4.1.2 exactly, alongside djangorestframework==3.14.0 and daphne==4.0.0. All 52 lines in that file are frozen with == signs, so a security patch in any of them does not arrive by upgrading. The Dockerfile compounds this by building on python:3.8.10-slim and the frontend on node:14.19.3-buster-slim, so a rebuild inherits those exact interpreter versions.

ERPNext models stock inside an ERP; GreaterWMS models warehouse documents alone

The nearest alternative is an ERP suite such as ERPNext or Odoo, where the warehouse is one module inside a system that already owns purchasing, sales, suppliers, customers and a general ledger. The difference in approach is scope of the source of truth. An ERP derives stock from posted transactions in financial documents, so a stock figure can be traced back to the invoice that caused it. GreaterWMS is organised around warehouse modules such as ASN receiving, DN shipping, inventory and storage locations, with payment/ and capital/ directories alongside them.

For a pure fulfilment operation, that is a clean fit. For a company that must reconcile goods movements against receivables, the ERP route answers questions GreaterWMS cannot, and joining the two means building the integration layer the README only gestures at when it mentions ERP integration.

SQLite by default, with no documented migration path off it

The database choice is listed as SQLite (default) / MySQL / PostgreSQL, and the README says nothing further about moving between them. No migration command, no settings key, no backup procedure. That silence matters more than the licence or the release count: GreaterWMS is Apache 2.0, so you may modify and redistribute it, and the last push to master was on 2026-10-26, but ownership of the data path is entirely yours from the first commit.

Pin files are the second upgrade cost. Every requirement is version-locked, so adopting a patched Django means editing requirements.txt by hand and then proving that your forked models still migrate. If you run this in production, treat the pins and the SQLite file as the two artefacts you must own before anyone else logs in.

Editorial conclusion

Adopt GreaterWMS if your deployment is a single warehouse operation whose paperwork you need to change, and you have Django developers who will own the fork. Do not adopt it if you cannot accept an undocumented database path from SQLite to MySQL or PostgreSQL. Verify first which version you actually get: the clone and daphne quick start in the README describes the older Django core, while the 3.0 banner at the top of the same file says that core was rebuilt on Bomiot and that developer documentation moved there.

Frequently asked questions

How do I install GreaterWMS locally?

Clone the repository, run pip install -r requirements.txt, then start the backend with daphne -b 0.0.0.0 -p 8008 greaterwms.asgi:application. The frontend is a separate npm and Quasar project started from the templates directory with npm install and quasar dev.

What port does the GreaterWMS backend serve on?

Port 8008. The quick start command binds daphne to 0.0.0.0 on port 8008, and docker-compose.yml publishes the backend container on 8008 and the front container on 8080.

Which database does GreaterWMS use by default?

SQLite is the default. The tech stack also lists MySQL and PostgreSQL, but the README does not document a migration procedure or backup process between them.

Is GreaterWMS a complete ERP or only a warehouse system?

It is a warehouse management system. The repository holds apps for ASN receiving, DN shipping, stock, warehouse locations, cycle counting and goods masters, alongside customer, supplier, payment and capital directories.

What licence is GreaterWMS released under?

Apache 2.0. The LICENSE file is at the repository root and the README closes with the same licence line.

Official sources

  1. GreaterWMS/GreaterWMS on GitHub
  2. License: Apache-2.0
  3. Project website
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/greaterwms-greaterwms.svg)](https://hysenlabs.com/projects/greaterwms-greaterwms)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/greaterwms-greaterwms.svg)](https://hysenlabs.com/projects/greaterwms-greaterwms)

Was this useful?