dashAI 0.9.7

Desktop installers (Windows / macOS / Linux)

The easiest way to get started. Desktop installers, ready to use, are published with every release. They are CPU only and bundle everything you need, so no Python or extra setup is required.

Download the file for your system from the latest release:

• Windows (x64): dashAI-<version>-x64-windows.exe

• macOS (Apple Silicon): dashAI-<version>-arm-osx.dmg

• macOS (Intel): dashAI-<version>-x64-osx.dmg

• Linux (x64): dashAI-<version>-x64-linux.AppImage

On Windows and macOS, run the installer, launch dashAI, and the graphical interface opens automatically.

On Linux, make the AppImage executable and run it:

$ chmod +x dashAI-<version>-x64-linux.AppImage
$ ./dashAI-<version>-x64-linux.AppImage

The AppImage bundles its own Python, so nothing needs to be installed. It requires glibc 2.35 or newer (Ubuntu 22.04+, Debian 12+, Fedora 36+, and most distributions from 2022 on) and FUSE 2 to mount. If FUSE is missing, run it with ./dashAI-<version>-x64-linux.AppImage --appimage-extract-and-run.

When double clicked, the AppImage opens a terminal window to show the server logs. This needs a terminal emulator, which every standard desktop (GNOME, KDE, XFCE, and others) already provides, so no setup is required. On a minimal system with no terminal emulator the log window is skipped, but the app still starts and opens the browser as usual.

Note: the desktop installers ship with CPU only PyTorch and llama-cpp-python. For NVIDIA (CUDA) or AMD (ROCm) GPU acceleration, use the pip installation below.

Installation (PyPI)

dashAI needs Python 3.10 or greater. We strongly recommend installing it inside an isolated environment to avoid clashes with other packages. The quickest way to do that is with uv (recommended, it even installs Python for you); classic venv/conda with pip works exactly the same if you prefer it.

Shortcut: if you just want dashAI as an app with the default PyTorch build for your platform, uv can install it in its own isolated environment and put the dashai command on your PATH in one line:

$ uv tool install dashai

For GPU acceleration, a CPU-slim install, or LLM (GGUF) support, follow the steps below instead.

Installing dashAI also installs PyTorch with the default build for your platform, which works out of the box on CPU. To enable GPU acceleration (NVIDIA CUDA or AMD ROCm), or to force a CPU only build, reinstall PyTorch from the matching index as shown in step 3. llama-cpp-python is required to run LLM models (GGUF / Llama, Mistral, Qwen, and similar) inside the app, but it is never installed automatically, so install it in step 3 if you need those models.

$ uv venv --python 3.12
$ source .venv/bin/activate          # Windows: .venv\Scripts\activate

$ python3 -m venv .venv
$ source .venv/bin/activate

> python -m venv .venv
> .venv\Scripts\Activate.ps1

$ conda create -n dashai python=3.12
$ conda activate dashai

$ uv pip install dashai

# or, with plain pip:
$ pip install dashai

$ pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu --force-reinstall --no-cache-dir

# Optional, for GGUF / Llama models (precompiled CPU wheel, no build tools):
$ pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu --force-reinstall --no-cache-dir

# Torch CUDA 12.8 (prebuilt wheels)
$ pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128 --force-reinstall --no-cache-dir

# Llama compiled with CUDA offload (requires build tools, see below)
$ pip install llama-cpp-python -C cmake.args="-DGGML_CUDA=on" --force-reinstall --no-cache-dir --verbose

# Torch ROCm (prebuilt wheels)
$ pip install torch torchvision --index-url https://download.pytorch.org/whl/rocm6.4 --force-reinstall --no-cache-dir

# Llama compiled with HIP/ROCm offload (requires build tools, see below)
$ pip install llama-cpp-python -C cmake.args="-DGGML_HIP=on" --force-reinstall --no-cache-dir --verbose

$ pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu --force-reinstall --no-cache-dir
$ pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/<cuda-version> --force-reinstall --no-cache-dir

$ dashai

Docker

dashAI can also run inside a container. Two Dockerfiles are provided at the repository root.

$ docker build -t dashai .
$ docker run -p 8000:8000 dashai

$ docker build -t dashai:cuda -f Dockerfile.cuda .
$ docker run --gpus all -p 8000:8000 dashai:cuda

Test datasets

Some datasets you can use to try dashAI are available here.

Development

To download and run the development version of dashAI, first, download the repository and switch to the developing branch:

$ git clone https://github.com/DashAISoftware/DashAI.git
$ git checkout develop

$ cd DashAI/front
$ yarn install

$ cd DashAI/front

$ yarn start

$ uv sync
$ uv run pre-commit install

$ uv sync --extra cpu

$ uv cache clean llama-cpp-python
$ CMAKE_ARGS="-DGGML_CUDA=on" uv sync --extra cuda --reinstall-package llama-cpp-python

$ pip install -e . --group dev    # --group needs pip >= 25.1
$ pre-commit install

$ uv run python -m DashAI

$ uv run dashai

Optional Flags

Setting the local execution path

With the –local-path (alias -lp) option you can determine where dashAI will save its local files, such as datasets, experiments, runs and others. The following example shows how to set the folder in the local .DashAI directory:

$ python -m DashAI --local-path "~/.DashAI"

Setting the logging level

Through the –logging-level (alias -ll) parameter, you can set which logging level the dashAI backend server will have.

$ python -m DashAI --logging-level INFO

The possible levels available are: DEBUG, INFO, WARNING, ERROR, CRITICAL.

Note that the –logging-level not only affects the dashAI loggers, but also the datasets (which is set to the same level as dashAI) and the SQLAlchemy (which is only activated when logging level is DEBUG).

Disabling automatic browser opening

By default, dashAI will open a browser window pointing to the application after starting. If you prefer to disable this behavior, you can use the –no-browser (alias -nb) flag:

$ python -m DashAI --no-browser

Checking Available Options

You can check all available options through the command:

$ python -m DashAI --help

Database Migrations

Migrations are managed through Alembic.

They are automatically executed when starting dashAI. However, if you want to run them manually, you can do so using the following command (inside the DashAI/ folder):

$ alembic upgrade head

This command applies all pending migrations up to the latest revision.

—

$ alembic revision --autogenerate -m "<<Your message here>>"

$ alembic upgrade head

$ alembic upgrade <revision_id>

$ alembic downgrade -1

$ alembic downgrade <revision_id>

$ alembic current

$ alembic history

Testing

Execute tests

dashAI uses pytest to perform the backend tests. To execute the backend tests

1. Move to DashAI/back

$ cd DashAI/back

2. Run:

$ pytest tests/

Acknowledgments

This project is developed in collaboration with:

• University of Chile - Leading Institution

• Fcfm - Leading Institution

• CENIA - Associated Institution

• IMFD - Collaborator

• Unholster - Industry Partner

Supported by ANID through Fondef IDEA ID25I10330, Fondef VIU23P 0110, and grants supporting the centers CENIA (FB210017) and IMFD (ICN17_002). Developed by students of DCC UChile and UTFSM.

To see the full list of contributors, visit in Contributors the dashAI repository on Github.