# Where Den Fits Den is useful when the operating system should be a small bootable envelope around a locked conda package graph. That makes it different from a general server distribution, but close to several proven Linux image patterns. Use these support levels when reading the examples: | Level | Meaning | | --- | --- | | `runnable today` | The current Den prototype can build and smoke this pattern locally. | | `prototype-ready` | The current model fits, but production integration is still missing. | | `blueprint` | The pattern is documented as direction, not as a working target. | | `out of scope for now` | The pattern needs substantial platform work before Den should claim it. | ## Cloud And Server Images Ubuntu, Debian, RHEL, and CentOS are often used as cloud images because cloud providers know how to boot them, inject metadata, seed SSH keys, and apply first-boot configuration. Ubuntu publishes official cloud images, and cloud-init describes the common model: clone a generic image, then give each instance its identity through metadata and user data. Den is `prototype-ready` for this shape. It can build a QEMU UEFI image and has a NoCloud-style seed smoke path, but it is not yet a provider-ready cloud image for EC2, GCE, Azure, OpenStack, or similar services. Good starter use: - internal VM image for one controlled environment, - repeatable service appliance for QEMU or a local hypervisor, - CI image tests that exercise first-boot configuration. Missing pieces: - provider metadata services beyond the current NoCloud smoke path, - published image formats and marketplace upload flows, - cloud-init compatibility or an explicitly smaller Den-native alternative, - image signing and release provenance. Research anchors: [Ubuntu Cloud Images](https://cloud-images.ubuntu.com/), [cloud-init](https://cloud-init.io/), and the [OpenStack image guide](https://docs.openstack.org/image-guide/obtain-images.html). ## Software Appliances And JeOS Just Enough Operating System images package a small OS with one application or service. SUSE documents this as an appliance pattern, and KIWI builds images that include the OS plus preconfigured application payloads. Photon OS uses a similar reduced-surface idea for cloud, edge, and appliance deployments. Den is `runnable today` as a conda-native OCI base image for application containers. The first practical examples build a Python web container and a SciPy job container from `den:dev`. Den is `prototype-ready` for bootable VM appliances where the workload is integrated into the system generation with conda packages and systemd units. That path is more OS-native, but it is less familiar to application teams than building a container from a base image. Good starter use: - a single internal HTTP service container, - a batch analysis worker container, - an appliance image shipped to a controlled VM environment, - a reproducible demo system for a conda-based application stack. Missing pieces: - installer flow, - appliance update policy for running machines, - signed release images, - complete SBOM and license reports. Research anchors: [SUSE JeOS](https://www.suse.com/topics/definition/jeos-just-enough-operating-system/), [SUSE KIWI](https://documentation.suse.com/appliance/kiwi-9/single-html/kiwi/index.html), and [Photon OS](https://vmware.github.io/photon/). ## Container Hosts Fedora CoreOS and similar systems are small, automatically updated hosts for containerized workloads. They make the host image boring on purpose, then put most application change into containers or declarative host configuration. Den is a `blueprint` for this shape as a booted host that runs Docker or Podman. The generation model and locked package graph fit the idea of a controlled host, but Den does not yet provide a container runtime package, kernel and cgroup policy, an automatic update agent, or fleet management. Good future use: - conda-native host for running a small number of containers, - single-purpose container appliance where the host itself needs conda tools, - reproducible image for CI agents. Missing pieces: - Podman, Docker, or another runtime policy, - cgroup and namespace smoke tests, - update scheduling and rollback after failed boot, - host hardening profile, - fleet identity and remote management. Research anchor: [Fedora CoreOS](https://fedoraproject.org/coreos/). ## Edge, Lab, And Embedded Systems Buildroot, Yocto, balenaOS, and Ubuntu Frame show different ways to build small images for devices, kiosks, gateways, and long-lived embedded systems. Den already uses Buildroot for the early boot layer, but deliberately moves the general system package graph into conda. Den is `prototype-ready` for headless lab gateways and data-collection appliances. GUI kiosk, POS, and digital signage patterns are `blueprint` only until Den has a graphics stack, input policy, and display manager story. Good starter use: - lab instrument gateway, - small service node with a fixed Python stack, - field data collector that writes local artifacts, - training image for a reproducible scientific workflow. Missing pieces: - hardware enablement beyond QEMU targets, - persistent configuration model, - OTA update and rollback policy, - GUI/Wayland stack for kiosk workloads, - secure boot and device identity. Research anchors: [Buildroot](https://buildroot.org/), [Yocto Project](https://www.yoctoproject.org/), [balenaOS](https://www.balena.io/os), and [Ubuntu Frame](https://ubuntu.com/frame/docs/24/tutorial/deploy-graphical-application-with-frame/). ## Scientific, HPC, And Data Workloads Scientific Linux deployments often use Ubuntu, Debian, RHEL, or CentOS with environment modules, conda environments, or Apptainer containers layered on top. The common need is reproducibility without giving every user full control over the host. Den is `runnable today` for single-purpose scientific job images and `blueprint` for multi-user HPC nodes. The conda-owned system graph is a strong fit for NumPy, SciPy, and Python data stacks, but Den does not yet integrate with Slurm, shared filesystems, environment modules, GPUs, or site identity. Good starter use: - reproducible SciPy batch image, - teaching or workshop VM with a pinned scientific stack, - internal analysis appliance that emits local files, - prototype for a Jupyter-style appliance before multi-user hardening. Missing pieces: - scheduler integration, - shared storage policy, - GPU/CUDA packaging and driver boundary, - multi-user authentication and resource limits, - notebook service hardening. Research anchors: [Apptainer](https://apptainer.org/user-docs/master/introduction.html), [HPC environment modules](https://docs.rcc.fsu.edu/hpc/environment-modules/), and [JupyterHub](https://jupyterhub.readthedocs.io/). ## CI And Build Images GitHub-hosted Linux runners show why predictable base images matter: jobs need known tool versions, repeatable architecture support, and tight permission boundaries. Den is not a GitHub-hosted runner replacement, but it can be a useful way to test the package graph and boot path that later production images will use. Den is `prototype-ready` for CI image validation and `runnable today` for local rootfs, QEMU, OCI inspection, and UEFI smoke tests. Good starter use: - validate that a conda workload boots under systemd, - test rootfs layout manifests before publishing package changes, - compare linux-64 and linux-aarch64 package behavior, - generate package reports for a staged image. Missing pieces: - release-grade artifact attestations, - immutable release image publication, - full SBOM and legal-info pipeline, - dedicated runner bootstrap and secret policy. Research anchors: GitHub's guidance on [secure use of Actions](https://docs.github.com/en/actions/reference/security/secure-use), [artifact attestations](https://docs.github.com/actions/security-for-github-actions/using-artifact-attestations/using-artifact-attestations-to-establish-provenance-for-builds), and [GitHub-hosted runners](https://docs.github.com/en/actions/reference/runners/github-hosted-runners).