How Factorial works
Factorial does all of its work in your browser. Your factors, results and analyses stay on your device, unless you choose to send them with Feedback.
In short
- It runs on your device. Your browser fetches the app once, and then does every calculation itself.
- Your studies stay in this browser. They are saved as you work. A study file keeps a copy elsewhere.
- Nothing is sent unless you send it. Feedback is the one thing that leaves, when you press Send.
- It works with no network. After a first visit, the page opens from a copy kept here.
- Anyone can check it. The code is open, and this page says where to look.
- You can run a copy of your own. Any web server can serve it.
Where does the work happen?
In your browser tab. When you open Factorial, your browser downloads the app and a copy of Python. From then on the two work together on your device: the page shows the form, the run sheet, the tables and the charts, and Python does the statistics. No calculation is done on a server.
Your browser tab
The details: which part does what
- The page draws what you see.
index.htmland its JavaScript modules draw the form, the run sheet, the tables and the charts, and hold the study you are working on. - A Web Worker runs Python. Pyodide is CPython compiled to
WebAssembly; in a worker, a long computation leaves the page free to scroll and type in. The page sends it
each request as JSON, and
web/bootstrap.pyanswers with the same process-improve functions you would call in Python:generate_design,compare_designs,TrueProcessandanalyze_experiment. A study of one factor also compares its levels with the package's tests:one_way_sample_sizesizes it;ttest_independent,ttest_paired,randomization_testandrank_sum_testcompare two levels; andstudentized_range_value(Tukey's intervals),dunnett_value,bartlett_testandkruskal_wallis_testcompare three or more. - The charts are process-improve's own. They are its Plotly figures, drawn in the page with Plotly.js.
- What comes from where. factori.al sends the app's files and the process-improve wheel; jsDelivr sends Pyodide, its Python packages and Plotly.js; PyPI sends openpyxl and plotly.
Where are my studies kept?
In this browser, on this device. Every study is saved as you work, and so is one you have only begun to describe. They are in no account and on no server, so they do not follow you to another browser or another computer.
Clearing this site's data in the browser deletes them. To keep a copy, or to take your studies elsewhere, download the study file.
The details: where in the browser
- Your studies are saved as you work. Every one of them is kept in this browser's IndexedDB, and a brief not yet made into a run sheet is kept in its local storage.
- The workbook and the notebook are written in the tab. The
.xlsxand the.ipynbare saved by your browser, as any download is.
Can I use it with no network?
Yes, after a first visit. Your browser keeps a copy of Factorial and of Python, and the page opens from that copy when there is no network.
The foot of the app says what the copy holds and how much room it takes on this device. The copy has the charts and the workbooks in it, a download of about 12 MB, and a button removes the copy. A browser set to save data is not sent those 12 MB unasked: there, a second button adds them.
The details: how the copy is kept
The copy is served by a
service
worker (web/sw.js): the page's own files, Python and its packages. What the foot of the page
says of the copy is read from the copy itself. With a network, the page's own files always come from
factori.al, so the copy is never shown in place of a newer page.
How do I share a study, or move it?
There are three ways, and each leaves the study in your hands:
- A link. It holds the whole study, and it goes only where you paste it.
- A file. The Download all button, under Your studies, saves every study as one file, and the Share button beside a study sends that study alone, as a file of its own (it reads Download in a browser that cannot share a file). Drop the file on Your studies, in any browser: a file of one study opens it on the page, and a file of several adds them all. A study already kept in that browser is not saved twice, and none is overwritten.
- A workbook or a notebook. One is for a spreadsheet and one for Python, and your browser saves each as it does any download.
The details: the link, and the file's format
A link holds the study itself. It is there compressed, after the #. A browser
does not send that part of an address to any server: the link travels only where you paste it.
The file is plain JSON, readable without Factorial (web/study-file.js writes and reads it):
{
"format": "factorial-studies",
"version": 1,
"exported": "2026-10-21T08:30:00.000Z",
"app": { "name": "Factorial", "url": "https://factori.al/", "process_improve": "1.4.0" },
"studies": [
{ "id": "8f1c…", "created": "…", "updated": "…", "sha256": "ab12…",
"study": { "v": 1, "title": "…", "design": { … }, "responses": [ … ], … } }
]
}
A study is whole: its brief, its design and run sheet, each response's results and where each came from, the
process they were simulated from, the models, and the settings kept from the what-if panel, each under its name,
as "what_if": [{ "name": "Cooler, more pressure", "settings": { "T": 175, "P": 2.5 } }]. Their
predictions are not kept: Learn works them out from the models and the results each time, so they follow a
result that changes. A target or a window typed in Learn is kept the same way, as
"targets": { "Yield": 62 } and "windows": { "Yield": [60, null] }, and the settings
it gives are found again. The file is built to grow with Factorial:
- New things are new keys. A reader skips a key it does not know, at any level, so a later Factorial adds what it needs beside what is there: a response measured as a curve, or a model inverted to find the settings for a target.
- Each study names its format. It is
"v", and it goes up when a study holds something an earlier Factorial could not keep. That Factorial then refuses the study, and says so, rather than open part of it; the other studies in the file open. A study of one factor is format 2, a study with a categorical factor that lists its levels (three or more, or two that read as numbers) is format 3, a study of more than 12 factors is format 4, a study with settings kept from the what-if panel is format 5, one that reads a curve on each run is format 6, one with a run set aside from a fit is format 7, and one with a target or a window typed in Learn is format 8; any other study keeps format 1, so an earlier Factorial still opens it. The file's own"version"goes up only for a change an earlier Factorial would misread. - A study keeps its
"id". It keeps it through files and copies, so a later study can name the one it builds on: a design that follows another and its model, with factors added or dropped. - Each study carries the SHA-256 of its contents. A study changed by hand is so told apart from one as Factorial saved it. It still opens, and Factorial says so.
What does a server see?
Very little, and nothing of your work.
- factori.al sends the app. It keeps no accounts, sets no cookies and follows nobody. It counts how often each page is opened, and cannot tell who opened it.
- Two public sites send Python. They send it the first time and after a new version. They see an ordinary download, and nothing of your study.
- Feedback goes only when you send it. Before you press Send, the form lists everything it will send. Your study is in it only if you tick the box.
The details: what is written down, and for how long
- factori.al sends the app's files. It has no database, no accounts, no cookies and no
tracking script. Its web server writes one line per request, as web servers do: the time, the file asked for,
the result, the browser's name (its
User-Agent) and the page that linked here. A link someone posted may name the place it was posted, as?ref=newsletter: a word for the place, not for you. Your address is cut to its network before the line is written (the first 24 bits of an IPv4 address, the first 48 of an IPv6 one), and the lines are kept for 366 days, to count visits. Each day's counts are kept for longer: how many times each page was opened, by about how many readers, with nothing of yours in them. - jsDelivr and PyPI send Python and its packages. They send them the first time and after a new version; your browser keeps them. They see an ordinary download, as for any web page that uses them, and nothing of your study.
- Feedback reaches factori.al only when you press Send. It holds what the Feedback dialog lists under "What will be sent": the topic, your message, your email address if you give one, a screenshot of the tab unless you untick it, your study only if you tick it, and the page's build, versions, tab and last Python errors. The site's relay emails it to the maintainer's mailbox through the email provider that sends the site's mail, and keeps nothing of it, in a file or in its log. The dialog then shows the report's reference, such as FB-7K3Q2M. If you give an address, the relay also sends it a receipt: the reference, the topic and the day, and nothing you wrote. An address gets at most one receipt a day; to count them, the relay holds a keyed hash of each address, in memory only, for a day. A copy of Factorial at another address sends nothing itself. Read the code.
What is this copy built with?
Python, some of its best-known scientific packages, and process-improve, the package that does Factorial's statistics. The versions are read from this copy itself, so the list cannot fall behind it.
The versions this copy loads
Read from the files it loads them by:
runtime.json and wheels/manifest.json.
| process-improve | the wheel built with this copy |
|---|---|
| Python, in WebAssembly | Pyodide |
| From the Pyodide release | numpy, pandas, scipy, statsmodels and more |
| From PyPI | openpyxl and plotly |
| Charts | Plotly.js |
Can I check what it does?
Yes. All of the code is open for anyone to read, and free to use, at github.com/kgdunn/process-improve.
The details: where to look in the code
It is open source under the MIT license. To check what it does with your data, these are the places to read:
web/: the page,worker.jsandpython-boot.js, which start Python, andoffline.jsandsw.js, which make and serve the copy for use without a network;web/bootstrap.py: every call the page makes into Python;scripts/build_web_app.py: how this site is built from the repository;deploy/factorial/: the server at factori.al, its configuration and what it logs, and the relay that emails a report sent with Feedback;tests/web/: the tests that check the page, in a real browser and under Pyodide, on every change.
Can I run a copy of my own?
Yes. Factorial is a folder of plain files, so any web server can serve it, an internal one included. It needs nothing else: no database and no accounts.
The details: how to build it and serve it
To build the folder from the code and serve it on your own machine (with uv installed):
git clone https://github.com/kgdunn/process-improve
cd process-improve
uv sync --all-extras
uv run python scripts/build_web_app.py --out site --serve
then open http://localhost:8000. The site folder can be copied to any web server:
nginx, Apache, Caddy, an internal server or GitHub Pages. It has to be served over HTTP, as Python's files are
fetched by the worker, so opening index.html from a disk does not work.
deploy/factorial/
holds the setup that serves factori.al, with deploys and roll-backs, as a worked example.
On a network without access to the internet, the browser has to fetch Pyodide, the PyPI packages and
Plotly.js from inside it as well: copy them to a server there, and change their addresses in
web/python-boot.js (Pyodide), web/charts.js (Plotly.js) and the built
wheels/manifest.json (the PyPI packages, under on_demand). The copy for use without a
network reads the first two addresses from web/offline.js and web/sw.js.
OMARS® is a registered trademark of KU Leuven Research & Development. Factorial uses the name only for the class of designs defined by Núñez Ares and Goos (2020), and is not affiliated with, or endorsed by, KU Leuven, Minitab or Effex.