Reduce is a web application and productivity tool. It’s best understood by 2 statements, both of which are examples of "reduction". The first one is a reduction in complexity. Reduce is built to be as simple as possible for the end user. Note that simple here doesn’t mean intuitive, underlying complexity is considered as well. For example, take the idea of generic tags. Tags are typically versatile. This can lead to situations where multiple concepts are described in tags.

For example, take an email inbox for a company. You could have a set of tags that describe at what stage an email is in resolution. You can have tags for specific topics. You can have tags for mentioning context like whether or not there is help needed. This makes tags very versatile, which is important if your application must be adaptable. However, it does add some complexity for the end user. You have to think about all variations of tags. Most typical people won’t find issue in this, but Reduce is built specifically with the people that have issue with this in mind. It does this in a few ways:

• Reduce is opinionated: promoting a very focused way to use the tool.

• Reduce prioritizes semantic value: terms and concepts are with intent and with a clear purpose.

• Reduce avoids ambiguity: a person should be very unlikely to misinterpret the intent of concepts.

The second meaning for Reduce is the reduction of tasks. Reduce can roughly be separated in 3 parts. The first is input, this can be manual or automatic. And these create tasks to do. Then there is the reduction part. The idea being that each interaction with Reduce shrinks what you’re doing. And finally there is the output. Not all things produce output, but those who do will do so cleanly. In some sense you could consider any program that manages tasks to work this way. The point of Reduce is to bring this idea into direct focus. This is meant to be more ideal for people with executive dysfunction. It’s a way of cutting up the tasks into small digestible bits.

• Rust toolchain and Cargo

• Node

• NPM

• Python

• PDM (python tool)

• Maturin (python tool)

• A way to run a Postgres server, Docker is recommended

The following are optional, but strongly recommended:

• mprocs (rust crate)

• cargo-watch (cargo tool)

I do not have a user-friendly quick start yet. This is because the structure of the project is currently evolving. Instead, I’ll describe what I’ve done so you can figure it out from context. Reduce is written within a monorepo. It’s written using 2 languages: Rust and Python. And linked together using pyo3. Eventually the project will be structured the following way:

Each element of this setup has a distinct purpose. Rust is partially used for speed, but the primary purpose is type correctness. Any parts having strong security requirements will be done within reduce-core. The most common extension modules will also reside in Rust. The Python binding has 2 purposes. First of all, allow for python extension modules. Python modules will be slower, but are ideal for quick iteration. Also, python modules will be dynamically loaded, making version management easier. The second is configuration. Python is better suited for handling configuation tasks. The reason for the multiple Rust crates is to allow advanced developers to take over default behavior. Say you want to write your own version of a primary module, or you require the speed in Rust. You can create your own project, and directly link with reduce-core and any extension modules you still want to use. You’ll have to reimplement the Python bindings, or you can even choose to forgo Python and write all logic in Rust only.

For rendering, HTMX and tailwind are used. I’ve also set up a docker compose configuration to run a Postgres server locally during development. All of this is handled in the files matching *.mprocs.yaml. To understand the details, look in these files. They contain the latest commands to manage all processes.