Provided by: distrobox_1.3.1-2_all bug

COMPATIBILITY

       This  project does not need a dedicated image.  It can use any OCI images from docker-hub,
       quay.io, or any registry of your choice.

       Granted, they may not be as featureful as expected (some of them do not even  have  which,
       mount, less or vi) but that’s all doable in the container itself after bootstrapping it.

       The  main concern is having basic Linux utilities (mount), basic user management utilities
       (usermod, passwd), and sudo correctly set.

   SUPPORTED CONTAINER MANAGERS
       distrobox can run on either podman or docker

       It depends either on podman configured in rootless mode or on  docker  configured  without
       sudo     (follow    THIS    instructions    (https://docs.docker.com/engine/install/linux-
       postinstall/))

       • Minimum podman version: 2.1.0

       • Minimum docker version: 18.06.1

       Follow the official installation guide here:

       • <https://podman.io/getting-started/installation>

       • <https://docs.docker.com/engine/install>

       • <https://docs.docker.com/engine/install/linux-postinstall/>

   CONTAINERS DISTROS
       Distrobox guests tested successfully with the following container images:

       Distro                    Version                    Images
       ──────────────────────────────────────────────────────────────────────────────────────────────────────────────
       AlmaLinux (UBI)           8                          quay.io/almalinux/8-base:8
                                                            quay.io/almalinux/8-init:8
       AlmaLinux                 8 8-minimal 9 9-minimal    quay.io/almalinux/almalinux:8
                                                            quay.io/almalinux/almalinux:9
                                                            quay.io/almalinux/almalinux:9-minimal
       Alpine Linux              3.15 3.16                  docker.io/library/alpine:3.15
                                                            docker.io/library/alpine:3.16
                                                            docker.io/library/alpine:latest
       AmazonLinux               1 2 2022                   public.ecr.aws/amazonlinux/amazonlinux:1
                                                            public.ecr.aws/amazonlinux/amazonlinux:2
                                                            public.ecr.aws/amazonlinux/amazonlinux:2022.0.20220531.0
       Archlinux                                            docker.io/library/archlinux:latest
       CentOS Stream             8 9                        quay.io/centos/centos:stream8
                                                            quay.io/centos/centos:stream9
       CentOS                    7                          quay.io/centos/centos:7
       ClearLinux                                           docker.io/library/clearlinux:latest
                                                            docker.io/library/clearlinux:base
       Debian                    7 8 9 10 11                docker.io/debian/eol:wheezy   docker.io/library/debian:8
                                                            docker.io/library/debian:9   docker.io/library/debian:10
                                                            docker.io/library/debian:stable
                                                            docker.io/library/debian:stable-backports
       Debian                    Testing                    docker.io/library/debian:testing
                                                            docker.io/library/debian:testing-backports
       Debian                    Unstable                   docker.io/library/debian:unstable

       Fedora                    35 36 37 Rawhide           registry.fedoraproject.org/fedora-toolbox:35
                                                            quay.io/fedora/fedora:35        quay.io/fedora/fedora:36
                                                            registry.fedoraproject.org/fedora:37
                                                            quay.io/fedora/fedora:rawhide
       Gentoo Linux              rolling                    You  will  have  to  Build  your  own to have a complete
                                                            Gentoo docker image
       Kali Linux                rolling                    docker.io/kalilinux/kali-rolling:latest
       Mageia                    8                          docker.io/library/mageia
       Neurodebian               nd100                      docker.io/library/neurodebian:nd100
       Opensuse                  Leap                       registry.opensuse.org/opensuse/leap:latest
       Opensuse                  Tumbleweed                 registry.opensuse.org/opensuse/tumbleweed:latest
                                                            registry.opensuse.org/opensuse/toolbox:latest
       Oracle Linux              6  6-slim  7  7-slim  8    container-registry.oracle.com/os/oraclelinux:6
                                 8-slim 9 9-slim            container-registry.oracle.com/os/oraclelinux:6-slim
                                                            container-registry.oracle.com/os/oraclelinux:7
                                                            container-registry.oracle.com/os/oraclelinux:7-slim
                                                            container-registry.oracle.com/os/oraclelinux:8
                                                            container-registry.oracle.com/os/oraclelinux:8-slim
                                                            container-registry.oracle.com/os/oraclelinux:9
                                                            container-registry.oracle.com/os/oraclelinux:9-slim
       RedHat (UBI)              7 8 9                      registry.access.redhat.com/ubi7/ubi
                                                            registry.access.redhat.com/ubi7/ubi-init
                                                            registry.access.redhat.com/ubi7/ubi-minimal
                                                            registry.access.redhat.com/ubi8/ubi
                                                            registry.access.redhat.com/ubi8/ubi-init
                                                            registry.access.redhat.com/ubi8/ubi-minimal
                                                            registry.access.redhat.com/ubi9/ubi
                                                            registry.access.redhat.com/ubi9/ubi-init
                                                            registry.access.redhat.com/ubi9/ubi-minimal
       Rocky Linux               8 8-minimal                quay.io/rockylinux/rockylinux:8
                                                            quay.io/rockylinux/rockylinux:8-minimal
                                                            quay.io/rockylinux/rockylinux:latest
       Scientific Linux          7                          docker.io/library/sl:7
       Slackware                 14.2                       docker.io/vbatts/slackware:14.2
       Ubuntu                    14.04 16.04 18.04 20.04    docker.io/library/ubuntu:14.04
                                 22.04 22.10                docker.io/library/ubuntu:16.04
                                                            docker.io/library/ubuntu:18.04
                                                            docker.io/library/ubuntu:20.04
                                                            docker.io/library/ubuntu:22.04
                                                            docker.io/library/ubuntu:22.10
       Void Linux                                           ghcr.io/void-linux/void-linux:latest-full-x86_64
                                                            ghcr.io/void-linux/void-linux:latest-full-x86_64-musl

       Note however that if you use a non-toolbox preconfigured image (e.g.  images pre-baked  to
       work  with  <https://github.com/containers/toolbox),>  the  first  distrobox-enter  you’ll
       perform can take a while as it will download and install the missing dependencies.

       A small time tax to pay for the ability to use any type of image.   This  will  not  occur
       after the first time, subsequent enters will be much faster.

       NixOS  is  not  a  supported  container  distro, and there are currently no plans to bring
       support to it.  If you are looking for unprivlaged NixOS environments, we suggest you look
       into nix-shell (https://nixos.org/manual/nix/unstable/command-ref/nix-shell.html).

   NEW DISTRO SUPPORT
       If  your  distro of choice is not on the list, open an issue requesting support for it, we
       can work together to check if it is possible to add support for it.

       Or just try using it anyway, if it works, open an issue and it will be added to the list!

   OLDER DISTRIBUTIONS
       For older distributions like CentOS 5, CentOS 6, Debian 6, Ubuntu 12.04, compatibility  is
       not assured.

       Their  libc version is incompatible with kernel releases after >=4.11.  A work around this
       is to use the vsyscall=emulate flag in the bootloader of the host.

       Keep also in mind that mirrors could be down for such old releases, so you  will  need  to
       build a custom distrobox image to ensure basic dependencies are met.

NAME

              distrobox create
              distrobox-create

DESCRIPTION

       distrobox-create  takes  care  of  creating  the container with input name and image.  The
       created container will be tightly integrated with the host, allowing sharing of  the  HOME
       directory  of  the  user,  external  storage,  external  usb  devices  and  graphical apps
       (X11/Wayland), and audio.

SYNOPSIS

       distrobox create

              --image/-i:     image to use for the container  default: registry.fedoraproject.org/fedora-toolbox:36
              --name/-n:      name for the distrobox      default: my-distrobox
              --pull/-p:      pull latest image unconditionally without asking
              --yes/-Y:       non-interactive, pull images without asking
              --root/-r:      launch podman/docker with root privileges. Note that if you need root this is the preferred
                          way over "sudo distrobox" (note: if using a program other than 'sudo' for root privileges is necessary,
                          specify it through the DBX_SUDO_PROGRAM env variable, or 'distrobox_sudo_program' config variable)
              --clone/-c:     name of the distrobox container to use as base for a new container
                          this will be useful to either rename an existing distrobox or have multiple copies
                          of the same environment.
              --home/-H       select a custom HOME directory for the container. Useful to avoid host's home littering with temp files.
              --volume        additional volumes to add to the container
              --additional-flags/-a:  additional flags to pass to the container manager command
              --init-hooks        additional commands to execute during container initialization
              --pre-init-hooks    additional commands to execute prior to container initialization
              --init/-I       use init system (like systemd) inside the container.
                          this will make host's processes not visible from within the container.
              --help/-h:      show this message
              --dry-run/-d:       only print the container manager command generated
              --verbose/-v:       show more verbosity
              --version/-V:       show version

COMPATIBILITY

              for a list of compatible images and container managers, please consult the man page:
                  man distrobox
                  man distrobox-compatibility
              or consult the documentation page on: https://github.com/89luca89/distrobox/blob/main/docs/compatibility.md#containers-distros

EXAMPLES

              distrobox create --image alpine:latest --name test --init-hooks "touch /var/tmp/test1 && touch /var/tmp/test2"
              distrobox create --image fedora:35 --name test --additional-flags "--env MY_VAR-value"
              distrobox create --image fedora:35 --name test --volume /opt/my-dir:/usr/local/my-dir:rw --additional-flags "--pids-limit -1"
              distrobox create -i docker.io/almalinux/8-init --init --name test --pre-init-hooks "dnf config-manager --enable powertools && dnf -y install epel-release"
              distrobox create --clone fedora-35 --name fedora-35-copy
              distrobox create --image alpine my-alpine-container
              distrobox create --image registry.fedoraproject.org/fedora-toolbox:35 --name fedora-toolbox-35
              distrobox create --pull --image centos:stream9 --home ~/distrobox/centos9

       You can also use environment variables to specify  container  name,  image  and  container
       manager:

              DBX_CONTAINER_MANAGER="docker" DBX_NON_INTERACTIVE=1 DBX_CONTAINER_NAME=test-alpine DBX_CONTAINER_IMAGE=alpine distrobox-create

       Supported environment variables:

              DBX_CONTAINER_ALWAYS_PULL
              DBX_CONTAINER_CUSTOM_HOME
              DBX_CONTAINER_IMAGE
              DBX_CONTAINER_MANAGER
              DBX_CONTAINER_NAME
              DBX_NON_INTERACTIVE
              DBX_SUDO_PROGRAM

       The --additional-flags or -a is useful to modify defaults in the container creations.  For
       example:

              distrobox create -i docker.io/library/archlinux -n dev-arch

              podman container inspect dev-arch | jq '.[0].HostConfig.PidsLimit'
              2048

              distrobox rm -f dev-arch
              distrobox create -i docker.io/library/archlinux -n dev-arch --volume $CBL_TC:/tc --additional-flags "--pids-limit -1"

              podman container inspect dev-arch | jq '.[0].HostConfig,.PidsLimit'
              0

       Additional volumes can be specified using the --volume flag.  This flag follows  the  same
       standard   as   docker   and   podman   to   specify   the   mount   point   so   --volume
       SOURCE_PATH:DEST_PATH:MODE.

              distrobox create --image docker.io/library/archlinux --name dev-arch --volume /usr/share/:/var/test:ro

       During container creation, it is possible to specify  (using  the  additional-flags)  some
       environment  variables  that  will  persist  in the container and be independent from your
       environment:

              distrobox create --image fedora:35 --name test --additional-flags "--env MY_VAR-value"

       The --init-hooks is useful to add commands to the  entrypoint  (init)  of  the  container.
       This  could  be  useful to create containers with a set of programs already installed, add
       users, groups.

              distrobox create  --image fedora:35 --name test --init-hooks "dnf groupinstall -y \"C Development Tools and Libraries\""

       The --init is useful to create a container that will use  its  own  separate  init  system
       within.  For example using:

              distrobox create -i docker.io/almalinux/8-init --init-hooks "dnf install -y openssh-server" --init --name test

       Inside the container we will be able to use normal systemd units:

              ~$ distrobox enter test
              user@test:~$ sudo systemctl enable --now sshd
              user@test:~$ sudo systemctl status sshd
                  ● sshd.service - OpenSSH server daemon
                     Loaded: loaded (/usr/lib/systemd/system/sshd.service; enabled; vendor preset: enabled)
                     Active: active (running) since Fri 2022-01-28 22:54:50 CET; 17s ago
                       Docs: man:sshd(8)
                             man:sshd_config(5)
                   Main PID: 291 (sshd)

       Note  that  enabling  --init  will  disable  host’s  process integration.  From within the
       container you will not be able to see and manage host’s processes.  This is needed because
       /sbin/init must be pid 1.

NAME

              distrobox enter
              distrobox-enter

DESCRIPTION

       distrobox-enter  takes  care  of  entering the container with the name specified.  Default
       command executed is your SHELL, but you can specify different shells or entire commands to
       execute.   If  using it inside a script, an application, or a service, you can specify the
       –headless mode to disable tty and interactivity.

SYNOPSIS

       distrobox enter

              --name/-n:      name for the distrobox                      default: my-distrobox
              --/-e:          end arguments execute the rest as command to execute at login   default: bash -l
              --no-tty/-T:        do not instantiate a tty
              --no-workdir/-nw:       always start the container from container's home directory
              --additional-flags/-a:  additional flags to pass to the container manager command
              --help/-h:      show this message
              --root/-r:      launch podman/docker with root privileges. Note that if you need root this is the preferred
                          way over "sudo distrobox" (note: if using a program other than 'sudo' for root privileges is necessary,
                          specify it through the DBX_SUDO_PROGRAM env variable, or 'distrobox_sudo_program' config variable)
              --dry-run/-d:       only print the container manager command generated
              --verbose/-v:       show more verbosity
              --version/-V:       show version

EXAMPLES

              distrobox-enter --name fedora-toolbox-35 -- bash -l
              distrobox-enter my-alpine-container -- sh -l
              distrobox-enter --additional-flags "--preserve-fds" --name test -- bash -l
              distrobox-enter --additional-flags "--env MY_VAR=value" --name test -- bash -l
              MY_VAR=value distrobox-enter --additional-flags "--preserve-fds" --name test -- bash -l

       You can also use environment variables to specify container manager and container name:

              DBX_CONTAINER_MANAGER="docker" DBX_CONTAINER_NAME=test-alpine distrobox-enter

       Supported environment variables:

              DBX_CONTAINER_NAME
              DBX_CONTAINER_MANAGER
              DBX_SKIP_WORKDIR
              DBX_SUDO_PROGRAM

       This is used to enter the distrobox itself.  Personally, I just create  multiple  profiles
       in my gnome-terminal to have multiple distros accessible.

       The  --additional-flags  or  -a  is useful to modify default command when executing in the
       container.  For example:

              distrobox enter -n dev-arch --additional-flags "--env my_var=test" -- printenv &| grep my_var
              my_var=test

       This is possible also using normal env variables:

              my_var=test distrobox enter -n dev-arch --additional-flags -- printenv &| grep my_var
              my_var=test

       If you’d like to enter a rootful container having  distrobox  use  a  program  other  than
       `sudo'  to  run podman/docker as root, such as `pkexec' or `doas', you may specify it with
       the DBX_SUDO_PROGRAM environment variable.  For example, to use `doas' to enter a  rootful
       container:

              DBX_SUDO_PROGRAM="doas" distrobox enter -n container --root

       Additionally,  in  one  of  the  config  file  paths  that  distrobox  supports,  such  as
       ~/.distroboxrc, you can also append the line distrobox_sudo_program="doas"  (for  example)
       to always run distrobox commands involving rootful containers using `doas'.

NAME

              distrobox ephemeral
              distrobox-ephemeral

DESCRIPTION

       distrobox-ephemeral creates a temporary distrobox that is automatically destroyed when the
       command is terminated.

SYNOPSIS

       distrobox ephemeral

              --root/-r:      launch podman/docker with root privileges. Note that if you need root this is the preferred
                          way over "sudo distrobox" (note: if using a program other than 'sudo' for root privileges is necessary,
                          specify it through the DBX_SUDO_PROGRAM env variable, or 'distrobox_sudo_program' config variable)
              --verbose/-v:       show more verbosity
              --help/-h:      show this message
              --/-e:          end arguments execute the rest as command to execute at login   default: bash -l
              --version/-V:       show version

EXAMPLES

              distrobox-ephemeral --image alpine:latest -- cat /etc/os-release
              distrobox-ephemeral --root --verbose --image alpine:latest --volume /opt:/opt

       You can also use flags from distrobox-create to customize the ephemeral container to run.

       Refer to

              man distrobox-create

       or

              distrobox-create --help

       Supported environment variables:

              distrobox-ephemeral calls distrobox-create, SEE ALSO distrobox-create(1) for
              a list of supported environment variables to use.

NAME

              distrobox-export

DESCRIPTION

       Application and service exporting

       distrobox-export takes care of exporting an app a binary or a service from  the  container
       to the host.

       The  exported  app  will  be  easily  available  in  your  normal  launcher  and  it  will
       automatically be launched from the container it is exported from.

SYNOPSIS

       distrobox-export

              --app/-a:       name of the application to export
              --bin/-b:       absolute path of the binary to export
              --service/-s:       name of the service to export
              --delete/-d:        delete exported application or service
              --export-label/-el: label to add to exported application name.
                          Defaults to (on \$container_name)
              --export-path/-ep:  path where to export the binary
              --extra-flags/-ef:  extra flags to add to the command
              --sudo/-S:      specify if the exported item should be run as sudo
              --help/-h:      show this message
              --verbose/-v:       show more verbosity
              --version/-V:       show version

       You may want to install graphical applications or user services in your distrobox.   Using
       distrobox-export from inside the container will let you use them from the host itself.

EXAMPLES

              distrobox-export --app mpv [--extra-flags "flags"] [--delete] [--sudo]
              distrobox-export --service syncthing [--extra-flags "flags"] [--delete] [--sudo]
              distrobox-export --bin /path/to/bin --export-path ~/.local/bin [--extra-flags "flags"] [--delete] [--sudo]

       App export example

              distrobox-export --app abiword

       This  tool  will  simply copy the original .desktop files along with needed icons, add the
       prefix /usr/local/bin/distrobox-enter -n distrobox_name -e ... to the commands to run, and
       save them in your home to be used directly from the host as a normal app.

       Service export example

              distrobox-export --service syncthing --extra-flags "--allow-newer-config"
              distrobox-export --service nginx --sudo

       For  services,  it  will  similarly  export  the  systemd  unit  inside the container to a
       systemctl --user service,  prefixing  the  various  ExecStart  ExecStartPre  ExecStartPost
       ExecReload ExecStop ExecStopPost with the distrobox-enter command prefix.

       The exported services will be available in the host’s user’s systemd session, so

              systemctl --user status exported_service_name

       will show the status of the service exported.

       Binary export example

              distrobox-export --bin /usr/bin/code --extra-flags "--foreground" --export-path $HOME/.local/bin

       In  the case of exporting binaries, you will have to specify where to export it (--export-
       path) and the tool will create a little wrapper script that will distrobox-enter  -e  from
       the  host, the desired binary.  This can be handy with the use of direnv to have different
       versions of the same binary based on your env or project.

       The exported binaries will be exported in the “–export-path” of choice as a wrapper script
       that  acts  naturally  both on the host and in the container.  Note that “–export-path” is
       NOT OPTIONAL, you have to explicitly set it.

       Additional flags

       You can specify additional flags to add to the command, for example if you want to  export
       an electron app, you could add the “–foreground” flag to the command:

              distrobox-export --app atom --extra-flags "--foreground"
              distrobox-export --bin /usr/bin/vim --export-path ~/.local/bin --extra-flags "-p"
              distrobox-export --service syncthing --extra-flags "-allow-newer-config"

       This  works for services, binaries, and apps.  Extra flags are only used then the exported
       app, binary, or service is used from the host, using them inside the  container  will  not
       include them.

       Unexport

       The option “–delete” will un-export an app, binary, or service.

              distrobox-export --app atom --delete
              distrobox-export --bin /usr/bin/vim --export-path ~/.local/bin --delete
              distrobox-export --service syncthing --delete
              distrobox-export --service nginx --delete

       Run as root in the container

       The option “–sudo” will launch the exported item as root inside the distrobox.

       Exporting apps from rootful containers

       It  is  worth  noting that, when exporting any item - which includes graphical apps - from
       rootful containers (created with distrobox create --root), root privileges will be  needed
       every  time  the  item  is  launched  (in order to enter the rootful container), which, by
       default, is done using sudo (see docs for  distrobox-enter  on  how  to  customize  that).
       However,  for  graphical apps in specific, since they launch without a terminal, the usage
       of sudo might, at first, make it impossible to launch them.

       To fix this without needing to customize  the  sudo  program,  one  can  define  a  global
       SUDO_ASKPASS  environment variable on their machine, which is a PATH to an executable that
       is run by sudo when no terminal is available (or when it is  given  the  --askpass  or  -A
       option),  and  the output of that executable to stdout is used as the password input.  The
       executable is called as many times is needed for authentication as root to succeed (unless
       a limit of amount of attempts is reached).

       To do this, pick a program to ask the user for graphical password input.  In this example,
       we will use zenity --password, which should be present for GNOME users (and  can  also  be
       installed  in  other  DEs) - there are other options, such as kdialog --password "Message"
       for KDE users.

       Write the call to the desired program to  a  script  file,  for  example  to  /usr/bin/my-
       password-prompt (sample contents below):

              #!/bin/sh
              zenity --password "Authentication as root is required"

       (You  may  save  the  script under, for example, ~/.local/bin if you want to keep it fully
       local to your user.)

       Afterwards, make it  executable  (e.g. run  sudo  chmod  +x  /usr/bin/my-password-prompt).
       Then,  make  sure  to set SUDO_ASKPASS to "/usr/bin/my-password-prompt" (replace with your
       script’s path) in a global profile file, so that it is picked  up  by  sudo  when  running
       graphical  apps  (and,  therefore,  sudo  will  run  the  script  you created to ask for a
       password).      This      is      done      with      the      shell      line      export
       SUDO_ASKPASS="/path/to/script/goes/here".   You  can do this for your user only by running
       the command below (replace the script path as needed):

              echo 'export SUDO_ASKPASS="/usr/bin/my-password-prompt"' >> ~/.profile

       Which appends the appropriate line to the end of your ~/.profile  file,  thus  making  the
       change  local to your user.  Alternatively, to set it system-wide (for all users), you may
       create a file in /etc/profile.d/ (or equivalent for your system) with that line.

       Now just log out and log back in, and graphical  apps  exported  from  rootful  containers
       should  now  be  properly  asking  for  root’s  password  before launching (instead of not
       opening, if that was the case before).

       Notes

       Note you can use –app OR –bin OR –service but not together.

              distrobox-export --service nginx --sudo

       [IMAGE:                             app-export                              (https://user-
       images.githubusercontent.com/598882/144294795-c7785620-bf68-4d1b-b251-1e1f0a32a08d.png)]

       [IMAGE:                            service-export                           (https://user-
       images.githubusercontent.com/598882/144294314-29a8921f-4511-453d-bf8e-d0d1e336db91.png)]

       NOTE: some electron apps such as vscode and atom need additional flags to work from inside
       the container, use the --extra-flags option to provide a series of flags, for example:

       distrobox-export --app atom --extra-flags "--foreground"

NAME

              distrobox-host-exec

DESCRIPTION

       distrobox-host-exec lets one execute command on the host, while inside of a container.

       If “flatpak-spawn” is installed in the container, this is what is used, and it is the most
       powerful and recommended method.  If, instead, “flatpak-spawn” can’t be  found,  it  still
       try to get the job done with “host-spawn”, an alternative project.

SYNOPSIS

       Just pass to “distrobox-host-exec” any command and all its arguments, if any.

              distrobox-host-exec [command [arguments]]

              --help/-h:      show this message
              --verbose/-v:       show more verbosity
              --version/-V:       show version

       If no command is provided, it will execute “$SHELL”.

       Alternatively, use symlinks to make distrobox-host-exec execute as that command:

              ~$: ln -s /usr/bin/distrobox-host-exec /usr/local/bin/podman
              ~$: ls -l /usr/local/bin/podman
              lrwxrwxrwx. 1 root root 51 Jul 11 19:26 /usr/local/bin/podman -> /usr/bin/distrobox-host-exec
              ~$: podman version
              ...this is executed on host...

EXAMPLES

              distrobox-host-exec ls
              distrobox-host-exec bash -l
              distrobox-host-exec flatpak run org.mozilla.firefox
              distrobox-host-exec podman ps -a

NAME

              distrobox-init

DESCRIPTION

       Init the distrobox (not to be launched manually)

       distrobox-init  is  the entrypoint of a created distrobox.  Note that this HAS to run from
       inside a distrobox, will not work if you run it from your host.

       This is not intended to be used manually, but instead used by distrobox-create to  set  up
       the container’s entrypoint.

       distrobox-init  will  take care of installing missing dependencies (eg.  sudo), set up the
       user and groups, mount directories from the host to ensure the tight integration.

SYNOPSIS

       distrobox-init

              --name/-n:      user name
              --user/-u:      uid of the user
              --group/-g:     gid of the user
              --home/-d:      path/to/home of the user
              --help/-h:      show this message
              --init/-I:      whether to use or not init
              --pre-init-hooks:   commands to execute prior to init
              --verbose/-v:       show more verbosity
              --version/-V:       show version
              --:         end arguments execute the rest as command to execute during init

EXAMPLES

              distrobox-init --name test-user --user 1000 --group 1000 --home /home/test-user

NAME

              distrobox list
              distrobox-list

DESCRIPTION

       distrobox-list lists available distroboxes.  It detects them  and  lists  them  separately
       from the rest of normal podman or docker containers.

SYNOPSIS

       distrobox list

              --help/-h:      show this message
              --no-color:     disable color formatting
              --root/-r:      launch podman/docker with root privileges. Note that if you need root this is the preferred
                          way over "sudo distrobox" (note: if using a program other than 'sudo' for root privileges is necessary,
                          specify it through the DBX_SUDO_PROGRAM env variable, or 'distrobox_sudo_program' config variable)
              --size/-s:      show also container size
              --verbose/-v:       show more verbosity
              --version/-V:       show version

EXAMPLES

              distrobox-list

       You can also use environment variables to specify container manager

              DBX_CONTAINER_MANAGER="docker" distrobox-list

       Supported environment variables:

              DBX_CONTAINER_MANAGER
              DBX_SUDO_PROGRAM

       [IMAGE:     image    (https://user-images.githubusercontent.com/598882/147831082-24b5bc2e-
       b47e-49ac-9b1a-a209478c9705.png)]

NAME

              distrobox rm
              distrobox-rm

DESCRIPTION

       distrobox-rm delete one of the available distroboxes.

SYNOPSIS

       distrobox rm

              --name/-n:      name for the distrobox
              --force/-f:     force deletion
              --root/-r:      launch podman/docker with root privileges. Note that if you need root this is the preferred
                          way over "sudo distrobox" (note: if using a program other than 'sudo' for root privileges is necessary,
                          specify it through the DBX_SUDO_PROGRAM env variable, or 'distrobox_sudo_program' config variable)
              --help/-h:      show this message
              --verbose/-v:       show more verbosity
              --version/-V:       show version

EXAMPLES

              distrobox-rm --name container-name [--force]
              distrobox-rm container-name [-f]

       You can also use environment variables to specify container manager and name:

              DBX_CONTAINER_MANAGER="docker" DBX_CONTAINER_NAME=test-alpine distrobox-rm

       Supported environment variables:

              DBX_CONTAINER_MANAGER
              DBX_CONTAINER_NAME
              DBX_NON_INTERACTIVE
              DBX_SUDO_PROGRAM

NAME

              distrobox stop
              distrobox-stop

DESCRIPTION

       distrobox-stop stop a running distrobox.

       Distroboxes are left running, even after exiting out of them, so  that  subsequent  enters
       are really quick.  This is how they can be stopped.

SYNOPSIS

       distrobox stop

              --name/-n:      name for the distrobox
              --yes/-Y:       non-interactive, stop without asking
              --help/-h:      show this message
              --root/-r:      launch podman/docker with root privileges. Note that if you need root this is the preferred
                          way over "sudo distrobox" (note: if using a program other than 'sudo' for root privileges is necessary,
                          specify it through the DBX_SUDO_PROGRAM env variable, or 'distrobox_sudo_program' config variable)
              --verbose/-v:       show more verbosity
              --version/-V:       show version

EXAMPLES

              distrobox-stop --name container-name
              distrobox-stop container-name

       You can also use environment variables to specify container manager and name:

              DBX_CONTAINER_MANAGER="docker" DBX_CONTAINER_NAME=test-alpine distrobox-stop

       Supported environment variables:

              DBX_CONTAINER_MANAGER
              DBX_CONTAINER_NAME
              DBX_NON_INTERACTIVE
              DBX_SUDO_PROGRAM