casperbox 0.2.1__py3-none-any.whl

casperbox/__init__.py

@@ -0,0 +1,8 @@
+"""casperbox: build and run CASPER toolflow development containers with rootless podman."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("casperbox")
+except PackageNotFoundError:  # running from a source tree without installation
+    __version__ = "0+unknown"

casperbox/assets/common/packages/software.list

@@ -0,0 +1,70 @@
+# apt packages installed into the image by common/scripts/install_base.sh
+# One package per line; text after # is ignored.
+
+# ---- basic tools ----
+ca-certificates
+curl
+wget
+git
+sudo
+locales
+tzdata
+bzip2
+xz-utils
+unzip
+file
+less
+vim
+nano
+procps
+psmisc
+iproute2
+iputils-ping
+net-tools
+lsb-release
+
+# ---- build tools ----
+build-essential
+make
+gcc
+g++
+device-tree-compiler
+
+# ---- ssh / vnc / desktop ----
+openssh-server
+tigervnc-standalone-server
+tigervnc-common
+xfce4
+xfce4-terminal
+dbus-x11
+x11-xserver-utils
+x11-utils
+xfonts-base
+fonts-dejavu
+firefox
+
+# ---- Vivado runtime dependencies ----
+libtinfo5
+libncurses5
+libx11-6
+libxext6
+libxrender1
+libxtst6
+libxi6
+libxft2
+libxrandr2
+libxcursor1
+libxinerama1
+libsm6
+libice6
+libfreetype6
+libfontconfig1
+libglib2.0-0
+libgtk2.0-0
+libgtk-3-0
+libcanberra-gtk-module
+libcanberra-gtk3-module
+libasound2
+libgl1
+libglu1-mesa
+graphviz

casperbox/assets/common/rootfs/etc/profile.d/casper.sh

@@ -0,0 +1,48 @@
+# shellcheck shell=bash
+# CASPER toolflow environment: Vivado, mlib_devel (startsg.local), conda env
+# Sourced by /etc/profile (login shells) and ~/.bashrc (interactive shells); safe to source repeatedly.
+
+# Vivado settings64.sh etc. require bash
+[ -n "${BASH_VERSION:-}" ] || return 0
+[ -r /etc/casper/toolflow.env ] || return 0
+
+set -a
+# shellcheck disable=SC1091
+. /etc/casper/toolflow.env
+# Generated at container startup: VIVADO_DIR / XILINX_PATH / COMPOSER_PATH
+# shellcheck disable=SC1091
+[ -r /etc/casper/runtime.env ] && . /etc/casper/runtime.env
+set +a
+
+export MLIB_DEVEL_PATH="${CASPER_TOOLFLOW_DIR}/mlib_devel"
+
+# ~/.local/bin (scilab etc. are linked here)
+case ":${PATH}:" in
+    *":${HOME}/.local/bin:"*) ;;
+    *) export PATH="${HOME}/.local/bin:${PATH}" ;;
+esac
+
+# mlib_devel local config (XILINX_PATH / JASPER_BACKEND / XLNX_DT_REPO_PATH etc.)
+if [ -r "${MLIB_DEVEL_PATH}/startsg.local" ]; then
+    # shellcheck disable=SC1091
+    . "${MLIB_DEVEL_PATH}/startsg.local"
+fi
+
+# Vivado (load once to avoid growing PATH repeatedly)
+_casper_vivado_settings="${XILINX_PATH:-}/settings64.sh"
+if [ -z "${CASPER_VIVADO_LOADED:-}" ] && [ -n "${XILINX_PATH:-}" ] && [ -r "${_casper_vivado_settings}" ]; then
+    # shellcheck disable=SC1090
+    . "${_casper_vivado_settings}" >/dev/null
+    export CASPER_VIVADO_LOADED=1
+fi
+unset _casper_vivado_settings
+
+# conda: activate the toolflow python env by default (CONDA_ENV_NAME, e.g. casper)
+# Every shell must define the conda function and run activate:
+#   - environment variables are inherited from the parent, but the conda function and PS1 are not;
+#   - if the env is already active, conda only reactivates (no stacking) and restores the "(casper)" prompt.
+if [ -r /opt/conda/etc/profile.d/conda.sh ]; then
+    # shellcheck disable=SC1091
+    . /opt/conda/etc/profile.d/conda.sh
+    conda activate "${CONDA_ENV_NAME}"
+fi

casperbox/assets/common/rootfs/etc/ssh/sshd_config.d/casper.conf

@@ -0,0 +1,8 @@
+# casperbox: password login only, no root login
+PasswordAuthentication yes
+PubkeyAuthentication no
+PermitRootLogin no
+PermitEmptyPasswords no
+UsePAM yes
+X11Forwarding yes
+PrintMotd no

casperbox/assets/common/rootfs/usr/local/bin/entrypoint.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+# Container entrypoint (runs as root):
+#   1. Set the user password from CONTAINER_PWD and the VNC password from VNC_PASSWORD
+#   2. Start sshd (22) and vncserver :1 (5901)
+#   3. Stay in the foreground and clean up on stop signals
+set -euo pipefail
+
+log() { echo "[entrypoint] $*"; }
+
+# shellcheck disable=SC1091
+. /etc/casper/toolflow.env
+user="${CASPER_USER}"
+group="$(id -gn "${user}")"
+home_dir="/home/${user}"
+
+: "${CONTAINER_PWD:?CONTAINER_PWD is not set}"
+VNC_PASSWORD="${VNC_PASSWORD:-${CONTAINER_PWD}}"
+VNC_GEOMETRY="${VNC_GEOMETRY:-1920x1080}"
+if [[ ! "${VNC_GEOMETRY}" =~ ^[0-9]+x[0-9]+$ ]]; then
+    log "Invalid VNC_GEOMETRY: ${VNC_GEOMETRY}, using 1920x1080"
+    VNC_GEOMETRY=1920x1080
+fi
+
+# ---- Passwords ----
+log "Setting password for user ${user}"
+printf '%s:%s\n' "${user}" "${CONTAINER_PWD}" | chpasswd
+
+log "Setting VNC password"
+install -d -m 700 -o "${user}" -g "${group}" "${home_dir}/.vnc"
+printf '%s\n' "${VNC_PASSWORD}" | vncpasswd -f > "${home_dir}/.vnc/passwd"
+chown "${user}:${group}" "${home_dir}/.vnc/passwd"
+chmod 600 "${home_dir}/.vnc/passwd"
+if [[ ! -f "${home_dir}/.vnc/xstartup" ]]; then
+    install -m 755 -o "${user}" -g "${group}" /opt/casper/vnc/xstartup "${home_dir}/.vnc/xstartup"
+fi
+unset CONTAINER_PWD VNC_PASSWORD
+
+# ---- Vivado paths (mounted at the same path as on the host) ----
+# Two layouts are supported: <VIVADO_DIR>/Vivado/<version>/settings64.sh or <VIVADO_DIR>/settings64.sh
+: "${VIVADO_DIR:?VIVADO_DIR is not set}"
+xilinx_path=""
+composer_path=""
+if [[ -r "${VIVADO_DIR}/Vivado/${VIVADO_VERSION}/settings64.sh" ]]; then
+    xilinx_path="${VIVADO_DIR}/Vivado/${VIVADO_VERSION}"
+    [[ -d "${VIVADO_DIR}/Model_Composer/${VIVADO_VERSION}" ]] \
+        && composer_path="${VIVADO_DIR}/Model_Composer/${VIVADO_VERSION}"
+elif [[ -r "${VIVADO_DIR}/settings64.sh" ]]; then
+    xilinx_path="${VIVADO_DIR}"
+else
+    log "Warning: settings64.sh for Vivado ${VIVADO_VERSION} not found under ${VIVADO_DIR}, please check VIVADO_DIR"
+fi
+log "Vivado: ${xilinx_path:-<not found>}"
+{
+    echo "# Generated by the entrypoint at container startup"
+    printf "VIVADO_DIR='%s'\n" "${VIVADO_DIR}"
+    printf "XILINX_PATH='%s'\n" "${xilinx_path}"
+    printf "COMPOSER_PATH='%s'\n" "${composer_path}"
+} > /etc/casper/runtime.env
+chmod 644 /etc/casper/runtime.env
+
+# ---- sshd ----
+ssh-keygen -A >/dev/null
+mkdir -p /run/sshd
+log "Starting sshd"
+/usr/sbin/sshd
+
+# ---- vncserver ----
+rm -f /tmp/.X1-lock /tmp/.X11-unix/X1
+log "Starting vncserver :1 (${VNC_GEOMETRY})"
+su - "${user}" -c "vncserver :1 -geometry ${VNC_GEOMETRY} -depth 24 -localhost no -SecurityTypes VncAuth"
+
+cleanup() {
+    log "Stopping services"
+    su - "${user}" -c "vncserver -kill :1" >/dev/null 2>&1 || true
+    pkill -TERM -x sshd 2>/dev/null || true
+    exit 0
+}
+trap cleanup TERM INT
+
+log "Container ready (toolflow ${TOOLFLOW_VERSION})"
+sleep infinity &
+wait $!

casperbox/assets/common/scripts/config_mlib_devel.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# Configure mlib_devel (runs as the container user):
+#   1. Clone mlib_devel and device-tree-xlnx into ~/toolflow
+#   2. Install mlib_devel's python dependencies into the conda env
+#   3. Generate mlib_devel/startsg.local
+set -euo pipefail
+
+: "${MLIB_DEVEL_REPO:?}" "${MLIB_DEVEL_BRANCH:?}"
+: "${DEVICE_TREE_XLNX_REPO:?}" "${DEVICE_TREE_XLNX_BRANCH:?}"
+: "${CONDA_ENV_NAME:?}" "${VIVADO_VERSION:?}"
+CONDA_DIR="${CONDA_DIR:-/opt/conda}"
+GIT_CLONE_DEPTH="${GIT_CLONE_DEPTH:-1}"
+
+toolflow_dir="${HOME}/toolflow"
+mlib_dir="${toolflow_dir}/mlib_devel"
+dt_dir="${toolflow_dir}/device-tree-xlnx"
+
+depth_args=()
+if [[ "${GIT_CLONE_DEPTH}" != "0" ]]; then
+    depth_args=(--depth "${GIT_CLONE_DEPTH}")
+fi
+
+mkdir -p "${toolflow_dir}"
+
+echo ">>> Cloning mlib_devel (${MLIB_DEVEL_BRANCH})"
+git clone "${depth_args[@]}" --single-branch --branch "${MLIB_DEVEL_BRANCH}" \
+    "${MLIB_DEVEL_REPO}" "${mlib_dir}"
+
+echo ">>> Cloning device-tree-xlnx (${DEVICE_TREE_XLNX_BRANCH})"
+git clone "${depth_args[@]}" --single-branch --branch "${DEVICE_TREE_XLNX_BRANCH}" \
+    "${DEVICE_TREE_XLNX_REPO}" "${dt_dir}"
+
+echo ">>> Installing mlib_devel dependencies into conda env ${CONDA_ENV_NAME}"
+# shellcheck disable=SC1091
+source "${CONDA_DIR}/etc/profile.d/conda.sh"
+conda activate "${CONDA_ENV_NAME}"
+python -m pip install --no-cache-dir --upgrade pip
+# requirements.txt has -e git+... dependencies; put their sources in ~/toolflow/src
+(cd "${mlib_dir}" && python -m pip install --no-cache-dir --src "${toolflow_dir}/src" -r requirements.txt)
+
+echo ">>> Generating ${mlib_dir}/startsg.local"
+cat > "${mlib_dir}/startsg.local" <<EOF
+# Generated by casperbox at image build time
+# Vivado is mounted at the host path; the entrypoint writes /etc/casper/runtime.env at container startup
+[ -r /etc/casper/runtime.env ] && . /etc/casper/runtime.env
+export XILINX_PATH COMPOSER_PATH
+export PLATFORM=lin64
+export JASPER_BACKEND=vivado
+export XLNX_DT_REPO_PATH=${dt_dir}
+#export MATLAB_PATH=/path/to/matlab
+# python: shells activate conda env ${CONDA_ENV_NAME} automatically via /etc/profile.d/casper.sh
+EOF
+
+echo "mlib_devel configured: ${mlib_dir}"

casperbox/assets/common/scripts/create_user.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Create the container user: UID/GID match the host user, member of the sudo group.
+# The password is not set at build time; the entrypoint sets it from CONTAINER_PWD at startup.
+set -euo pipefail
+
+: "${CONTAINER_USER:?CONTAINER_USER is not set}"
+: "${USER_UID:?USER_UID is not set}"
+: "${USER_GID:?USER_GID is not set}"
+
+# Group: reuse the GID if it already exists, otherwise create it
+if getent group "${USER_GID}" >/dev/null; then
+    group_name="$(getent group "${USER_GID}" | cut -d: -f1)"
+else
+    groupadd -g "${USER_GID}" "${CONTAINER_USER}"
+    group_name="${CONTAINER_USER}"
+fi
+
+# If another user in the base image owns the UID (e.g. the ubuntu user), remove it
+if existing="$(getent passwd "${USER_UID}" | cut -d: -f1)" && [[ -n "${existing}" ]] \
+        && [[ "${existing}" != "${CONTAINER_USER}" ]]; then
+    echo "UID ${USER_UID} is used by ${existing}, removing that user"
+    userdel -r "${existing}" 2>/dev/null || userdel "${existing}"
+fi
+
+useradd -m -u "${USER_UID}" -g "${group_name}" -G sudo -s /bin/bash "${CONTAINER_USER}"
+
+home_dir="/home/${CONTAINER_USER}"
+
+# Pre-create mount points and work directories with correct ownership
+mkdir -p "${home_dir}/work" "${home_dir}/.Xilinx" "${home_dir}/toolflow" "${home_dir}/.vnc"
+chown -R "${USER_UID}:${USER_GID}" "${home_dir}"
+
+# Non-login shells (e.g. terminals opened in VNC) also load the toolflow environment
+cat >> "${home_dir}/.bashrc" <<'EOF'
+
+# CASPER toolflow environment (Vivado / conda / mlib_devel)
+[ -r /etc/profile.d/casper.sh ] && . /etc/profile.d/casper.sh
+EOF
+chown "${USER_UID}:${USER_GID}" "${home_dir}/.bashrc"

casperbox/assets/common/scripts/install_base.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Install the system packages listed in common/packages/software.list
+set -euo pipefail
+
+export DEBIAN_FRONTEND=noninteractive
+
+# Package list: one package per line, # starts a comment
+pkg_list="${1:-/opt/casper/packages/software.list}"
+[[ -r "${pkg_list}" ]] || { echo "Error: package list not found: ${pkg_list}" >&2; exit 1; }
+mapfile -t packages < <(sed -e 's/#.*//' -e 's/[[:space:]]//g' -e '/^$/d' "${pkg_list}")
+(( ${#packages[@]} > 0 )) || { echo "Error: no packages in ${pkg_list}" >&2; exit 1; }
+echo "Installing ${#packages[@]} packages from ${pkg_list}"
+
+apt-get update
+apt-get install -y --no-install-recommends "${packages[@]}"
+
+# locale
+sed -i 's/^# *\(en_US.UTF-8 UTF-8\)/\1/' /etc/locale.gen
+locale-gen
+update-locale LANG=en_US.UTF-8
+
+# sshd: no auditd in the container, make pam_loginuid optional to avoid login failures
+mkdir -p /run/sshd
+sed -i 's/^\(session\s\+\)required\(\s\+pam_loginuid.so\)/\1optional\2/' /etc/pam.d/sshd
+
+apt-get clean
+rm -rf /var/lib/apt/lists/*

casperbox/assets/common/scripts/install_miniconda.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Install Miniconda to ${CONDA_DIR} (default /opt/conda) and hand ownership to the container user
+set -euo pipefail
+
+: "${MINICONDA_INSTALLER:?MINICONDA_INSTALLER is not set}"
+: "${CONTAINER_USER:?CONTAINER_USER is not set}"
+CONDA_DIR="${CONDA_DIR:-/opt/conda}"
+
+tmp_dir="$(mktemp -d)"
+trap 'rm -rf "${tmp_dir}"' EXIT
+
+curl -fL --retry 3 -o "${tmp_dir}/miniconda.sh" \
+    "https://repo.anaconda.com/miniconda/${MINICONDA_INSTALLER}"
+bash "${tmp_dir}/miniconda.sh" -b -p "${CONDA_DIR}"
+
+# Use conda-forge only, avoiding the Terms of Service restrictions of the Anaconda defaults channel
+cat > "${CONDA_DIR}/.condarc" <<'EOF'
+channels:
+  - conda-forge
+channel_priority: strict
+auto_activate_base: false
+EOF
+
+"${CONDA_DIR}/bin/conda" clean -afy
+
+# Let the container user install/upgrade packages
+chown -R "${CONTAINER_USER}:$(id -gn "${CONTAINER_USER}")" "${CONDA_DIR}"

casperbox/assets/common/scripts/install_scilab.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# Install Scilab:
+#   1. Download the .tar.gz / .tar.xz archive at SCILAB_URL
+#   2. Extract it to /opt/scilab (stripping the top-level scilab-<version>/ directory)
+#   3. Link the executable to the container user's ~/.local/bin/scilab
+# Runs as root, after create_user.sh.
+set -euo pipefail
+
+: "${SCILAB_VERSION:?SCILAB_VERSION is not set}"
+: "${SCILAB_URL:?SCILAB_URL is not set}"
+: "${CONTAINER_USER:?CONTAINER_USER is not set}"
+
+install_dir=/opt/scilab
+user_group="$(id -gn "${CONTAINER_USER}")"
+user_bin="/home/${CONTAINER_USER}/.local/bin"
+
+case "${SCILAB_URL}" in
+    *.tar.gz|*.tgz|*.tar.xz) ;;
+    *) echo "Error: SCILAB_URL must point to a .tar.gz or .tar.xz archive: ${SCILAB_URL}" >&2; exit 1 ;;
+esac
+
+tmp_dir="$(mktemp -d)"
+trap 'rm -rf "${tmp_dir}"' EXIT
+archive="${tmp_dir}/$(basename "${SCILAB_URL}")"
+
+echo "Downloading Scilab ${SCILAB_VERSION}: ${SCILAB_URL}"
+curl -fL --retry 3 -o "${archive}" "${SCILAB_URL}"
+
+# Extract to /opt/scilab (tar detects gz / xz automatically)
+rm -rf "${install_dir}"
+mkdir -p "${install_dir}"
+tar -xf "${archive}" -C "${install_dir}" --strip-components=1
+
+if [[ ! -x "${install_dir}/bin/scilab" ]]; then
+    echo "Error: ${install_dir}/bin/scilab not found after extraction, please check the archive" >&2
+    exit 1
+fi
+
+# Link to the user's ~/.local/bin/scilab (owned by the container user, so pip --user etc. work)
+install -d -m 755 -o "${CONTAINER_USER}" -g "${user_group}" \
+    "/home/${CONTAINER_USER}/.local" "${user_bin}"
+ln -sfn "${install_dir}/bin/scilab" "${user_bin}/scilab"
+chown -h "${CONTAINER_USER}:${user_group}" "${user_bin}/scilab"
+
+echo "Scilab ${SCILAB_VERSION} installed to ${install_dir}, linked at ${user_bin}/scilab"

casperbox/assets/common/scripts/setup_conda_env.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# Create conda env CONDA_ENV_NAME with PYTHON_VERSION (runs as the container user)
+set -euo pipefail
+
+: "${PYTHON_VERSION:?PYTHON_VERSION is not set}"
+: "${CONDA_ENV_NAME:?CONDA_ENV_NAME is not set}"
+CONDA_DIR="${CONDA_DIR:-/opt/conda}"
+
+# shellcheck disable=SC1091
+source "${CONDA_DIR}/etc/profile.d/conda.sh"
+
+conda create -y -n "${CONDA_ENV_NAME}" --override-channels -c conda-forge \
+    "python=${PYTHON_VERSION}" pip
+conda clean -afy
+
+echo "conda env ${CONDA_ENV_NAME} (python ${PYTHON_VERSION}) created"

casperbox/assets/common/vnc/xstartup

@@ -0,0 +1,9 @@
+#!/bin/sh
+# TigerVNC session startup: XFCE desktop
+unset SESSION_MANAGER
+unset DBUS_SESSION_BUS_ADDRESS
+export XDG_SESSION_TYPE=x11
+
+[ -r "$HOME/.Xresources" ] && xrdb "$HOME/.Xresources"
+
+exec dbus-launch --exit-with-session startxfce4

casperbox/assets/versions/m2021a/Dockerfile

@@ -0,0 +1,85 @@
+# CASPER toolflow m2021a image
+# Built by `casper build`: build args come from versions/m2021a/toolflow.toml and the
+# user's casper.toml; the build context is the package's assets/ directory.
+# Do not change the defaults here to switch versions.
+
+ARG BASE_IMAGE=docker.io/library/ubuntu:20.04
+FROM ${BASE_IMAGE}
+
+# ---- toolflow version args (from toolflow.toml) ----
+ARG TOOLFLOW_VERSION
+ARG VIVADO_VERSION
+ARG MINICONDA_INSTALLER
+ARG PYTHON_VERSION
+ARG CONDA_ENV_NAME
+ARG MLIB_DEVEL_REPO
+ARG MLIB_DEVEL_BRANCH
+ARG DEVICE_TREE_XLNX_REPO
+ARG DEVICE_TREE_XLNX_BRANCH
+ARG GIT_CLONE_DEPTH=1
+ARG SCILAB_VERSION
+ARG SCILAB_URL
+
+# ---- user args (from casper.toml / host) ----
+ARG CONTAINER_USER=casper
+ARG USER_UID=1000
+ARG USER_GID=1000
+
+LABEL casper.toolflow.version="${TOOLFLOW_VERSION}" \
+      casper.user="${CONTAINER_USER}" \
+      casper.uid="${USER_UID}" \
+      casper.gid="${USER_GID}"
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    LANG=en_US.UTF-8 \
+    LC_ALL=en_US.UTF-8 \
+    CONDA_DIR=/opt/conda
+
+SHELL ["/bin/bash", "-o", "pipefail", "-c"]
+
+# 1. System packages: openssh-server / tigervnc / firefox / desktop / Vivado dependencies
+COPY common/packages/software.list /opt/casper/packages/
+COPY common/scripts/install_base.sh /opt/casper/scripts/
+RUN bash /opt/casper/scripts/install_base.sh
+
+# 2. Create the user (UID/GID match the host, for userns keep-id)
+COPY common/scripts/create_user.sh /opt/casper/scripts/
+RUN bash /opt/casper/scripts/create_user.sh
+
+# 3. Scilab: extract to /opt/scilab, link to ~/.local/bin/scilab (requires the user)
+COPY common/scripts/install_scilab.sh /opt/casper/scripts/
+RUN bash /opt/casper/scripts/install_scilab.sh
+
+# 4. Miniconda
+COPY common/scripts/install_miniconda.sh /opt/casper/scripts/
+RUN bash /opt/casper/scripts/install_miniconda.sh
+
+# 5. conda env + mlib_devel (run as the regular user so file ownership is correct)
+COPY common/scripts/setup_conda_env.sh common/scripts/config_mlib_devel.sh /opt/casper/scripts/
+USER ${CONTAINER_USER}
+RUN HOME="/home/${CONTAINER_USER}" bash /opt/casper/scripts/setup_conda_env.sh
+RUN HOME="/home/${CONTAINER_USER}" bash /opt/casper/scripts/config_mlib_devel.sh
+USER root
+
+# 6. Runtime files: sshd config, profile, entrypoint, VNC xstartup
+COPY common/rootfs/ /
+COPY common/vnc/xstartup /opt/casper/vnc/xstartup
+RUN chmod 755 /usr/local/bin/entrypoint.sh /opt/casper/vnc/xstartup \
+ && chmod 644 /etc/profile.d/casper.sh /etc/ssh/sshd_config.d/casper.conf \
+ && mkdir -p /etc/casper \
+ && { \
+      echo "CASPER_USER=${CONTAINER_USER}"; \
+      echo "CASPER_TOOLFLOW_DIR=/home/${CONTAINER_USER}/toolflow"; \
+      echo "TOOLFLOW_VERSION=${TOOLFLOW_VERSION}"; \
+      echo "VIVADO_VERSION=${VIVADO_VERSION}"; \
+      echo "PYTHON_VERSION=${PYTHON_VERSION}"; \
+      echo "CONDA_ENV_NAME=${CONDA_ENV_NAME}"; \
+      echo "MLIB_DEVEL_BRANCH=${MLIB_DEVEL_BRANCH}"; \
+      echo "DEVICE_TREE_XLNX_BRANCH=${DEVICE_TREE_XLNX_BRANCH}"; \
+      echo "SCILAB_VERSION=${SCILAB_VERSION}"; \
+    } > /etc/casper/toolflow.env \
+ && chmod 644 /etc/casper/toolflow.env
+
+EXPOSE 22 5901
+
+ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]

casperbox/assets/versions/m2021a/toolflow.toml

@@ -0,0 +1,32 @@
+# CASPER toolflow m2021a version definition
+#
+# Managed by the maintainers and shipped with the casper tool; users do not edit it.
+# Every key is passed to the Dockerfile as a build arg of the same name.
+
+TOOLFLOW_VERSION = "m2021a"
+
+# Base image (fully qualified name to avoid podman short-name prompts)
+BASE_IMAGE = "docker.io/library/ubuntu:20.04"
+
+# Vivado version: vivado.dir must contain Vivado/<VIVADO_VERSION>/settings64.sh
+VIVADO_VERSION = "2021.1"
+
+# Python / conda
+MINICONDA_INSTALLER = "Miniconda3-latest-Linux-x86_64.sh"
+PYTHON_VERSION = "3.14"
+CONDA_ENV_NAME = "casper"
+
+# mlib_devel
+MLIB_DEVEL_REPO = "https://github.com/liuweiseu/mlib_devel.git"
+MLIB_DEVEL_BRANCH = "scilab-dev-ai"
+
+# device-tree-xlnx (used by mlib_devel via XLNX_DT_REPO_PATH)
+DEVICE_TREE_XLNX_REPO = "https://github.com/Xilinx/device-tree-xlnx.git"
+DEVICE_TREE_XLNX_BRANCH = "xlnx_rel_v2021.1"
+
+# git clone depth (0 = full history)
+GIT_CLONE_DEPTH = "1"
+
+# Scilab
+SCILAB_VERSION = "2024.1.0"
+SCILAB_URL = "https://www.scilab.org/download/2024.1.0/scilab-2024.1.0.bin.x86_64-linux-gnu.tar.xz"