Developing with Phymes
Setting up your build environment (Linux)
Setting up the Rust tool chain
Install the Rust tool chain:
https://www.rust-lang.org/tools/install
An example bash script for installing the Rust tool chain for Linux is the following:
apt update
DEBIAN_FRONTEND=noninteractive apt install --assume-yes git clang curl libssl-dev llvm libudev-dev make pkg-config protobuf-compiler
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
. "$HOME/.cargo/env"
rustup toolchain install stable --target x86_64-unknown-linux-gnu
rustup default stable
rustc --version
Also, make sure your Rust tool chain is up-to-date, because we always use the latest stable version of Rust to test this project.
rustup update stable
Setting up GPU acceleration with CUDA
Install CUDA for linux:
https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html
GPU acceleration with CUDA is currently only support for Linux (including WSL2) at this time. An example bash script for installing CUDA for WSL2 is the following:
wget https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-wsl-ubuntu.pin
sudo mv cuda-wsl-ubuntu.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/12.6.2/local_installers/cuda-repo-wsl-ubuntu-12-6-local_12.6.2-1_amd64.deb
sudo dpkg -i cuda-repo-wsl-ubuntu-12-6-local_12.6.2-1_amd64.deb
sudo cp /var/cuda-repo-wsl-ubuntu-12-6-local/cuda-*-keyring.gpg /usr/share/keyrings/
sudo apt update
sudo apt -y install cuda-toolkit-12-6
Please replace the repo and cuda versions accordingly. Check the Cuda installation
nvcc --version
nvidia-smi --query-gpu=compute_cap --format=csv
Install CuDNN backend for linux:
https://docs.nvidia.com/deeplearning/cudnn/installation/latest/linux.html
An example bash script for install CuDNN for Linux is the following:
wget https://developer.download.nvidia.com/compute/cudnn/9.5.1/local_installers/cudnn-local-repo-ubuntu2404-9.5.1_1.0-1_amd64.deb
sudo dpkg -i cudnn-local-repo-ubuntu2404-9.5.1_1.0-1_amd64.deb
sudo cp /var/cudnn-local-repo-ubuntu2404-9.5.1/cudnn-*-keyring.gpg /usr/share/keyrings/
sudo apt update
sudo apt -y install cudnn
Please replace the repo and cuda versions accordingly.
Setting up NVIDIA NIMs for local deployment
Obtain an NGC API key following the instructions.
Install the NVIDIA Container Toolkit following the instructions
Check that the installation was successful by running the following:
sudo docker run --rm --runtime=nvidia --gpus all ubuntu nvidia-smi
The NGC catalogue can be viewed using NGC CLI. Install NGC following the instructions
Alternatively, the NGC catalogue can be viewed online. For example, the open-source Llama3.2 model can be deployed locally following the instructions, and alternatively accessed via the NVIDIA NIMs API if available (see the NIMs LLM [API](NIMs LLM API https://docs.nvidia.com/nim/large-language-models/latest/api-reference.html) for OpenAPI schema).
Setting up WASM build environment
Add the following wasm32 compilation targets from the nightly Rust toolchain:
rustup update nightly
rustup target add wasm32-unknown-unknown --toolchain nightly
rustup target add wasm32-wasip2 --toolchain nightly
In addition, we recommend using wasmtime for running wasi components
curl https://wasmtime.dev/install.sh -sSf | bash
Setting up Dioxus
The front-end application is built using dioxus to enable creating web, desktop, and mobile applications using Rust
# Build from source (can sometimes fail)
cargo install dioxus-cli
# Install using binstall (usually does not fail)
curl -L --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.sh | bash
cargo update
cargo binstall dioxus-cli
Setting up Android Studio
Installation of Android Studio is required to run virtual android phone emulations of the applicaiton or to test on a physical android device. Follow the below steps to install Android Studio on Linux.
First, install Linux 64 bit dependencies required to build Android applications
# add 32 bit architecture target
sudo dpkg --add-architecture i386
# add non-standard package repos for libncurses5
sudo tee -a /etc/apt/sources.list <<EOF
deb http://archive.ubuntu.com/ubuntu/ focal main restricted universe multiverse
deb http://archive.ubuntu.com/ubuntu/ focal-updates main restricted universe multiverse
deb http://archive.ubuntu.com/ubuntu/ focal-security main restricted universe multiverse
EOF
# install the dependencies
sudo apt-get update
sudo apt-get install libc6:i386 libncurses5:i386 libstdc++6:i386 lib32z1 libbz2-1.0:i386
sudo apt install default-jre
sudo apt install default-jdk
Second, install Android Studio. The simplest option is to download and untar in a directory of your choice. Then, move the files and folders to an accessible directory.
# cd to the directory for android-studio
mv android-studio /opt/android-studio/
sudo /opt/android-studio/bin/studio.sh
Third, use Android Studio to emulate a virtual android device by following the walkthrough under the section "Running the Emulator". Note that during the walkthrough, various packages are installed which require the configuration of permissions and environmental variables to work nicely with Dioxus.
# Set the environmental variable
export JAVA_HOME="/usr/lib/jvm/java-21-openjdk-amd64"
export ANDROID_HOME="$HOME/Android/Sdk"
export NDK_HOME="$ANDROID_HOME/ndk/29.0.13599879"
export PATH="$PATH:$ANDROID_HOME/emulator:$ANDROID_HOME/platform-tools"
# Fix the permission so that Dioxus can run Gradle
sudo chmod -R 757 ~/Android/Sdk
Finally, you should be able to build the phymes-app for android. Note that the emulator must be running before starting the phymes-app server.
dx serve -p phymes-app --platform android
Setting up your build environment (Android)
It is possible to build and run PHYMES directly on Android using Termux. Be sure enable developer options on Android and ensure to enable Disable child process restrictions.
Setting up Termux and Ubuntu
First, follow the instructions to install Termux on Android. Open Termux and install proot-distro by following the instructions on the repo.
Second, install Ubuntu using proot-distro:
# Install ubuntu (proot-distro reset ubuntu if something goes wrong)
proot-distro install ubuntu
proot-distro login ubuntu
# Setup a new user account
apt update && apt install sudo nano -y
adduser {USER} # enter password and optional information
nano /etc/sudoers # locate "root" and add entry for "{USER}"
su {USER} # switch to new user
# Setup for remote viewing
sudo apt upgrade && sudo apt update && sudo apt install udisks2
sudo rm /var/lib/dpkg/info/udisks2.postinst
echo "" >> /var/lib/dpkg/info/udisks2.postinst
sudo apt-mark hold udisks2
sudo apt install xfce4 xfce4-goodies
# If errors occur with the obove command run `sudo apt install gvfs-common gvfs-libs gvfs-daemons`
# Optional apps that can be useful Ubuntu
sudo apt install firefox gedit vlc dbus-x11 -y
Third, setup VNC server
sudo apt install tigervnc-standalone-server
echo "vncserver -geometry 1600x900 -xstartup /usr/bin/startxfce4 :1" >> /bin/vncstart
echo "vncserver -kill :1" >> /bin/vncstop
chmod +x /bin/vncstart
chmod +x /bin/vncstop
After starting vncserver, switch to a your VNC viewer of choice on android and connect using the password provided on the command line. We recommend bVNC.
Fourth, install visual studio code
# Install VS code
sudo apt-get install wget gpg -y
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -D -o root -g root -m 644 packages.microsoft.gpg /etc/apt/keyrings/packages.microsoft.gpg
sudo sh -c 'echo "deb [arch=amd64,arm64,armhf signed-by=/etc/apt/keyrings/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main" > /etc/apt/sources.list.d/vscode.list'
rm -f packages.microsoft.gpg
sudo apt install apt-transport-https
sudo apt update
sudo apt install code
# Run VS code
code --no-sandbox
Optionally, add a shortcut for starting Ubuntu under your user account.
# If you are already in Termux
exit
logout
echo "proot-distro login --user {USER} ubuntu" >> $PREFIX/bin/ubuntu
chmod +x $PREFIX/bin/ubuntu
# Now you can start ubuntu with your user account using
ubuntu
Setting up your build environment (Windows, MacOS)
PHYMES can be also be built on Windows and MacOS. However, we have omitted the steps for now. Contributions to add the detailed steps are welcome 😊.
How to compile and run PHYMES
How to compile
This is a standard cargo project with workspaces. To build the different workspaces, you need to have rust and cargo and you will need to specify workspaces using the using the -p, --project flag:
cargo build -p phymes-core
CPU, GPU, and WASM-specific compilation features are gated behind feature flags wsl, gpu, and wasip2 respectively. The use of embedded Candle or OpenAI API token services are gated behind the feature flag candle and openai_api, which enables the use of Candle or OpenAI API token services. Enabling candle will force the application to use embedded Candle models even if openai_api is enabled. The use of HuggingFace models from the HuggingFace Hub API are gated behind the feature flag hf_hub.
The following will build the phymes-agents workspace with different configurations of CPU and GPU acceleration for Tensor and Token services:
# Native CPU for tensor operations and local/remote OpenAI API token services
cargo build -p phymes-agents --features wsl,openai_api --release
# Native CPU for tensor operations and embedded Candle for token services
cargo build -p phymes-agents --features wsl,candle --release
# Native CPU for tensor operations and embedded Candle with models from HuggingFace for token services
cargo build -p phymes-agents --features wsl,candle,hf_hub --release
# GPU support for tensor operations and local/remote OpenAI API token services
cargo build -p phymes-agents --features wsl,gpu,openai_api --release
# GPU support for tensor operations and embedded Candle for token services
cargo build -p phymes-agents --features wsl,gpu,candle --release
# GPU support for tensor operations and embedded Candle with models from HuggingFace for token services
cargo build -p phymes-agents --features wsl,gpu,candle,hf_hub --release
Please ensure that all CUDA related environmental variables are setup correctly for GPU acceleration. Most errors related to missing CUDA or CuDNN libraries are related to missing environmental variables particularly on WSL2.
export PATH=$PATH:/usr/local/cuda/bin:/usr/lib/x86_64-linux-gnu/
export LD_LIBRARY_PATH=/usr/lib/wsl/lib:/usr/local/cuda/lib64:/usr/local/cuda/lib64/stubs
The following will build the phymes-agents workspace as a WASIp2 component:
cargo build -p phymes-agents --target wasm32-wasip2 --no-default-features --features wasip2,candle --release
Mixing and matching features that are compilation target specific and compilation targets will result in build errors.
You can also use rust's official docker image:
docker run --rm -v ${pwd}:/phymes -it rust /bin/bash -c "cd /phymes && rustup component add rustfmt && cargo build -p phymes-core"
From here on, this is a pure Rust project and cargo can be used to run tests, benchmarks, docs and examples as usual.
Setting up the cache for running tests and examples
Many of the tests (and examples if running without the GPU or on WASM) depend upon a local cache of model assets to run. The following bash script can be used to prepare the local assets:
# ensure your home environmental variable is set
echo $HOME
# make the cache directory
mkdir -p $HOME/.cache/hf
# copy over the cache files from the root of the GitHub repository
cp -a .cache/hf/. $HOME/.cache/hf/
# download the model assets manually from HuggingFace
curl -L -o $HOME/.cache/hf/models--sentence-transformers--all-MiniLM-L6-v2/model.safetensors https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2/resolve/main/model.safetensors?download=true -sSf
curl -L -o $HOME/.cache/hf/models--sentence-transformers--all-MiniLM-L6-v2/pytorch_model.bin https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2/resolve/main/pytorch_model.bin?download=true -sSf
curl -L -o ~/.cache/hf/models--sentence-transformers--all-MiniLM-L6-v2/all-minilm-l6-v2-q8_0.gguf https://huggingface.co/sudomoniker/all-MiniLM-L6-v2-Q8_0-GGUF/resolve/main/all-minilm-l6-v2-q8_0.gguf?download=true -sSfv
curl -L -o $HOME/.cache/hf/models--Qwen--Qwen2-0.5B-Instruct/qwen2.5-0.5b-instruct-q4_k_m.gguf https://huggingface.co/Qwen/Qwen2.5-0.5B-Instruct-GGUF/resolve/main/qwen2.5-0.5b-instruct-q4_k_m.gguf?download=true -sSf
curl -L -o $HOME/.cache/hf/models--HuggingFaceTB--SmolLM2-135M-Instruct/smollm2-135m-instruct-q4_k_m.gguf https://huggingface.co/Segilmez06/SmolLM2-135M-Instruct-Q4_K_M-GGUF/resolve/main/smollm2-135m-instruct-q4_k_m.gguf?download=true -sSf
curl -L -o $HOME/.cache/hf/models--Alibaba-NLP--gte-Qwen2-1.5B-instruct/gte-Qwen2-1.5B-instruct-Q4_K_M.gguf https://huggingface.co/tensorblock/gte-Qwen2-1.5B-instruct-GGUF/resolve/main/gte-Qwen2-1.5B-instruct-Q4_K_M.gguf?download=true -sSf
Setting up local OpenAI API endpoints
Instead of using token credits with remote OpenAI API endpoints, it is possible to run the tests and examples locally using self-hosted open-source NVIDIA NIMs. Modify the following code depending upon the model(s) to be locally deployed:
# Text Generation Inference with Llama 3.2 (terminal 1)
export NGC_API_KEY=nvapi-
export LOCAL_NIM_CACHE=$HOME/.cache/nim
docker run -it --rm --gpus all --shm-size=16GB -e NGC_API_KEY -v "$LOCAL_NIM_CACHE:/opt/nim/.cache" -u $(id -u) -p 8000:8000 nvcr.io/nim/meta/llama-3.2-1b-instruct:1.8.6
# Text Embedding Inference with Llama 3.2 (terminal 2)
export NGC_API_KEY=nvapi-
export LOCAL_NIM_CACHE=$HOME/.cache/nim
docker run -it --rm --gpus all --shm-size=16GB -e NGC_API_KEY -v "$LOCAL_NIM_CACHE:/opt/nim/.cache" -u $(id -u) -p 8001:8000 nvcr.io/nim/nvidia/llama-3.2-nv-embedqa-1b-v2:latest
Note that the tests and examples assume that the local OpenAI API endpoints for NVIDIA NIMs are http://0.0.0.0:8000/v1 for Text Generation Inference (TGI, Chat) and http://0.0.0.0:8001/v1 for Text Embedding Inference (TEI, Embed), respectively. The defaults can be overwritten by setting the environmental variables for the TEI and TGI endpoints, respectively.
# URL of the local TGI NIMs deployment
export CHAT_API_URL=http://0.0.0.0:8000/v1
# URL of the local TEI NIMs deployment
export EMBED_API_URL=http://0.0.0.0:8001/v1
Also, be sure to add your NGC_API_KEY to the environmental variables before running tests or examples in a different terminal.
# NVIDIA API Key
export NGC_API_KEY=nvapi-...
Running the tests
Run tests using the Rust standard cargo test command:
# run all unit and integration tests with default features
cargo test
# run tests for the phymes-core crate with all features enabled
cargo test -p phymes-core --all-features
# run a specific test for the phymes-core crate with the wsl feature enabled
# and printing to the console
cargo test test_session_update_state -p phymes-core --features wsl -- --no-capture
# run the doc tests
cargo test --doc
You can find up-to-date information on the current CI tests in .github/workflows. The phymes-server, phymes-core, and phymes-agents crates have unit tests. Please note that many of the tests in the phymes-ml and phymes-agent crates do not run on the CPU due to the amount of time that it takes to run them. To run all tests in the phymes-ml and phymes-agents crates, either enable GPU acceleration with Candle using --features wsl,gpu,candle feature flag, or with OpenAI API local/remote token services using --feature wsl,openai_api or --feature wsl,gpu,openai_api feature flags depending upon GPU availability.
# run tests for the phymes-core crate
cargo test --package phymes-core --features wsl --release
# run tests for the phymes-data crate with GPU acceleration
cargo test --package phymes-data --features wsl,gpu --release
# or run tests for the phymes-data crate on the CPU
cargo test --package phymes-data --features wsl --release
# run tests for the phymes-ml crate with GPU acceleration with Candle assets
cargo test --package phymes-ml --features wsl,gpu,candle --release
# run tests for the phymes-ml crate with GPU acceleration with Candle assets from HuggingFace
cargo test --package phymes-ml --features wsl,gpu,candle,hf_hub --release
# or run tests for the phymes-ml crate on the CPU with OpenAI API token services
cargo test --package phymes-ml --features wsl,openai_api --release
# run tests for the phymes-agents crate with GPU acceleration with Candle assets
cargo test --package phymes-agents --features wsl,gpu,candle --release
# run tests for the phymes-agents crate with GPU acceleration with Candle assets from HuggingFace
cargo test --package phymes-agents --features wsl,gpu,candle,hf_hub --release
# or run tests for the phymes-agents crate on the CPU with OpenAI API token services
cargo test --package phymes-agents --no-default-features --features wsl,openai_api --release
# run tests for the phymes-server crate
cargo test --package phymes-server --features wsl --release
The tests can also be ran for WASM components. However, the WASM debug output is essentially useless, so it is recommend to debug the tests natively before testing on WASM
# build tests for the phymes-core crate
cargo test --package phymes-core --target wasm32-wasip2 --no-default-features --features wasip2 --no-run
# build tests for the phymes-core crate using wasmtime
# be sure to replace the -26200b790e92721b with your systems unique hash
wasmtime run target/wasm32-wasip2/debug/deps/phymes-core-26200b790e92721b.wasm
# run tests for the phymes-data crate
cargo test --package phymes-data --target wasm32-wasip2 --no-default-features --features wasip2,candle --no-run
# build tests for the phymes-data using wasmtime
# be sure to replace the -9ce9c7c7142d7db7 with your systems unique hash
wasmtime --dir=$HOME/.cache/hf --env=HOME=$HOME target/wasm32-wasip2/debug/deps/phymes_data-9ce9c7c7142d7db7.wasm
# run tests for the phymes-ml crate
cargo test --package phymes-ml --target wasm32-wasip2 --no-default-features --features wasip2,candle --no-run
# build tests for the phymes-ml crate using wasmtime
# be sure to replace the -9ce9c7c7142d7db7 with your systems unique hash
wasmtime --dir=$HOME/.cache/hf --env=HOME=$HOME target/wasm32-wasip2/debug/deps/phymes_ml-9ce9c7c7142d7db7.wasm
# run tests for the phymes-agents crate
cargo test --package phymes-agents --target wasm32-wasip2 --no-default-features --features wasip2,candle --no-run
# build tests for the phymes-agents crate using wasmtime
# be sure to replace the -9ce9c7c7142d7db7 with your systems unique hash
wasmtime --dir=$HOME/.cache/hf --env=HOME=$HOME target/wasm32-wasip2/debug/deps/phymes_agents-9ce9c7c7142d7db7.wasm
# run tests for the phymes-server crate
cargo test -p phymes-server --features wasip2-candle --no-default-features --target wasm32-wasip2 --no-run
# build tests for the phymes-server crate using wasmtime
# be sure to replace the -48a453bb50fd01da with your systems unique hash
wasmtime --dir=$HOME/.cache --env=HOME=$HOME target/wasm32-wasip2/debug/deps/phymes_server-48a453bb50fd01da.wasm
Running the examples
Run examples using the Rust standard cargo run command. A few simple examples are provided for the phymes-core and phymes-agents crates to provide new users a starting point for building application using the crates
# run examples for the phymes-core crate
cargo run --package phymes-core --features wsl --release --example addrows
# run examples for the phymes-ml and phymes-agents crates with GPU acceleration with Candle assets
cargo run --package phymes-ml --features wsl,gpu,candle --release --example chat -- --candle-asset SmoLM2-135M-chat
cargo run --package phymes-agents --features wsl,gpu,candle --release --example chat_agent_session
# or run examples for the phymes-ml and phymes-agents crates on the CPU with OpenAI API token services
cargo run --package phymes-ml --no-default-features --features wsl,openai_api --release --example chat -- --openai-asset Llama-3.2-1b-instruct
cargo run --package phymes-agents --no-default-features --features wsl,openai_api --release --example chat_agent_session
The examples can also be ran using WASM. However, all assets needed to run the example need to be provided locally unlike native where we can rely on the HuggingFace API to download and cache models for us. The following bash script can be used to build the examples in wasm and run the examples using wasmtime:
# build examples for the phymes-core crate
cargo build --package phymes-core --target wasm32-wasip2 --no-default-features --features wasip2 --release --example addrows
# run the examples for the phymes-core crate
wasmtime run target/wasm32-wasip2/release/examples/addrows.wasm
# build the chat example for the phymes-ml crate
cargo build --package phymes-ml --target wasm32-wasip2 --no-default-features --features wasip2,candle --release --example chat
# run the chat example for the phymes-agents crate
wasmtime --dir="$HOME/.cache/hf" --env=HOME=$HOME target/wasm32-wasip2/release/examples/chat.wasm --weights-config-file "$HOME/.cache/hf/models--HuggingFaceTB--SmolLM2-135M-Instruct/config.json" --weights-file "$HOME/.cache/hf/models--HuggingFaceTB--SmolLM2-135M-Instruct/smollm2-135m-instruct-q4_k_m.gguf" --tokenizer-file "$HOME/.cache/hf/models--HuggingFaceTB--SmolLM2-135M-Instruct/tokenizer.json" --tokenizer-config-file "$HOME/.cache/hf/models--HuggingFaceTB--SmolLM2-135M-Instruct/tokenizer_config.json" --candle-asset "SmoLM2-135M-chat"
# build the chat_agent_session example for the phymes-agents crate
cargo build --package phymes-agents --target wasm32-wasip2 --no-default-features --features wasip2,candle --release --example chat_agent_session
# run the chat_agent_session example for the phymes-agents crate
wasmtime --dir="$HOME/.cache/hf" --env=HOME=$HOME target/wasm32-wasip2/release/examples/chat_agent_session.wasm
Clippy lints
We use clippy for checking lints during development, and CI runs clippy checks.
Run the following to check for clippy lints:
cargo clippy --all-targets
If you use Visual Studio Code with the rust-analyzer plugin, you can enable clippy to run each time you save a file. See https://users.rust-lang.org/t/how-to-use-clippy-in-vs-code-with-rust-analyzer/41881.
One of the concerns with clippy is that it often produces a lot of false positives, or that some recommendations may hurt readability. We do not have a policy of which lints are ignored, but if you disagree with a clippy lint, you may disable the lint and briefly justify it.
Search for allow(clippy:: in the codebase to identify lints that are ignored/allowed. We currently prefer ignoring lints on the lowest unit possible.
- If you are introducing a line that returns a lint warning or error, you may disable the lint on that line.
- If you have several lints on a function or module, you may disable the lint on the function or module.
- If a lint is pervasive across multiple modules, you may disable it at the crate level.
Rustfmt Formatting
We use rustfmt for formatting during development, and CI runs rustfmt checks.
Run the following to check for rustfmt changes (before submitting a PR!):
cargo fmt --all -- --check
Rustdocs and mdBook for documentation
We use doc for API documentation hosted on crates.io and mdBook for the guide and tutorial static website with a mermaid preprocessor mdbook-mermaid is used for generating mermaid diagrams hosted on GitHub Pages.
Run the following to create the API documentation using doc:
cargo doc --document-private-items --no-deps -p phymes-core
cargo doc --document-private-items --no-deps -p phymes-ml
cargo doc --document-private-items --no-deps -p phymes-data
cargo doc --document-private-items --no-deps -p phymes-agents
cargo doc --document-private-items --no-deps -p phymes-server
cargo doc --document-private-items --no-deps -p phymes-app
Please visit the mdBook guide for installation and usage instructions. Also, please visit mdbook-mermaid for installation instructions. Run the following to create the the guide and tutorials using mdBook:
mdbook build phymes-book
Running Benchmarks
Running benchmarks are a good way to test the performance of a change. As benchmarks usually take a long time to run, we recommend running targeted tests instead of the full suite.
# run all benchmarks
cargo bench
# run phymes-agents benchmarks
cargo bench -p phymes-agents
# run benchmark for the candle_asset functions within the phymes-agents crate
cargo bench -p phymes-agents --bench candle_asset
To set the baseline for your benchmarks, use the --save-baseline flag:
git checkout main
cargo bench -p phymes-agents --bench candle_asset -- --save-baseline main
git checkout feature
cargo bench -p phymes-agents --bench candle_asset -- --baseline main
Running the CI locally
Continuous integration and deployment are orchestrated using GitHub actions on each pull request (PR) to the main branch. Unfortunately, debugging the CI/CD can be quite difficult and time consuming, so we recommend testing locally using a self-hosted runner.
First, follow the instructions for downloading, configuring, and using the self-hosted runner.
Second, be sure to change runs-on: ubuntu-latest to runs-on: self-hosted in the YAML for all workflow files for each job.
Third, Run the actions-runner. Now, when you open a PR, the CI will run locally on your machine.