diff --git a/bin/junest b/bin/junest
index 3b7eb87..17d32bc 100755
--- a/bin/junest
+++ b/bin/junest
@@ -39,22 +39,27 @@ usage() {
     echo -e "            -d, --delete                   Delete $NAME from ${JUNEST_HOME}"
     echo
     echo -e "  n[s]                                     Access via Linux Namespaces using BubbleWrap (Default action)"
+    echo -e "            -f, --fakeroot                 Run $NAME with fakeroot privileges"
+    echo -e "            --backend-command <cmd>        Bwrap command to use"
     echo -e "            -b, --backend-args <args>      Arguments for bwrap backend program"
     echo -e "                                           ($CMD ns -b \"--help\" to check out the bwrap options)"
     echo -e "            -n, --no-copy-files            Do not copy common etc files into $NAME environment"
     echo
     echo -e "  p[root]                                  Access via PRoot"
     echo -e "            -f, --fakeroot                 Run $NAME with fakeroot privileges"
+    echo -e "            --backend-command <cmd>        PRoot command to use"
     echo -e "            -b, --backend-args <args>      Arguments for PRoot backend program"
     echo -e "                                           ($CMD proot -b \"--help\" to check out the PRoot options)"
     echo -e "            -n, --no-copy-files            Do not copy common etc files into $NAME environment"
     echo
     echo -e "  g[root]                                  Access with root privileges via GRoot"
+    echo -e "            --backend-command <cmd>        GRoot command to use"
     echo -e "            -b, --backend-args <args>      Arguments for GRoot backend program"
     echo -e "                                           ($CMD groot -b \"--help\" to check out the GRoot options)"
     echo -e "            -n, --no-copy-files            Do not copy common etc files into $NAME environment"
     echo
     echo -e "  r[oot]                                   Access with root privileges via classic chroot"
+    echo -e "            --backend-command <cmd>        Chroot command to use"
     echo -e "            -b, --backend-args <args>      Arguments for chroot backend program"
     echo -e "                                           ($CMD root -b \"--help\" to check out the chroot options)"
     echo -e "            -n, --no-copy-files            Do not copy common etc files into $NAME environment"
@@ -114,15 +119,16 @@ function parse_arguments(){
 
 function _parse_root_opts() {
     # Options:
-    OPT_BACKEND_ARGS=false
     BACKEND_ARGS=""
     OPT_NO_COPY_FILES=false
+    BACKEND_COMMAND=""
 
     while [[ -n "$1" ]]
     do
         case "$1" in
-            -b|--backend-args) OPT_BACKEND_ARGS=true ; shift ; BACKEND_ARGS=$1; shift ;;
+            -b|--backend-args) shift ; BACKEND_ARGS=$1; shift ;;
             -n|--no-copy-files) OPT_NO_COPY_FILES=true ; shift ;;
+            --backend-command) shift; BACKEND_COMMAND="$1"; shift ;;
             --) shift ; break ;;
             -*) die "Invalid option $1" ;;
             *) break ;;
@@ -139,16 +145,17 @@ function _parse_root_opts() {
 function _parse_ns_opts() {
     # Options:
     OPT_FAKEROOT=false
-    OPT_BACKEND_ARGS=false
     BACKEND_ARGS=""
     OPT_NO_COPY_FILES=false
+    BACKEND_COMMAND=""
 
     while [[ -n "$1" ]]
     do
         case "$1" in
             -f|--fakeroot) OPT_FAKEROOT=true ; shift ;;
-            -b|--backend-args) OPT_BACKEND_ARGS=true ; shift ; BACKEND_ARGS=$1; shift ;;
+            -b|--backend-args) shift ; BACKEND_ARGS=$1; shift ;;
             -n|--no-copy-files) OPT_NO_COPY_FILES=true ; shift ;;
+            --backend-command) shift; BACKEND_COMMAND="$1"; shift ;;
             --) shift ; break ;;
             -*) die "Invalid option $1" ;;
             *) break ;;
@@ -165,16 +172,17 @@ function _parse_ns_opts() {
 function _parse_proot_opts() {
     # Options:
     OPT_FAKEROOT=false
-    OPT_BACKEND_ARGS=false
     BACKEND_ARGS=""
     OPT_NO_COPY_FILES=false
+    BACKEND_COMMAND=""
 
     while [[ -n "$1" ]]
     do
         case "$1" in
             -f|--fakeroot) OPT_FAKEROOT=true ; shift ;;
-            -b|--backend-args) OPT_BACKEND_ARGS=true ; shift ; BACKEND_ARGS=$1; shift ;;
+            -b|--backend-args) shift ; BACKEND_ARGS=$1; shift ;;
             -n|--no-copy-files) OPT_NO_COPY_FILES=true ; shift ;;
+            --backend-command) shift; BACKEND_COMMAND="$1"; shift ;;
             --) shift ; break ;;
             -*) die "Invalid option $1" ;;
             *) break ;;
@@ -269,7 +277,7 @@ function execute_operation() {
         run_env=run_env_as_chroot
     fi
 
-    $run_env "${BACKEND_ARGS}" $OPT_NO_COPY_FILES "${ARGS[@]}"
+    $run_env "$BACKEND_COMMAND" "${BACKEND_ARGS}" $OPT_NO_COPY_FILES "${ARGS[@]}"
 
 }
 
diff --git a/lib/core/chroot.sh b/lib/core/chroot.sh
index eb584f0..635137b 100644
--- a/lib/core/chroot.sh
+++ b/lib/core/chroot.sh
@@ -58,15 +58,18 @@ function _run_env_as_xroot(){
 function run_env_as_groot(){
     check_nested_env
 
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
+
+    [[ -z "$backend_command" ]] && backend_command="$GROOT"
 
     provide_common_bindings
     local bindings=${RESULT}
     unset RESULT
 
-    _run_env_as_xroot "$GROOT $bindings" "$backend_args" "$no_copy_files" "$@"
+    _run_env_as_xroot "$backend_command $bindings" "$backend_args" "$no_copy_files" "$@"
 }
 
 #######################################
@@ -92,9 +95,12 @@ function run_env_as_groot(){
 function run_env_as_chroot(){
     check_nested_env
 
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
 
-    _run_env_as_xroot chroot_cmd "$backend_args" "$no_copy_files" "$@"
+    [[ -z "$backend_command" ]] && backend_command=chroot_cmd
+
+    _run_env_as_xroot "$backend_command" "$backend_args" "$no_copy_files" "$@"
 }
diff --git a/lib/core/namespace.sh b/lib/core/namespace.sh
index 39080e0..1307de0 100644
--- a/lib/core/namespace.sh
+++ b/lib/core/namespace.sh
@@ -56,14 +56,17 @@ function _check_user_namespace() {
 }
 
 function _run_env_with_bwrap(){
-    local backend_args="$1"
-    shift
+    local backend_command="$1"
+    local backend_args="$2"
+    shift 2
+
+    [[ -z "$backend_command" ]] && backend_command=bwrap_cmd
 
     if [[ "$1" != "" ]]
     then
-        JUNEST_ENV=1 bwrap_cmd --bind "$JUNEST_HOME" / --bind "$HOME" "$HOME" --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try ${backend_args} "${SH[@]}" "-c" "$(insert_quotes_on_spaces "${@}")"
+        JUNEST_ENV=1 "$backend_command" --bind "$JUNEST_HOME" / --bind "$HOME" "$HOME" --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try ${backend_args} "${SH[@]}" "-c" "$(insert_quotes_on_spaces "${@}")"
     else
-        JUNEST_ENV=1 bwrap_cmd --bind "$JUNEST_HOME" / --bind "$HOME" "$HOME" --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try ${backend_args} "${SH[@]}"
+        JUNEST_ENV=1 "$backend_command" --bind "$JUNEST_HOME" / --bind "$HOME" "$HOME" --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try ${backend_args} "${SH[@]}"
     fi
 
 }
@@ -89,9 +92,10 @@ function _run_env_with_bwrap(){
 function run_env_as_bwrap_fakeroot(){
     check_nested_env
 
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
 
     _check_user_namespace
 
@@ -102,7 +106,7 @@ function run_env_as_bwrap_fakeroot(){
         copy_common_files
     fi
 
-    _run_env_with_bwrap "--uid 0 $backend_args" "$@"
+    _run_env_with_bwrap "$backend_command" "--uid 0 $backend_args" "$@"
 }
 
 
@@ -126,9 +130,10 @@ function run_env_as_bwrap_fakeroot(){
 function run_env_as_bwrap_user() {
     check_nested_env
 
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
 
     _check_user_namespace
 
@@ -145,7 +150,7 @@ function run_env_as_bwrap_user() {
         copy_passwd_and_group
     fi
 
-    _run_env_with_bwrap "$backend_args" "$@"
+    _run_env_with_bwrap "$backend_command" "$backend_args" "$@"
 }
 
 
diff --git a/lib/core/proot.sh b/lib/core/proot.sh
index d2bfd5f..a1eee73 100644
--- a/lib/core/proot.sh
+++ b/lib/core/proot.sh
@@ -9,19 +9,25 @@
 # vim: ft=sh
 
 function _run_env_with_proot(){
-    local proot_args="$1"
-    shift
+    local backend_command="$1"
+    local backend_args="$2"
+    shift 2
+
+    [[ -z "$backend_command" ]] && backend_command=proot_cmd
 
     if [ "$1" != "" ]
     then
-        JUNEST_ENV=1 proot_cmd "${proot_args}" "${SH[@]}" "-c" "$(insert_quotes_on_spaces "${@}")"
+        JUNEST_ENV=1 "${backend_command}" "${backend_args}" "${SH[@]}" "-c" "$(insert_quotes_on_spaces "${@}")"
     else
-        JUNEST_ENV=1 proot_cmd "${proot_args}" "${SH[@]}"
+        JUNEST_ENV=1 "${backend_command}" "${backend_args}" "${SH[@]}"
     fi
 }
 
 function _run_env_with_qemu(){
-    local proot_args="$1"
+    local backend_command="$1"
+    local backend_args="$2"
+    shift 2
+
     source ${JUNEST_HOME}/etc/junest/info
 
     if [ "$JUNEST_ARCH" != "$ARCH" ]
@@ -34,10 +40,10 @@ function _run_env_with_qemu(){
         warn "Emulating $NAME via QEMU..."
         [ -e ${qemu_symlink} ] || \
             ln_cmd -s ${JUNEST_HOME}/bin/${qemu_bin} ${qemu_symlink}
-        proot_args="-q ${qemu_symlink} $proot_args"
+        backend_args="-q ${qemu_symlink} $backend_args"
     fi
-    shift
-    _run_env_with_proot "$proot_args" "${@}"
+
+    _run_env_with_proot "$backend_args" "${@}"
 }
 
 #######################################
@@ -63,9 +69,10 @@ function run_env_as_proot_fakeroot(){
         die_on_status $ROOT_ACCESS_ERROR "You cannot access with root privileges. Use --groot option instead."
     check_nested_env
 
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
 
     if ! $no_copy_files
     then
@@ -78,7 +85,7 @@ function run_env_as_proot_fakeroot(){
 
     # An alternative is via -S option:
     #_run_env_with_qemu "-S ${JUNEST_HOME} $1" "${@:2}"
-    _run_env_with_qemu "-0 ${bindings} -r ${JUNEST_HOME} $backend_args" "$@"
+    _run_env_with_qemu "$backend_command" "-0 ${bindings} -r ${JUNEST_HOME} $backend_args" "$@"
 }
 
 #######################################
@@ -104,9 +111,10 @@ function run_env_as_proot_user(){
         die_on_status $ROOT_ACCESS_ERROR "You cannot access with root privileges. Use --groot option instead."
     check_nested_env
 
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
 
     if ! $no_copy_files
     then
@@ -127,5 +135,5 @@ function run_env_as_proot_user(){
     local bindings=${RESULT}
     unset RESULT
 
-    _run_env_with_qemu "${bindings} -r ${JUNEST_HOME} $backend_args" "$@"
+    _run_env_with_qemu "$backend_command" "${bindings} -r ${JUNEST_HOME} $backend_args" "$@"
 }
diff --git a/tests/unit-tests/test-chroot.sh b/tests/unit-tests/test-chroot.sh
index b2e5e70..4556671 100755
--- a/tests/unit-tests/test-chroot.sh
+++ b/tests/unit-tests/test-chroot.sh
@@ -32,20 +32,28 @@ function init_mocks() {
         echo "chroot_cmd $@"
     }
     GROOT=chroot_cmd
+    mychroot() {
+        echo mychroot $@
+    }
 }
 
 function test_run_env_as_groot_cmd(){
-    assertCommandSuccess run_env_as_groot "" "false" pwd
+    assertCommandSuccess run_env_as_groot "" "" "false" pwd
     assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
 }
 
 function test_run_env_as_groot_no_cmd(){
-    assertCommandSuccess run_env_as_groot "" "false" ""
+    assertCommandSuccess run_env_as_groot "" "" "false" ""
     assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login -c /bin/sh --login" "$(cat $STDOUTF)"
 }
 
+function test_run_env_as_groot_with_backend_command(){
+    assertCommandSuccess run_env_as_groot "mychroot" "" "false" ""
+    assertEquals "mychroot -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login -c /bin/sh --login" "$(cat $STDOUTF)"
+}
+
 function test_run_env_as_groot_no_copy(){
-    assertCommandSuccess run_env_as_groot "" "true" pwd
+    assertCommandSuccess run_env_as_groot "" "" "true" pwd
     assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
 
     [[ ! -e ${JUNEST_HOME}/etc/hosts ]]
@@ -60,27 +68,32 @@ function test_run_env_as_groot_no_copy(){
 
 function test_run_env_as_groot_nested_env(){
     JUNEST_ENV=1
-    assertCommandFailOnStatus 106 run_env_as_groot "" "false" ""
+    assertCommandFailOnStatus 106 run_env_as_groot "" "" "false" ""
     unset JUNEST_ENV
 }
 
 function test_run_env_as_groot_cmd_with_backend_args(){
-    assertCommandSuccess run_env_as_groot "-n -b /home/blah" "false" pwd
+    assertCommandSuccess run_env_as_groot "" "-n -b /home/blah" "false" pwd
     assertEquals "chroot_cmd -b $HOME -b /tmp -b /proc -b /sys -b /dev -n -b /home/blah $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
 }
 
 function test_run_env_as_chroot_cmd(){
-    assertCommandSuccess run_env_as_chroot "" "false" pwd
+    assertCommandSuccess run_env_as_chroot "" "" "false" pwd
     assertEquals "chroot_cmd $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
 }
 
 function test_run_env_as_chroot_no_cmd(){
-    assertCommandSuccess run_env_as_chroot "" "false" ""
+    assertCommandSuccess run_env_as_chroot "" "" "false" ""
     assertEquals "chroot_cmd $JUNEST_HOME /bin/sh --login -c /bin/sh --login" "$(cat $STDOUTF)"
 }
 
+function test_run_env_as_chroot_with_backend_command(){
+    assertCommandSuccess run_env_as_chroot "mychroot" "" "false" ""
+    assertEquals "mychroot $JUNEST_HOME /bin/sh --login -c /bin/sh --login" "$(cat $STDOUTF)"
+}
+
 function test_run_env_as_chroot_no_copy(){
-    assertCommandSuccess run_env_as_chroot "" "true" pwd
+    assertCommandSuccess run_env_as_chroot "" "" "true" pwd
     assertEquals "chroot_cmd $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
 
     [[ ! -e ${JUNEST_HOME}/etc/hosts ]]
@@ -95,12 +108,12 @@ function test_run_env_as_chroot_no_copy(){
 
 function test_run_env_as_choot_nested_env(){
     JUNEST_ENV=1
-    assertCommandFailOnStatus 106 run_env_as_chroot "" "false" ""
+    assertCommandFailOnStatus 106 run_env_as_chroot "" "" "false" ""
     unset JUNEST_ENV
 }
 
 function test_run_env_as_chroot_cmd_with_backend_args(){
-    assertCommandSuccess run_env_as_chroot "-n -b /home/blah" "false" pwd
+    assertCommandSuccess run_env_as_chroot "" "-n -b /home/blah" "false" pwd
     assertEquals "chroot_cmd -n -b /home/blah $JUNEST_HOME /bin/sh --login -c pwd" "$(cat $STDOUTF)"
 }
 
diff --git a/tests/unit-tests/test-junest.sh b/tests/unit-tests/test-junest.sh
index db7d184..e3c7ee1 100755
--- a/tests/unit-tests/test-junest.sh
+++ b/tests/unit-tests/test-junest.sh
@@ -38,40 +38,46 @@ function setup_env(){
     echo "setup_env($1)"
 }
 function run_env_as_proot_fakeroot(){
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
-    echo "run_env_as_proot_fakeroot($backend_args,$no_copy_files,$@)"
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
+    echo "run_env_as_proot_fakeroot($backend_command,$backend_args,$no_copy_files,$@)"
 }
 function run_env_as_groot(){
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
-    echo "run_env_as_groot($backend_args,$no_copy_files,$@)"
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
+    echo "run_env_as_groot($backend_command,$backend_args,$no_copy_files,$@)"
 }
 function run_env_as_chroot(){
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
-    echo "run_env_as_chroot($backend_args,$no_copy_files,$@)"
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
+    echo "run_env_as_chroot($backend_command,$backend_args,$no_copy_files,$@)"
 }
 function run_env_as_proot_user(){
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
-    echo "run_env_as_proot_user($backend_args,$no_copy_files,$@)"
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
+    echo "run_env_as_proot_user($backend_command,$backend_args,$no_copy_files,$@)"
 }
 function run_env_as_bwrap_fakeroot(){
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
-    echo "run_env_as_bwrap_fakeroot($backend_args,$no_copy_files,$@)"
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
+    echo "run_env_as_bwrap_fakeroot($backend_command,$backend_args,$no_copy_files,$@)"
 }
 function run_env_as_bwrap_user(){
-    local backend_args="$1"
-    local no_copy_files="$2"
-    shift 2
-    echo "run_env_as_bwrap_user($backend_args,$no_copy_files,$@)"
+    local backend_command="$1"
+    local backend_args="$2"
+    local no_copy_files="$3"
+    shift 3
+    echo "run_env_as_bwrap_user($backend_command,$backend_args,$no_copy_files,$@)"
 }
 
 function test_help(){
@@ -139,20 +145,25 @@ function test_setup_env(){
 
 function test_run_env_as_proot_fakeroot(){
     assertCommandSuccess main p -f
-    assertEquals "run_env_as_proot_fakeroot(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main proot --fakeroot
-    assertEquals "run_env_as_proot_fakeroot(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main p -f -n
-    assertEquals "run_env_as_proot_fakeroot(,true,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,,true,)" "$(cat $STDOUTF)"
+
+    assertCommandSuccess main p -f --backend-command blah
+    assertEquals "run_env_as_proot_fakeroot(blah,,false,)" "$(cat $STDOUTF)"
+    assertCommandSuccess main proot -f --backend-command blah
+    assertEquals "run_env_as_proot_fakeroot(blah,,false,)" "$(cat $STDOUTF)"
 
     assertCommandSuccess main proot -f -b "-b arg"
-    assertEquals "run_env_as_proot_fakeroot(-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,-b arg,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main proot -f -b "-b arg" -- command -kv
-    assertEquals "run_env_as_proot_fakeroot(-b arg,false,command -kv)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,-b arg,false,command -kv)" "$(cat $STDOUTF)"
     assertCommandSuccess main proot -f command --as
-    assertEquals "run_env_as_proot_fakeroot(,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
     assertCommandSuccess main proot -f  -- command --as
-    assertEquals "run_env_as_proot_fakeroot(,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
 
     is_env_installed(){
         return 1
@@ -162,18 +173,23 @@ function test_run_env_as_proot_fakeroot(){
 
 function test_run_env_as_user(){
     assertCommandSuccess main proot
-    assertEquals "run_env_as_proot_user(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main p -n
-    assertEquals "run_env_as_proot_user(,true,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,,true,)" "$(cat $STDOUTF)"
+
+    assertCommandSuccess main p --backend-command blah
+    assertEquals "run_env_as_proot_user(blah,,false,)" "$(cat $STDOUTF)"
+    assertCommandSuccess main proot --backend-command blah
+    assertEquals "run_env_as_proot_user(blah,,false,)" "$(cat $STDOUTF)"
 
     assertCommandSuccess main proot -b "-b arg"
-    assertEquals "run_env_as_proot_user(-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,-b arg,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main proot -b "-b arg" -- command -ll
-    assertEquals "run_env_as_proot_user(-b arg,false,command -ll)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,-b arg,false,command -ll)" "$(cat $STDOUTF)"
     assertCommandSuccess main proot command -ls
-    assertEquals "run_env_as_proot_user(,false,command -ls)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,,false,command -ls)" "$(cat $STDOUTF)"
     assertCommandSuccess main proot -- command -ls
-    assertEquals "run_env_as_proot_user(,false,command -ls)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_proot_user(,,false,command -ls)" "$(cat $STDOUTF)"
 
     is_env_installed(){
         return 1
@@ -183,15 +199,21 @@ function test_run_env_as_user(){
 
 function test_run_env_as_groot(){
     assertCommandSuccess main g
-    assertEquals "run_env_as_groot(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(,,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main g -n
-    assertEquals "run_env_as_groot(,true,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(,,true,)" "$(cat $STDOUTF)"
     assertCommandSuccess main g -b "-b arg"
-    assertEquals "run_env_as_groot(-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(,-b arg,false,)" "$(cat $STDOUTF)"
+
+    assertCommandSuccess main g --backend-command blah
+    assertEquals "run_env_as_groot(blah,,false,)" "$(cat $STDOUTF)"
+    assertCommandSuccess main groot --backend-command blah
+    assertEquals "run_env_as_groot(blah,,false,)" "$(cat $STDOUTF)"
+
     assertCommandSuccess main groot command
-    assertEquals "run_env_as_groot(,false,command)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(,,false,command)" "$(cat $STDOUTF)"
     assertCommandSuccess main groot -- command
-    assertEquals "run_env_as_groot(,false,command)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_groot(,,false,command)" "$(cat $STDOUTF)"
 
     is_env_installed(){
         return 1
@@ -201,13 +223,19 @@ function test_run_env_as_groot(){
 
 function test_run_env_as_chroot(){
     assertCommandSuccess main r
-    assertEquals "run_env_as_chroot(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_chroot(,,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main r -b "-b arg"
-    assertEquals "run_env_as_chroot(-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_chroot(,-b arg,false,)" "$(cat $STDOUTF)"
+
+    assertCommandSuccess main r --backend-command blah
+    assertEquals "run_env_as_chroot(blah,,false,)" "$(cat $STDOUTF)"
+    assertCommandSuccess main root --backend-command blah
+    assertEquals "run_env_as_chroot(blah,,false,)" "$(cat $STDOUTF)"
+
     assertCommandSuccess main root command
-    assertEquals "run_env_as_chroot(,false,command)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_chroot(,,false,command)" "$(cat $STDOUTF)"
     assertCommandSuccess main root -- command
-    assertEquals "run_env_as_chroot(,false,command)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_chroot(,,false,command)" "$(cat $STDOUTF)"
 
     is_env_installed(){
         return 1
@@ -217,34 +245,39 @@ function test_run_env_as_chroot(){
 
 function test_run_env_as_bwrap_fakeroot(){
     assertCommandSuccess main n -f
-    assertEquals "run_env_as_bwrap_fakeroot(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main ns -f
-    assertEquals "run_env_as_bwrap_fakeroot(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main ns -n -f
-    assertEquals "run_env_as_bwrap_fakeroot(,true,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,true,)" "$(cat $STDOUTF)"
 
     assertCommandSuccess main ns -f -b "-b arg"
-    assertEquals "run_env_as_bwrap_fakeroot(-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main ns -f -b "-b arg" -- command -kv
-    assertEquals "run_env_as_bwrap_fakeroot(-b arg,false,command -kv)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,command -kv)" "$(cat $STDOUTF)"
     assertCommandSuccess main ns -f command --as
-    assertEquals "run_env_as_bwrap_fakeroot(,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
     assertCommandSuccess main ns -f -- command --as
-    assertEquals "run_env_as_bwrap_fakeroot(,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
+
+    assertCommandSuccess main ns -f --backend-command blah
+    assertEquals "run_env_as_bwrap_fakeroot(blah,,false,)" "$(cat $STDOUTF)"
+    assertCommandSuccess main -f --backend-command blah
+    assertEquals "run_env_as_bwrap_fakeroot(blah,,false,)" "$(cat $STDOUTF)"
 
     assertCommandSuccess main -f
-    assertEquals "run_env_as_bwrap_fakeroot(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main -f
-    assertEquals "run_env_as_bwrap_fakeroot(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,)" "$(cat $STDOUTF)"
 
     assertCommandSuccess main -f -b "-b arg"
-    assertEquals "run_env_as_bwrap_fakeroot(-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main -f -b "-b arg" -- command -kv
-    assertEquals "run_env_as_bwrap_fakeroot(-b arg,false,command -kv)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,-b arg,false,command -kv)" "$(cat $STDOUTF)"
     assertCommandSuccess main -f command --as
-    assertEquals "run_env_as_bwrap_fakeroot(,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
     assertCommandSuccess main -f -- command --as
-    assertEquals "run_env_as_bwrap_fakeroot(,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_fakeroot(,,false,command --as)" "$(cat $STDOUTF)"
 
     is_env_installed(){
         return 1
@@ -254,34 +287,39 @@ function test_run_env_as_bwrap_fakeroot(){
 
 function test_run_env_as_bwrap_user(){
     assertCommandSuccess main n
-    assertEquals "run_env_as_bwrap_user(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main ns
-    assertEquals "run_env_as_bwrap_user(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main ns -n
-    assertEquals "run_env_as_bwrap_user(,true,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,true,)" "$(cat $STDOUTF)"
 
     assertCommandSuccess main ns -b "-b arg"
-    assertEquals "run_env_as_bwrap_user(-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,-b arg,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main ns -b "-b arg" -- command -kv
-    assertEquals "run_env_as_bwrap_user(-b arg,false,command -kv)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,-b arg,false,command -kv)" "$(cat $STDOUTF)"
     assertCommandSuccess main ns command --as
-    assertEquals "run_env_as_bwrap_user(,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat $STDOUTF)"
     assertCommandSuccess main ns -- command --as
-    assertEquals "run_env_as_bwrap_user(,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat $STDOUTF)"
+
+    assertCommandSuccess main ns --backend-command blah
+    assertEquals "run_env_as_bwrap_user(blah,,false,)" "$(cat $STDOUTF)"
+    assertCommandSuccess main --backend-command blah
+    assertEquals "run_env_as_bwrap_user(blah,,false,)" "$(cat $STDOUTF)"
 
     assertCommandSuccess main
-    assertEquals "run_env_as_bwrap_user(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main
-    assertEquals "run_env_as_bwrap_user(,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,)" "$(cat $STDOUTF)"
 
     assertCommandSuccess main -b "-b arg"
-    assertEquals "run_env_as_bwrap_user(-b arg,false,)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,-b arg,false,)" "$(cat $STDOUTF)"
     assertCommandSuccess main -b "-b arg" -- command -kv
-    assertEquals "run_env_as_bwrap_user(-b arg,false,command -kv)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,-b arg,false,command -kv)" "$(cat $STDOUTF)"
     assertCommandSuccess main command --as
-    assertEquals "run_env_as_bwrap_user(,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat $STDOUTF)"
     assertCommandSuccess main -- command --as
-    assertEquals "run_env_as_bwrap_user(,false,command --as)" "$(cat $STDOUTF)"
+    assertEquals "run_env_as_bwrap_user(,,false,command --as)" "$(cat $STDOUTF)"
 
     is_env_installed(){
         return 1
diff --git a/tests/unit-tests/test-namespace.sh b/tests/unit-tests/test-namespace.sh
index 03eb1cd..9efbad3 100755
--- a/tests/unit-tests/test-namespace.sh
+++ b/tests/unit-tests/test-namespace.sh
@@ -18,6 +18,9 @@ function init_mocks() {
     function bwrap_cmd(){
         echo "bwrap $@"
     }
+    function mybwrap(){
+        echo "mybwrap $@"
+    }
 }
 
 function setUp(){
@@ -100,22 +103,37 @@ function test_is_user_namespace_enabled_with_userns_clone_file_enabled(){
 }
 
 function test_run_env_as_bwrap_fakeroot() {
-    assertCommandSuccess run_env_as_bwrap_fakeroot "" "false"
+    assertCommandSuccess run_env_as_bwrap_fakeroot "" "" "false"
     assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 /bin/sh --login" "$(cat $STDOUTF)"
 
     _test_copy_common_files
 }
 
+function test_run_env_as_bwrap_fakeroot_with_backend_command() {
+    assertCommandSuccess run_env_as_bwrap_fakeroot "mybwrap" "" "false"
+    assertEquals "mybwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 /bin/sh --login" "$(cat $STDOUTF)"
+
+    _test_copy_common_files
+}
+
 function test_run_env_as_bwrap_user() {
-    assertCommandSuccess run_env_as_bwrap_user "" "false"
+    assertCommandSuccess run_env_as_bwrap_user "" "" "false"
     assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try /bin/sh --login" "$(cat $STDOUTF)"
 
     _test_copy_common_files
     _test_copy_remaining_files
 }
 
+function test_run_env_as_bwrap_user_with_backend_command() {
+    assertCommandSuccess run_env_as_bwrap_user "mybwrap" "" "false"
+    assertEquals "mybwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try /bin/sh --login" "$(cat $STDOUTF)"
+
+    _test_copy_common_files
+    _test_copy_remaining_files
+}
+
 function test_run_env_as_bwrap_fakeroot_no_copy() {
-    assertCommandSuccess run_env_as_bwrap_fakeroot "" "true" ""
+    assertCommandSuccess run_env_as_bwrap_fakeroot "" "" "true" ""
     assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 /bin/sh --login" "$(cat $STDOUTF)"
 
     [[ ! -e ${JUNEST_HOME}/etc/hosts ]]
@@ -141,7 +159,7 @@ function test_run_env_as_bwrap_fakeroot_no_copy() {
 }
 
 function test_run_env_as_bwrap_user_no_copy() {
-    assertCommandSuccess run_env_as_bwrap_user "" "true" ""
+    assertCommandSuccess run_env_as_bwrap_user "" "" "true" ""
     assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try /bin/sh --login" "$(cat $STDOUTF)"
 
     [[ ! -e ${JUNEST_HOME}/etc/hosts ]]
@@ -167,14 +185,14 @@ function test_run_env_as_bwrap_user_no_copy() {
 }
 
 function test_run_env_as_bwrap_fakeroot_with_backend_args() {
-    assertCommandSuccess run_env_as_bwrap_fakeroot "--bind /usr /usr" "false"
+    assertCommandSuccess run_env_as_bwrap_fakeroot "" "--bind /usr /usr" "false"
     assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 --bind /usr /usr /bin/sh --login" "$(cat $STDOUTF)"
 
     _test_copy_common_files
 }
 
 function test_run_env_as_bwrap_user_with_backend_args() {
-    assertCommandSuccess run_env_as_bwrap_user "--bind /usr /usr" "false"
+    assertCommandSuccess run_env_as_bwrap_user "" "--bind /usr /usr" "false"
     assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --bind /usr /usr /bin/sh --login" "$(cat $STDOUTF)"
 
     _test_copy_common_files
@@ -182,14 +200,14 @@ function test_run_env_as_bwrap_user_with_backend_args() {
 }
 
 function test_run_env_as_bwrap_fakeroot_with_command() {
-    assertCommandSuccess run_env_as_bwrap_fakeroot "" "false" "ls -la"
+    assertCommandSuccess run_env_as_bwrap_fakeroot "" "" "false" "ls -la"
     assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 /bin/sh --login -c \"ls -la\"" "$(cat $STDOUTF)"
 
     _test_copy_common_files
 }
 
 function test_run_env_as_bwrap_user_with_command() {
-    assertCommandSuccess run_env_as_bwrap_user "" "false" "ls -la"
+    assertCommandSuccess run_env_as_bwrap_user "" "" "false" "ls -la"
     assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try /bin/sh --login -c \"ls -la\"" "$(cat $STDOUTF)"
 
     _test_copy_common_files
@@ -197,14 +215,14 @@ function test_run_env_as_bwrap_user_with_command() {
 }
 
 function test_run_env_as_bwrap_fakeroot_with_backend_args_and_command() {
-    assertCommandSuccess run_env_as_bwrap_fakeroot "--bind /usr /usr" "false" "ls -la"
+    assertCommandSuccess run_env_as_bwrap_fakeroot "" "--bind /usr /usr" "false" "ls -la"
     assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --uid 0 --bind /usr /usr /bin/sh --login -c \"ls -la\"" "$(cat $STDOUTF)"
 
     _test_copy_common_files
 }
 
 function test_run_env_as_bwrap_user_with_backend_args_and_command() {
-    assertCommandSuccess run_env_as_bwrap_user "--bind /usr /usr" "false" "ls -la"
+    assertCommandSuccess run_env_as_bwrap_user "" "--bind /usr /usr" "false" "ls -la"
     assertEquals "bwrap --bind $JUNEST_HOME / --bind $HOME $HOME --bind /tmp /tmp --proc /proc --dev /dev --unshare-user-try --bind /usr /usr /bin/sh --login -c \"ls -la\"" "$(cat $STDOUTF)"
 
     _test_copy_common_files
@@ -213,13 +231,13 @@ function test_run_env_as_bwrap_user_with_backend_args_and_command() {
 
 function test_run_env_as_bwrap_fakeroot_nested_env(){
     JUNEST_ENV=1
-    assertCommandFailOnStatus 106 run_env_as_bwrap_fakeroot "" "false" ""
+    assertCommandFailOnStatus 106 run_env_as_bwrap_fakeroot "" "" "false" ""
     unset JUNEST_ENV
 }
 
 function test_run_env_as_bwrap_user_nested_env(){
     JUNEST_ENV=1
-    assertCommandFailOnStatus 106 run_env_as_bwrap_user "" "false" ""
+    assertCommandFailOnStatus 106 run_env_as_bwrap_user "" "" "false" ""
     unset JUNEST_ENV
 }
 
diff --git a/tests/unit-tests/test-proot.sh b/tests/unit-tests/test-proot.sh
index 8fa636f..9e152f9 100755
--- a/tests/unit-tests/test-proot.sh
+++ b/tests/unit-tests/test-proot.sh
@@ -51,22 +51,37 @@ function test_run_env_as_proot_user(){
     _run_env_with_qemu() {
         echo $@
     }
-    assertCommandSuccess run_env_as_proot_user "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
+    assertCommandSuccess run_env_as_proot_user "" "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
     assertEquals "-b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
 
     SH=("/usr/bin/echo")
-    assertCommandSuccess run_env_as_proot_user "-k 3.10" "false"
+    assertCommandSuccess run_env_as_proot_user "" "-k 3.10" "false"
     assertEquals "-b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat $STDOUTF)"
 
     _test_copy_common_files
     _test_copy_remaining_files
 }
 
+function test_run_env_as_proot_user_with_backend_command(){
+    _run_env_with_qemu() {
+        echo $@
+    }
+    assertCommandSuccess run_env_as_proot_user "myproot" "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
+    assertEquals "myproot -b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
+
+    SH=("/usr/bin/echo")
+    assertCommandSuccess run_env_as_proot_user "myproot" "-k 3.10" "false"
+    assertEquals "myproot -b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat $STDOUTF)"
+
+    _test_copy_common_files
+    _test_copy_remaining_files
+}
+
 function test_run_env_as_proot_user_no_copy(){
     _run_env_with_qemu() {
         echo $@
     }
-    assertCommandSuccess run_env_as_proot_user "-k 3.10" "true" "/usr/bin/mkdir" "-v" "/newdir2"
+    assertCommandSuccess run_env_as_proot_user "" "-k 3.10" "true" "/usr/bin/mkdir" "-v" "/newdir2"
     assertEquals "-b $HOME -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
 
     [[ ! -e ${JUNEST_HOME}/etc/hosts ]]
@@ -93,7 +108,7 @@ function test_run_env_as_proot_user_no_copy(){
 
 function test_run_env_as_proot_user_nested_env(){
     JUNEST_ENV=1
-    assertCommandFailOnStatus 106 run_env_as_proot_user "" "false"
+    assertCommandFailOnStatus 106 run_env_as_proot_user "" "" "false"
     unset JUNEST_ENV
 }
 
@@ -101,19 +116,33 @@ function test_run_env_as_proot_fakeroot(){
     _run_env_with_qemu() {
         echo $@
     }
-    assertCommandSuccess run_env_as_proot_fakeroot "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
+    assertCommandSuccess run_env_as_proot_fakeroot "" "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
     assertEquals "-0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
 
     SH=("/usr/bin/echo")
-    assertCommandSuccess run_env_as_proot_fakeroot "-k 3.10" "false"
+    assertCommandSuccess run_env_as_proot_fakeroot "" "-k 3.10" "false"
     assertEquals "-0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat $STDOUTF)"
 
     _test_copy_common_files
 }
 
+function test_run_env_as_proot_fakeroot_with_backend_command(){
+    _run_env_with_qemu() {
+        echo $@
+    }
+    assertCommandSuccess run_env_as_proot_fakeroot "myproot" "-k 3.10" "false" "/usr/bin/mkdir" "-v" "/newdir2"
+    assertEquals "myproot -0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
+
+    SH=("/usr/bin/echo")
+    assertCommandSuccess run_env_as_proot_fakeroot "myproot" "-k 3.10" "false"
+    assertEquals "myproot -0 -b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10" "$(cat $STDOUTF)"
+
+    _test_copy_common_files
+}
+
 function test_run_env_as_proot_fakeroot_nested_env(){
     JUNEST_ENV=1
-    assertCommandFailOnStatus 106 run_env_as_proot_fakeroot "" "false" ""
+    assertCommandFailOnStatus 106 run_env_as_proot_fakeroot "" "" "false" ""
     unset JUNEST_ENV
 }
 
@@ -121,7 +150,7 @@ function test_run_env_with_quotes(){
     _run_env_with_qemu() {
         echo $@
     }
-    assertCommandSuccess run_env_as_proot_user "-k 3.10" "false" "bash" "-c" "/usr/bin/mkdir -v /newdir2"
+    assertCommandSuccess run_env_as_proot_user "" "-k 3.10" "false" "bash" "-c" "/usr/bin/mkdir -v /newdir2"
     assertEquals "-b ${HOME} -b /tmp -b /proc -b /sys -b /dev -r ${JUNEST_HOME} -k 3.10 bash -c /usr/bin/mkdir -v /newdir2" "$(cat $STDOUTF)"
 }
 
@@ -131,10 +160,10 @@ function test_run_env_with_proot_args(){
         echo $@
     }
 
-    assertCommandSuccess _run_env_with_proot --help
+    assertCommandSuccess _run_env_with_proot "" "--help"
     assertEquals "--help /bin/sh --login" "$(cat $STDOUTF)"
 
-    assertCommandSuccess _run_env_with_proot --help mycommand
+    assertCommandSuccess _run_env_with_proot "" "--help" mycommand
     assertEquals "--help /bin/sh --login -c mycommand" "$(cat $STDOUTF)"
 
     assertCommandFail _run_env_with_proot
@@ -152,7 +181,7 @@ function test_qemu() {
         echo $@
     }
 
-    RANDOM=100 ARCH=x86_64 assertCommandSuccess _run_env_with_qemu ""
+    RANDOM=100 ARCH=x86_64 assertCommandSuccess _run_env_with_qemu "" ""
     assertEquals "$(echo -e "-s $JUNEST_HOME/bin/qemu-arm-static-x86_64 /tmp/qemu-arm-static-x86_64-100\n-q /tmp/qemu-arm-static-x86_64-100")" "$(cat $STDOUTF)"
 }