diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e3660730..0041304e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -54,15 +54,8 @@ jobs:
       - name: Run fast tests
         run: go test -v -race ./internal/...
 
-      - name: Set up Lima
-        uses: lima-vm/lima-actions/setup@03b96d61959e83b2c737e44162c3088e81de0886 # v1.0.1
-        id: lima-actions-setup
-
-      - name: Cache ~/.cache/lima
-        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
-        with:
-          path: ~/.cache/lima
-          key: lima-${{ steps.lima-actions-setup.outputs.version }}
+      - name: Install podman
+        run: sudo apt-get update -qq && sudo apt-get install -y podman
 
       - name: Run e2e tests
-        run: go test -v ./e2e/...
+        run: go test -v -timeout 5m ./e2e/...
diff --git a/e2e/limavm/debian.go b/e2e/limavm/debian.go
deleted file mode 100644
index 6a865c31..00000000
--- a/e2e/limavm/debian.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package limavm
-
-type Debian struct {
-	VM
-}
-
-func NewDebian() (Debian, error) {
-	vm, err := newVM("debian")
-	if err != nil {
-		return Debian{}, err
-	}
-	return Debian{VM: vm}, nil
-}
diff --git a/e2e/limavm/docker.go b/e2e/limavm/docker.go
deleted file mode 100644
index 3817ee30..00000000
--- a/e2e/limavm/docker.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package limavm
-
-import (
-	"github.com/arm/remoteproc-runtime/e2e/limavm/scripts"
-)
-
-type Docker struct {
-	VM
-}
-
-func NewDocker() (Docker, error) {
-	vm, err := newVM("docker")
-	if err != nil {
-		return Docker{}, err
-	}
-	return Docker{VM: vm}, nil
-}
-
-func (vm Docker) BuildImage(buildContext string, imageName string) error {
-	return scripts.BuildImage(vm.name, "docker", buildContext, imageName)
-}
diff --git a/e2e/limavm/limavm.go b/e2e/limavm/limavm.go
deleted file mode 100644
index 87ee6352..00000000
--- a/e2e/limavm/limavm.go
+++ /dev/null
@@ -1,149 +0,0 @@
-package limavm
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/arm/remoteproc-runtime/e2e/limavm/scripts"
-)
-
-type VM struct {
-	name string
-}
-
-var BinBuildEnv = map[string]string{
-	"GOOS": "linux",
-}
-
-func newVM(template string) (VM, error) {
-	vmName, err := scripts.PrepareLimaVM(template)
-	return VM{name: vmName}, err
-}
-
-func (vm VM) InstallBin(binToInstall string) (InstalledBin, error) {
-	installPath, err := scripts.InstallBin(vm.name, binToInstall)
-	if err != nil {
-		return InstalledBin{}, err
-	}
-	return InstalledBin{vm: vm, pathToBin: installPath}, nil
-}
-
-func (vm VM) Cleanup() {
-	_ = scripts.TeardownLimaVM(vm.name)
-}
-
-func (vm VM) Copy(sourcePathInHost string, destPathInVM string) (string, error) {
-	if err := os.CopyFS(destPathInVM, os.DirFS(sourcePathInHost)); err != nil {
-		return "", fmt.Errorf("failed to copy files to temporary location: %w: %s", err, destPathInVM)
-	}
-
-	limaCopyCommand := exec.Command("limactl", "copy", "--recursive", destPathInVM, vm.name+":"+filepath.Dir(destPathInVM)+"/")
-	copyOutput, err := limaCopyCommand.CombinedOutput()
-	if err != nil {
-		return "", fmt.Errorf("failed to copy files to VM: %w: %s", err, copyOutput)
-	}
-
-	err = os.RemoveAll(destPathInVM)
-	if err != nil {
-		return "", fmt.Errorf("failed to remove temporary copied files: %w: %s", err, destPathInVM)
-	}
-	return destPathInVM, nil
-}
-
-func (vm VM) RemoveFile(pathInVM string) error {
-	_, stderr, err := vm.RunCommand("rm", "-rf", pathInVM)
-	if err != nil {
-		return fmt.Errorf("failed to remove file %s: %w: %s", pathInVM, err, stderr)
-	}
-	return nil
-}
-
-func (vm VM) cmd(name string, args ...string) *exec.Cmd {
-	allArgs := append([]string{"shell", vm.name, name}, args...)
-	return exec.Command("limactl", allArgs...)
-}
-
-func (vm VM) RunCommand(name string, args ...string) (stdout, stderr string, err error) {
-	cmd := vm.cmd(name, args...)
-
-	var stdoutBuf, stderrBuf bytes.Buffer
-	cmd.Stdout = &stdoutBuf
-	cmd.Stderr = &stderrBuf
-
-	err = cmd.Run()
-	stdout = stdoutBuf.String()
-	stderr = stderrBuf.String()
-
-	if err != nil {
-		return stdout, stderr, fmt.Errorf("cmd failed: %w\nstdout:\n%s\nstderr:\n%s", err, stdout, stderr)
-	}
-	return stdout, stderr, nil
-}
-
-func (vm VM) ReadFileAsString(path string) (string, error) {
-	stdout, stderr, err := vm.RunCommand("cat", path)
-	if err != nil {
-		return "", fmt.Errorf("failed to read file %s: %w\nstderr:\n%s", path, err, stderr)
-	}
-	return stdout, nil
-}
-
-func (vm VM) ReadDir(path string) ([]string, error) {
-	stdout, stderr, err := vm.RunCommand("ls", "-1", path)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read directory %s: %w\nstderr:\n%s", path, err, stderr)
-	}
-	entries := []string{}
-	for _, line := range strings.Split(stdout, "\n") {
-		line = strings.TrimSpace(line)
-		if line != "" {
-			entries = append(entries, line)
-		}
-	}
-	return entries, nil
-}
-
-type Runnable interface {
-	Run(args ...string) (stdout, stderr string, err error)
-}
-
-type InstalledBin struct {
-	vm        VM
-	pathToBin string
-}
-
-func (b InstalledBin) Run(args ...string) (stdout, stderr string, err error) {
-	return b.vm.RunCommand(b.pathToBin, args...)
-}
-
-func (b InstalledBin) Command(args ...string) *exec.Cmd {
-	return b.vm.cmd(b.pathToBin, args...)
-}
-
-func (b InstalledBin) Path() string {
-	return b.pathToBin
-}
-
-type Sudo struct {
-	vm        VM
-	pathToBin string
-}
-
-func NewSudo(b InstalledBin) Sudo {
-	return Sudo(b)
-}
-
-func (r Sudo) Run(args ...string) (stdout, stderr string, err error) {
-	return r.vm.RunCommand("sudo", append([]string{r.pathToBin}, args...)...)
-}
-
-func Require(t *testing.T) {
-	if _, err := exec.LookPath("limactl"); err != nil {
-		t.Skip("limactl not found. Install limavm: https://lima-vm.io/")
-	}
-}
diff --git a/e2e/limavm/podman.go b/e2e/limavm/podman.go
deleted file mode 100644
index 65e55641..00000000
--- a/e2e/limavm/podman.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package limavm
-
-import (
-	"github.com/arm/remoteproc-runtime/e2e/limavm/scripts"
-)
-
-type Podman struct {
-	VM
-}
-
-func NewPodman() (Podman, error) {
-	vm, err := newVM("podman")
-	if err != nil {
-		return Podman{}, err
-	}
-	return Podman{VM: vm}, nil
-}
-
-func (vm Podman) BuildImage(buildContext string, imageName string) error {
-	return scripts.BuildImage(vm.name, "podman", buildContext, imageName)
-}
diff --git a/e2e/limavm/scripts/build-image.sh b/e2e/limavm/scripts/build-image.sh
deleted file mode 100755
index ea9f4cd6..00000000
--- a/e2e/limavm/scripts/build-image.sh
+++ /dev/null
@@ -1,76 +0,0 @@
-#!/bin/bash
-
-set -e
-
-VM_NAME=""
-TEMPLATE=""
-BUILD_CONTEXT=""
-IMAGE_NAME=""
-
-usage() {
-    echo "Usage: $0 <vm-name> <template> <build-context> <image-name>" >&2
-    echo "  vm-name:          Name of the Lima VM" >&2
-    echo "  template:         Lima template used (docker or podman)" >&2
-    echo "  build-context:    Build context directory for image build" >&2
-    echo "  image-name:       Name for the built image" >&2
-    exit 1
-}
-
-build_image() {
-    echo "Building image..." >&2
-    local tmp_context="/tmp/docker-build-$$"
-
-    echo "Copying build context to VM..." >&2
-    if ! limactl shell "$VM_NAME" mkdir -p "$tmp_context"; then
-        echo "Error: Failed to create temp directory in VM" >&2
-        exit 1
-    fi
-
-    if ! limactl copy -r "$BUILD_CONTEXT/." "$VM_NAME:$tmp_context/"; then
-        echo "Error: Failed to copy build context" >&2
-        exit 1
-    fi
-
-    case "$TEMPLATE" in
-        docker)
-            echo "Building Docker image..." >&2
-            if ! limactl shell "$VM_NAME" docker build -t "$IMAGE_NAME" "$tmp_context" >&2; then
-                echo "Error: Failed to build Docker image" >&2
-                exit 1
-            fi
-            ;;
-        podman)
-            echo "Building Podman image..." >&2
-            if ! limactl shell "$VM_NAME" podman build -t "$IMAGE_NAME" "$tmp_context" >&2; then
-                echo "Error: Failed to build Podman image" >&2
-                exit 1
-            fi
-            ;;
-        *)
-            echo "Error: Unsupported template '$TEMPLATE'. Only 'docker' and 'podman' are supported." >&2
-            exit 1
-            ;;
-    esac
-}
-
-main() {
-    if [ $# -ne 4 ]; then
-        usage
-    fi
-
-    VM_NAME="$1"
-    TEMPLATE="$2"
-    BUILD_CONTEXT="$3"
-    IMAGE_NAME="$4"
-
-    if [ ! -d "$BUILD_CONTEXT" ]; then
-        echo "Error: Build context directory not found: $BUILD_CONTEXT" >&2
-        exit 1
-    fi
-
-    build_image
-
-    echo "Image built successfully" >&2
-}
-
-main "$@"
diff --git a/e2e/limavm/scripts/install-bin.sh b/e2e/limavm/scripts/install-bin.sh
deleted file mode 100755
index d39468d3..00000000
--- a/e2e/limavm/scripts/install-bin.sh
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/bin/bash
-
-set -e
-
-VM_NAME=""
-BINARY_TO_INSTALL=""
-
-usage() {
-    echo "Usage: $0 <vm-name> <binary-to-install>" >&2
-    echo "  vm-name:            Name of the Lima VM" >&2
-    echo "  binary-to-install:  Path to binary to install in /usr/local/bin" >&2
-    exit 1
-}
-
-install_binary() {
-    local source_path="$1"
-    local binary_name="$2"
-    local dest_path="/usr/local/bin/$binary_name"
-
-    echo "Installing $binary_name..." >&2
-
-    if ! limactl copy "$source_path" "$VM_NAME:/tmp/$binary_name"; then
-        echo "Error: Failed to copy $binary_name" >&2
-        exit 1
-    fi
-
-    if ! limactl shell "$VM_NAME" sudo mv "/tmp/$binary_name" "$dest_path"; then
-        echo "Error: Failed to install $binary_name" >&2
-        exit 1
-    fi
-
-    if ! limactl shell "$VM_NAME" sudo chmod +x "$dest_path"; then
-        echo "Error: Failed to make $binary_name executable" >&2
-        exit 1
-    fi
-
-    echo "$dest_path"
-}
-
-main() {
-    if [ $# -ne 2 ]; then
-        usage
-    fi
-
-    VM_NAME="$1"
-    BINARY_TO_INSTALL="$2"
-
-    if [ ! -f "$BINARY_TO_INSTALL" ]; then
-      echo "Error: Binary not found: $BINARY_TO_INSTALL" >&2
-      exit 1
-    fi
-
-    binary_name=$(basename "$BINARY_TO_INSTALL")
-    installed_path=$(install_binary "$BINARY_TO_INSTALL" "$binary_name")
-
-    echo "Binary installed successfully" >&2
-    echo "$installed_path"
-}
-
-main "$@"
diff --git a/e2e/limavm/scripts/prepare-lima-vm.sh b/e2e/limavm/scripts/prepare-lima-vm.sh
deleted file mode 100755
index 82774498..00000000
--- a/e2e/limavm/scripts/prepare-lima-vm.sh
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/bin/bash
-
-set -e
-
-VM_NAME=""
-
-TEMPLATE=""
-MOUNT_DIR=""
-
-usage() {
-    echo "Usage: $0 <template>" >&2
-    echo "  template:         Lima template to use (docker or podman)" >&2
-    exit 1
-}
-
-cleanup_on_failure() {
-    echo "Cleaning up after failure..." >&2
-    limactl stop "$VM_NAME" 2>/dev/null || true
-    limactl delete "$VM_NAME" 2>/dev/null || true
-}
-
-create_vm() {
-    echo "Creating Lima VM..." >&2
-    if ! limactl create --tty=false --name "$VM_NAME" "template://$TEMPLATE"; then
-        echo "Error: Failed to create VM" >&2
-        exit 1
-    fi
-}
-
-start_vm() {
-    echo "Starting Lima VM..." >&2
-    if ! limactl start "$VM_NAME"; then
-        echo "Error: Failed to start VM" >&2
-        cleanup_on_failure
-        exit 1
-    fi
-}
-
-main() {
-    if [ $# -ne 1 ]; then
-        usage
-    fi
-
-    TEMPLATE="$1"
-
-    VM_NAME="remoteproc-test-vm-$(date +%s)"
-    echo "Creating VM: $VM_NAME" >&2
-
-    create_vm
-    start_vm
-
-    echo "VM created and started successfully" >&2
-
-    echo "$VM_NAME"
-}
-
-main "$@"
diff --git a/e2e/limavm/scripts/scripts.go b/e2e/limavm/scripts/scripts.go
deleted file mode 100644
index 073cb6bf..00000000
--- a/e2e/limavm/scripts/scripts.go
+++ /dev/null
@@ -1,79 +0,0 @@
-package scripts
-
-import (
-	"fmt"
-	"os/exec"
-	"path/filepath"
-	"strings"
-
-	"github.com/arm/remoteproc-runtime/e2e/repo"
-	"github.com/arm/remoteproc-runtime/e2e/runner"
-)
-
-var (
-	scriptsDir           = filepath.Join(repo.MustFindRootDir(), "e2e", "limavm", "scripts")
-	prepareLimaVMScript  = filepath.Join(scriptsDir, "prepare-lima-vm.sh")
-	installBinScript     = filepath.Join(scriptsDir, "install-bin.sh")
-	buildImageScript     = filepath.Join(scriptsDir, "build-image.sh")
-	teardownLimaVMScript = filepath.Join(scriptsDir, "teardown-lima-vm.sh")
-)
-
-func PrepareLimaVM(template string) (string, error) {
-	prepareCmd := exec.Command(prepareLimaVMScript, template)
-	prepareStreamer := runner.NewStreamingCmd(prepareCmd).WithPrefix("prepare-vm")
-
-	if err := prepareStreamer.Start(); err != nil {
-		return "", fmt.Errorf("failed to start prepare-lima script: %w", err)
-	}
-
-	if err := prepareStreamer.Wait(); err != nil {
-		return "", fmt.Errorf("failed to prepare VM: %w", err)
-	}
-
-	vmName := strings.TrimSpace(prepareStreamer.Output())
-	if vmName == "" {
-		return "", fmt.Errorf("prepare script did not return VM name")
-	}
-
-	return vmName, nil
-}
-
-func InstallBin(vmName string, binToInstall string) (string, error) {
-	installCmd := exec.Command(installBinScript, vmName, binToInstall)
-	installStreamer := runner.NewStreamingCmd(installCmd).WithPrefix("install-bin")
-
-	if err := installStreamer.Start(); err != nil {
-		return "", fmt.Errorf("failed to start install-bin script: %w", err)
-	}
-
-	if err := installStreamer.Wait(); err != nil {
-		return "", fmt.Errorf("failed to install binary: %w", err)
-	}
-
-	installedBinLocation := strings.TrimSpace(installStreamer.Output())
-	if installedBinLocation == "" {
-		return "", fmt.Errorf("install script did not return installed binary location")
-	}
-
-	return installedBinLocation, nil
-}
-
-func TeardownLimaVM(vmName string) error {
-	cmd := exec.Command(teardownLimaVMScript, vmName)
-	return cmd.Run()
-}
-
-func BuildImage(vmName string, template string, buildContext string, imageName string) error {
-	buildCmd := exec.Command(buildImageScript, vmName, template, buildContext, imageName)
-	buildStreamer := runner.NewStreamingCmd(buildCmd).WithPrefix("build-image")
-
-	if err := buildStreamer.Start(); err != nil {
-		return fmt.Errorf("failed to start build-image script: %w", err)
-	}
-
-	if err := buildStreamer.Wait(); err != nil {
-		return fmt.Errorf("failed to build image: %w", err)
-	}
-
-	return nil
-}
diff --git a/e2e/limavm/scripts/teardown-lima-vm.sh b/e2e/limavm/scripts/teardown-lima-vm.sh
deleted file mode 100755
index 79774494..00000000
--- a/e2e/limavm/scripts/teardown-lima-vm.sh
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/bin/bash
-
-set -e
-
-VM_NAME=""
-
-usage() {
-    echo "Usage: $0 <vm-name>" >&2
-    echo "  vm-name: Name of the Lima VM to teardown" >&2
-    exit 1
-}
-
-check_vm_exists() {
-    if ! limactl list -q | grep -q "^$VM_NAME$"; then
-        echo "Warning: VM '$VM_NAME' not found" >&2
-        return 1
-    fi
-    return 0
-}
-
-stop_vm() {
-    echo "Stopping VM..." >&2
-    if ! limactl stop "$VM_NAME"; then
-        echo "Warning: Failed to stop VM '$VM_NAME' (may already be stopped)" >&2
-    fi
-}
-
-delete_vm() {
-    echo "Deleting VM..." >&2
-    if ! limactl delete "$VM_NAME"; then
-        echo "Error: Failed to delete VM '$VM_NAME'" >&2
-        exit 1
-    fi
-}
-
-main() {
-    if [ $# -ne 1 ]; then
-        usage
-    fi
-
-    VM_NAME="$1"
-
-    echo "Tearing down VM: $VM_NAME" >&2
-
-    if ! check_vm_exists; then
-        exit 0
-    fi
-
-    stop_vm
-    delete_vm
-
-    echo "VM '$VM_NAME' successfully removed" >&2
-}
-
-main "$@"
diff --git a/e2e/remoteproc/assert.go b/e2e/remoteproc/assert.go
index fea56e2e..b5665412 100644
--- a/e2e/remoteproc/assert.go
+++ b/e2e/remoteproc/assert.go
@@ -5,33 +5,33 @@ import (
 	"testing"
 	"time"
 
-	"github.com/arm/remoteproc-runtime/e2e/limavm"
+	"github.com/arm/remoteproc-runtime/e2e/testenv"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func AssertState(t testing.TB, vm limavm.VM, deviceDir, wantState string) {
+func AssertState(t testing.TB, env testenv.Env, deviceDir, wantState string) {
 	t.Helper()
 	const waitFor = 500 * time.Millisecond
 	const tickEvery = 100 * time.Millisecond
 	stateFilePath := filepath.Join(deviceDir, "state")
 	assert.EventuallyWithT(t, func(c *assert.CollectT) {
-		assertFileContent(c, vm, stateFilePath, wantState)
+		assertFileContent(c, env, stateFilePath, wantState)
 	}, waitFor, tickEvery)
 }
 
-func RequireState(t testing.TB, vm limavm.VM, deviceDir, wantState string) {
+func RequireState(t testing.TB, env testenv.Env, deviceDir, wantState string) {
 	t.Helper()
 	const waitFor = 500 * time.Millisecond
 	const tickEvery = 100 * time.Millisecond
 	stateFilePath := filepath.Join(deviceDir, "state")
 	require.EventuallyWithT(t, func(c *assert.CollectT) {
-		assertFileContent(c, vm, stateFilePath, wantState)
+		assertFileContent(c, env, stateFilePath, wantState)
 	}, waitFor, tickEvery)
 }
 
-func assertFileContent(t assert.TestingT, vm limavm.VM, path, wantContent string) {
-	gotContent, err := vm.ReadFileAsString(path)
+func assertFileContent(t assert.TestingT, env testenv.Env, path, wantContent string) {
+	gotContent, err := env.ReadFile(path)
 	if assert.NoError(t, err) {
 		assert.Equal(t, wantContent, gotContent)
 	}
diff --git a/e2e/remoteproc/simulator.go b/e2e/remoteproc/simulator.go
index ef4f2f33..de14e107 100644
--- a/e2e/remoteproc/simulator.go
+++ b/e2e/remoteproc/simulator.go
@@ -15,23 +15,23 @@ import (
 	"sync"
 	"time"
 
-	"github.com/arm/remoteproc-runtime/e2e/limavm"
 	"github.com/arm/remoteproc-runtime/e2e/repo"
 	"github.com/arm/remoteproc-runtime/e2e/runner"
+	"github.com/arm/remoteproc-runtime/e2e/testenv"
 )
 
 type Simulator struct {
-	vm      limavm.VM
-	bin     limavm.InstalledBin
+	env     testenv.Env
+	bin     testenv.InstalledBin
 	cmd     *runner.StreamingCmd
 	name    string
 	index   uint
 	rootDir string
 }
 
-func NewSimulator(bin limavm.InstalledBin, vm limavm.VM, rootDir string) *Simulator {
+func NewSimulator(bin testenv.InstalledBin, env testenv.Env, rootDir string) *Simulator {
 	return &Simulator{
-		vm:      vm,
+		env:     env,
 		bin:     bin,
 		rootDir: rootDir,
 		index:   0,
@@ -109,7 +109,7 @@ func (r *Simulator) waitForBoot(waitingTime time.Duration, outputBuf *io.PipeRea
 
 func (r *Simulator) Stop() error {
 	var killErr error
-	_, stderr, err := r.vm.RunCommand("pkill", "-f", "remoteproc-simulator")
+	_, stderr, err := r.env.RunCommand("pkill", "-f", "remoteproc-simulator")
 	if err != nil {
 		killErr = fmt.Errorf("pkill failed: %w: stderr: %s", err, stderr)
 	}
diff --git a/e2e/runtime_test.go b/e2e/runtime_test.go
index 77c56abb..60632ab1 100644
--- a/e2e/runtime_test.go
+++ b/e2e/runtime_test.go
@@ -9,37 +9,33 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/arm/remoteproc-runtime/e2e/limavm"
 	"github.com/arm/remoteproc-runtime/e2e/remoteproc"
 	"github.com/arm/remoteproc-runtime/e2e/repo"
+	"github.com/arm/remoteproc-runtime/e2e/testenv"
 	"github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestRuntime(t *testing.T) {
-	limavm.Require(t)
+	rootpathPrefix := filepath.Join("/tmp", "fake-root")
 
-	rootpathPrefixInVM := filepath.Join("/tmp", "fake-root")
+	env := testenv.New(t)
 
-	runtimeBin, err := repo.BuildRuntimeBin(t.TempDir(), rootpathPrefixInVM, limavm.BinBuildEnv)
+	runtimeBin, err := repo.BuildRuntimeBin(t.TempDir(), rootpathPrefix, testenv.BuildEnv())
 	require.NoError(t, err)
 
-	vm, err := limavm.NewDebian()
-	require.NoError(t, err)
-	defer vm.Cleanup()
-
-	installedRuntime, err := vm.InstallBin(runtimeBin)
+	installedRuntime, err := env.InstallBin(runtimeBin)
 	require.NoError(t, err)
 
 	simulatorBin, err := remoteproc.DownloadSimulator(context.Background())
 	require.NoError(t, err)
-	installedSimulator, err := vm.InstallBin(simulatorBin)
+	installedSimulator, err := env.InstallBin(simulatorBin)
 	require.NoError(t, err)
 
 	t.Run("basic container lifecycle", func(t *testing.T) {
 		remoteprocName := "yolo-device"
-		sim := remoteproc.NewSimulator(installedSimulator, vm.VM, rootpathPrefixInVM).WithName(remoteprocName)
+		sim := remoteproc.NewSimulator(installedSimulator, env, rootpathPrefix).WithName(remoteprocName)
 		if err := sim.Start(); err != nil {
 			t.Fatalf("failed to run simulator: %s", err)
 		}
@@ -47,26 +43,26 @@ func TestRuntime(t *testing.T) {
 
 		uniqueID := testID(t)
 		containerName := uniqueID
-		bundlePathInVM, err := generateBundleInVM(t, vm, remoteprocName)
+		bundlePath, err := generateBundle(t, env, remoteprocName)
 		require.NoError(t, err)
 
 		_, stderr, err := installedRuntime.Run(
 			"create",
-			"--bundle", bundlePathInVM,
+			"--bundle", bundlePath,
 			containerName)
 		require.NoError(t, err, "stderr: %s", stderr)
 		assertContainerStatus(t, installedRuntime, containerName, specs.StateCreated)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "offline")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "offline")
 
 		_, stderr, err = installedRuntime.Run("start", containerName)
 		require.NoError(t, err, "stderr: %s", stderr)
 		assertContainerStatus(t, installedRuntime, containerName, specs.StateRunning)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "running")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "running")
 
 		_, stderr, err = installedRuntime.Run("kill", containerName)
 		require.NoError(t, err, "stderr: %s", stderr)
 		assertContainerStatus(t, installedRuntime, containerName, specs.StateStopped)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "offline")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "offline")
 
 		_, stderr, err = installedRuntime.Run("delete", containerName)
 		require.NoError(t, err, "stderr: %s", stderr)
@@ -74,7 +70,7 @@ func TestRuntime(t *testing.T) {
 
 	t.Run("errors when requested remoteproc name doesn't exist", func(t *testing.T) {
 		processorName := "some-processor"
-		sim := remoteproc.NewSimulator(installedSimulator, vm.VM, rootpathPrefixInVM).WithName(processorName)
+		sim := remoteproc.NewSimulator(installedSimulator, env, rootpathPrefix).WithName(processorName)
 		if err := sim.Start(); err != nil {
 			t.Fatalf("failed to run simulator: %s", err)
 		}
@@ -83,18 +79,18 @@ func TestRuntime(t *testing.T) {
 		uniqueID := testID(t)
 
 		containerName := uniqueID
-		bundlePathInVM, err := generateBundleInVM(t, vm, "other-processor")
+		bundlePath, err := generateBundle(t, env, "other-processor")
 		require.NoError(t, err)
 
 		expectedErrorSubstring := "remote processor other-processor does not exist, available remote processors: "
-		_, stderr, err := installedRuntime.Run("create", "--bundle", bundlePathInVM, containerName)
+		_, stderr, err := installedRuntime.Run("create", "--bundle", bundlePath, containerName)
 		assert.ErrorContains(t, err, expectedErrorSubstring, "error doesn't contain: %s: stderr: %s", expectedErrorSubstring, stderr)
 		assert.ErrorContains(t, err, processorName, "error doesn't contain expected processor name: %s: stderr: %s", processorName, stderr)
 	})
 
 	t.Run("killing process by pid stops the running container", func(t *testing.T) {
 		remoteprocName := "nice-processor"
-		sim := remoteproc.NewSimulator(installedSimulator, vm.VM, rootpathPrefixInVM).WithName(remoteprocName)
+		sim := remoteproc.NewSimulator(installedSimulator, env, rootpathPrefix).WithName(remoteprocName)
 		if err := sim.Start(); err != nil {
 			t.Fatalf("failed to run simulator: %s", err)
 		}
@@ -102,10 +98,10 @@ func TestRuntime(t *testing.T) {
 
 		uniqueID := testID(t)
 		containerName := uniqueID
-		bundlePathInVM, err := generateBundleInVM(t, vm, remoteprocName)
+		bundlePath, err := generateBundle(t, env, remoteprocName)
 		require.NoError(t, err)
 
-		_, stderr, err := installedRuntime.Run("create", "--bundle", bundlePathInVM, containerName)
+		_, stderr, err := installedRuntime.Run("create", "--bundle", bundlePath, containerName)
 		require.NoError(t, err, "stderr: %s", stderr)
 
 		pid, err := getContainerPid(installedRuntime, containerName)
@@ -114,29 +110,29 @@ func TestRuntime(t *testing.T) {
 
 		_, stderr, err = installedRuntime.Run("start", containerName)
 		require.NoError(t, err, "stderr: %s", stderr)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "running")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "running")
 
-		_, stderr, err = vm.RunCommand("kill", "-TERM", fmt.Sprintf("%d", pid))
+		_, stderr, err = env.RunCommand("kill", "-TERM", fmt.Sprintf("%d", pid))
 		require.NoError(t, err, "stderr: %s", stderr)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "offline")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "offline")
 	})
 
 	t.Run("writes pid to file specified by --pid-file", func(t *testing.T) {
 		remoteprocName := "oh-what-a-device"
-		sim := remoteproc.NewSimulator(installedSimulator, vm.VM, rootpathPrefixInVM).WithName(remoteprocName)
+		sim := remoteproc.NewSimulator(installedSimulator, env, rootpathPrefix).WithName(remoteprocName)
 		if err := sim.Start(); err != nil {
 			t.Fatalf("failed to run simulator: %s", err)
 		}
 		defer func() { _ = sim.Stop() }()
 
 		containerName := testID(t)
-		bundlePathInVM, err := generateBundleInVM(t, vm, remoteprocName)
+		bundlePath, err := generateBundle(t, env, remoteprocName)
 		require.NoError(t, err)
-		pidFile := filepath.Join(bundlePathInVM, "container.pid")
+		pidFile := filepath.Join(bundlePath, "container.pid")
 
 		_, stderr, err := installedRuntime.Run(
 			"create",
-			"--bundle", bundlePathInVM,
+			"--bundle", bundlePath,
 			"--pid-file", pidFile,
 			containerName,
 		)
@@ -145,16 +141,16 @@ func TestRuntime(t *testing.T) {
 		pid, err := getContainerPid(installedRuntime, containerName)
 		require.NoError(t, err)
 		require.Greater(t, pid, 0)
-		requireFileExistsInVM(t, vm, pidFile)
-		assertFileContentInVM(t, vm, pidFile, fmt.Sprintf("%d", pid))
+		requireFileExists(t, env, pidFile)
+		assertFileContent(t, env, pidFile, fmt.Sprintf("%d", pid))
 	})
 
 	t.Run("proxy process namespacing", func(t *testing.T) {
-		installedRuntimeSudo := limavm.NewSudo(installedRuntime)
+		installedRuntimeSudo := testenv.NewSudo(installedRuntime)
 
 		t.Run("creates process in requested namespace when root", func(t *testing.T) {
 			remoteprocName := "lovely-blue-device"
-			sim := remoteproc.NewSimulator(installedSimulator, vm.VM, rootpathPrefixInVM).WithName(remoteprocName)
+			sim := remoteproc.NewSimulator(installedSimulator, env, rootpathPrefix).WithName(remoteprocName)
 			if err := sim.Start(); err != nil {
 				t.Fatalf("failed to run simulator: %s", err)
 			}
@@ -162,16 +158,16 @@ func TestRuntime(t *testing.T) {
 
 			uniqueID := testID(t)
 			containerName := uniqueID
-			bundlePathInVM, err := generateBundleInVM(
+			bundlePath, err := generateBundle(
 				t,
-				vm,
+				env,
 				remoteprocName,
 				specs.LinuxNamespace{Type: specs.MountNamespace},
 			)
 			require.NoError(t, err)
 			_, stderr, err := installedRuntimeSudo.Run(
 				"create",
-				"--bundle", bundlePathInVM,
+				"--bundle", bundlePath,
 				containerName)
 			require.NoError(t, err, "stderr: %s", stderr)
 			t.Cleanup(func() {
@@ -181,34 +177,34 @@ func TestRuntime(t *testing.T) {
 			pid, err := getContainerPid(installedRuntimeSudo, containerName)
 			require.NoError(t, err)
 
-			requireDifferentMountNamespace(t, vm, pid)
+			requireDifferentMountNamespace(t, env, pid)
 
-			remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "offline")
+			remoteproc.AssertState(t, env, sim.DeviceDir(), "offline")
 
 			_, stderr, err = installedRuntimeSudo.Run("start", containerName)
 			require.NoError(t, err, "stderr: %s", stderr)
-			remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "running")
+			remoteproc.AssertState(t, env, sim.DeviceDir(), "running")
 		})
 
 		t.Run("creates process in user's namespace when not root", func(t *testing.T) {
 			remoteprocName := "lovely-green-device"
-			sim := remoteproc.NewSimulator(installedSimulator, vm.VM, rootpathPrefixInVM).WithName(remoteprocName)
+			sim := remoteproc.NewSimulator(installedSimulator, env, rootpathPrefix).WithName(remoteprocName)
 			if err := sim.Start(); err != nil {
 				t.Fatalf("failed to run simulator: %s", err)
 			}
 			defer func() { _ = sim.Stop() }()
 
 			containerName := testID(t)
-			bundlePathInVM, err := generateBundleInVM(
+			bundlePath, err := generateBundle(
 				t,
-				vm,
+				env,
 				remoteprocName,
 				specs.LinuxNamespace{Type: specs.MountNamespace},
 			)
 			require.NoError(t, err)
 			_, stderr, err := installedRuntime.Run(
 				"create",
-				"--bundle", bundlePathInVM,
+				"--bundle", bundlePath,
 				containerName)
 			require.NoError(t, err, "stderr: %s", stderr)
 			t.Cleanup(func() {
@@ -218,40 +214,40 @@ func TestRuntime(t *testing.T) {
 			pid, err := getContainerPid(installedRuntime, containerName)
 			require.NoError(t, err)
 
-			requireSameMountNamespace(t, vm, uint(pid))
+			requireSameMountNamespace(t, env, uint(pid))
 
-			remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "offline")
+			remoteproc.AssertState(t, env, sim.DeviceDir(), "offline")
 
 			_, stderr, err = installedRuntime.Run("start", containerName)
 			require.NoError(t, err, "stderr: %s", stderr)
-			remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "running")
+			remoteproc.AssertState(t, env, sim.DeviceDir(), "running")
 		})
 	})
 
 	t.Run("When a custom path is set in /sys/module/firmware_class/parameters/path, the firmware will be stored there", func(t *testing.T) {
 		remoteprocName := "nice-device"
-		sim := remoteproc.NewSimulator(installedSimulator, vm.VM, rootpathPrefixInVM).WithName(remoteprocName)
+		sim := remoteproc.NewSimulator(installedSimulator, env, rootpathPrefix).WithName(remoteprocName)
 		if err := sim.Start(); err != nil {
 			t.Fatalf("failed to run simulator: %s", err)
 		}
 		defer func() { _ = sim.Stop() }()
 
 		containerName := testID(t)
-		bundlePathInVM, err := generateBundleInVM(t, vm, remoteprocName)
+		bundlePath, err := generateBundle(t, env, remoteprocName)
 		require.NoError(t, err)
 
 		_, stderr, err := installedRuntime.Run(
 			"create",
-			"--bundle", bundlePathInVM,
+			"--bundle", bundlePath,
 			containerName)
 		require.NoError(t, err, "stderr: %s", stderr)
 
-		customFirmwareStorageDirectory := filepath.Join(rootpathPrefixInVM, "my", "firmware", "path")
+		customFirmwareStorageDirectory := filepath.Join(rootpathPrefix, "my", "firmware", "path")
 
-		_, _, err = vm.RunCommand("sh", "-c", fmt.Sprintf("echo -n %s > %s",
+		_, _, err = env.RunCommand("sh", "-c", fmt.Sprintf("echo -n %s > %s",
 			customFirmwareStorageDirectory,
 			filepath.Join(
-				rootpathPrefixInVM,
+				rootpathPrefix,
 				"sys",
 				"module",
 				"firmware_class",
@@ -265,54 +261,54 @@ func TestRuntime(t *testing.T) {
 		require.NoError(t, err, "stderr: %s", stderr)
 		assertContainerStatus(t, installedRuntime, containerName, specs.StateRunning)
 
-		assertFirmwareFileExistsInVM(t, vm, customFirmwareStorageDirectory)
+		assertFirmwareFileExists(t, env, customFirmwareStorageDirectory)
 	})
 }
 
-func assertFirmwareFileExistsInVM(t *testing.T, vm limavm.Debian, firmwareStorageDirectory string) {
+func assertFirmwareFileExists(t *testing.T, env testenv.Env, firmwareStorageDirectory string) {
 	t.Helper()
-	entries, err := vm.ReadDir(firmwareStorageDirectory)
+	entries, err := env.ReadDir(firmwareStorageDirectory)
 	require.NoError(t, err)
 
 	require.Greater(t, len(entries), 0, "expected at least one firmware file in %s", firmwareStorageDirectory)
 }
 
-func assertContainerStatus(t testing.TB, runtime limavm.Runnable, containerName string, wantStatus specs.ContainerState) {
+func assertContainerStatus(t testing.TB, runtime testenv.Runnable, containerName string, wantStatus specs.ContainerState) {
 	t.Helper()
 	state, err := getContainerState(runtime, containerName)
 	require.NoError(t, err)
 	assert.Equal(t, wantStatus, state.Status)
 }
 
-func assertFileContentInVM(t *testing.T, vm limavm.Debian, path string, wantContent string) {
+func assertFileContent(t *testing.T, env testenv.Env, path string, wantContent string) {
 	t.Helper()
-	gotContent, err := vm.ReadFileAsString(path)
+	gotContent, err := env.ReadFile(path)
 	if assert.NoError(t, err) {
 		assert.Equal(t, wantContent, gotContent)
 	}
 }
 
-func requireFileExistsInVM(t *testing.T, vm limavm.Debian, path string) {
+func requireFileExists(t *testing.T, env testenv.Env, path string) {
 	t.Helper()
-	_, stderr, err := vm.RunCommand("test", "-e", path)
-	require.NoError(t, err, "failed to check file existence %s in VM: stderr: %s", path, stderr)
+	_, stderr, err := env.RunCommand("test", "-e", path)
+	require.NoError(t, err, "failed to check file existence %s: stderr: %s", path, stderr)
 }
 
-func requireSameMountNamespace(t testing.TB, vm limavm.Debian, pid uint) {
+func requireSameMountNamespace(t testing.TB, env testenv.Env, pid uint) {
 	t.Helper()
-	hostMountNS, stderr, err := vm.RunCommand("readlink", "/proc/self/ns/mnt")
+	hostMountNS, stderr, err := env.RunCommand("readlink", "/proc/self/ns/mnt")
 	require.NoError(t, err, "stderr: %s", stderr)
-	pidMountNS, stderr, err := vm.RunCommand("sudo", "readlink", fmt.Sprintf("/proc/%d/ns/mnt", pid))
+	pidMountNS, stderr, err := env.RunCommand("sudo", "readlink", fmt.Sprintf("/proc/%d/ns/mnt", pid))
 	require.NoError(t, err, "stderr: %s", stderr)
 
 	require.Equal(t, strings.TrimSpace(hostMountNS), strings.TrimSpace(pidMountNS))
 }
 
-func requireDifferentMountNamespace(t testing.TB, vm limavm.Debian, pid int) {
+func requireDifferentMountNamespace(t testing.TB, env testenv.Env, pid int) {
 	t.Helper()
-	hostMountNS, stderr, err := vm.RunCommand("readlink", "/proc/self/ns/mnt")
+	hostMountNS, stderr, err := env.RunCommand("readlink", "/proc/self/ns/mnt")
 	require.NoError(t, err, "stderr: %s", stderr)
-	pidMountNS, stderr, err := vm.RunCommand("sudo", "readlink", fmt.Sprintf("/proc/%d/ns/mnt", pid))
+	pidMountNS, stderr, err := env.RunCommand("sudo", "readlink", fmt.Sprintf("/proc/%d/ns/mnt", pid))
 	require.NoError(t, err, "stderr: %s", stderr)
 
 	require.NotEqual(t, strings.TrimSpace(hostMountNS), strings.TrimSpace(pidMountNS))
@@ -322,10 +318,11 @@ func testID(t testing.TB) string {
 	name := strings.ToLower(t.Name())
 	name = strings.ReplaceAll(name, "/", "-")
 	name = strings.ReplaceAll(name, " ", "-")
+	name = strings.ReplaceAll(name, "'", "")
 	return name
 }
 
-func getContainerPid(runtime limavm.Runnable, containerName string) (int, error) {
+func getContainerPid(runtime testenv.Runnable, containerName string) (int, error) {
 	state, err := getContainerState(runtime, containerName)
 	if err != nil {
 		return 0, err
@@ -333,7 +330,7 @@ func getContainerPid(runtime limavm.Runnable, containerName string) (int, error)
 	return state.Pid, err
 }
 
-func getContainerState(runtime limavm.Runnable, containerName string) (specs.State, error) {
+func getContainerState(runtime testenv.Runnable, containerName string) (specs.State, error) {
 	var state specs.State
 	out, stderr, err := runtime.Run("state", containerName)
 	if err != nil {
@@ -346,7 +343,7 @@ func getContainerState(runtime limavm.Runnable, containerName string) (specs.Sta
 	return state, nil
 }
 
-func generateBundleInVM(t *testing.T, vm limavm.Debian, remoteprocName string, namespaces ...specs.LinuxNamespace) (string, error) {
+func generateBundle(t *testing.T, env testenv.Env, remoteprocName string, namespaces ...specs.LinuxNamespace) (string, error) {
 	bundlePathOnHost := t.TempDir()
 	const bundleRoot = "rootfs"
 	const firmwareName = "hello_world.elf"
@@ -383,11 +380,11 @@ func generateBundleInVM(t *testing.T, vm limavm.Debian, remoteprocName string, n
 		return "", err
 	}
 
-	bundlePathInVM, err := vm.Copy(bundlePathOnHost, filepath.Join("/tmp", testID(t)))
-	if err != nil {
+	bundlePath := filepath.Join("/tmp", testID(t))
+	if err := env.CopyDir(bundlePathOnHost, bundlePath); err != nil {
 		return "", err
 	}
-	t.Cleanup(func() { _ = vm.RemoveFile(bundlePathInVM) })
+	t.Cleanup(func() { _ = env.RemoveAll(bundlePath) })
 
-	return bundlePathInVM, nil
+	return bundlePath, nil
 }
diff --git a/e2e/runtime_via_podman_test.go b/e2e/runtime_via_podman_test.go
index 4aab5db4..c5f2c7ab 100644
--- a/e2e/runtime_via_podman_test.go
+++ b/e2e/runtime_via_podman_test.go
@@ -7,66 +7,62 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/arm/remoteproc-runtime/e2e/limavm"
 	"github.com/arm/remoteproc-runtime/e2e/remoteproc"
 	"github.com/arm/remoteproc-runtime/e2e/repo"
+	"github.com/arm/remoteproc-runtime/e2e/testenv"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestPodman(t *testing.T) {
-	limavm.Require(t)
+	rootpathPrefix := filepath.Join("/tmp", "fake-root")
 
-	rootpathPrefixInVM := filepath.Join("/tmp", "fake-root")
+	env := testenv.New(t)
 
-	runtimeBin, err := repo.BuildRuntimeBin(t.TempDir(), rootpathPrefixInVM, limavm.BinBuildEnv)
+	runtimeBin, err := repo.BuildRuntimeBin(t.TempDir(), rootpathPrefix, testenv.BuildEnv())
 	require.NoError(t, err)
 
-	vm, err := limavm.NewPodman()
-	require.NoError(t, err)
-	defer vm.Cleanup()
-
-	installedRuntimeBin, err := vm.InstallBin(runtimeBin)
+	installedRuntimeBin, err := env.InstallBin(runtimeBin)
 	require.NoError(t, err)
 
 	simulatorBin, err := remoteproc.DownloadSimulator(context.Background())
 	require.NoError(t, err)
-	installedSimulator, err := vm.InstallBin(simulatorBin)
+	installedSimulator, err := env.InstallBin(simulatorBin)
 	require.NoError(t, err)
 
 	imageName := "fancy-image"
-	require.NoError(t, vm.BuildImage("../testdata", imageName))
+	require.NoError(t, env.BuildImage("podman", "../testdata", imageName))
 
 	t.Run("basic container lifecycle", func(t *testing.T) {
 		remoteprocName := "yolo-podman-device"
-		sim := remoteproc.NewSimulator(installedSimulator, vm.VM, rootpathPrefixInVM).WithName(remoteprocName)
+		sim := remoteproc.NewSimulator(installedSimulator, env, rootpathPrefix).WithName(remoteprocName)
 		if err := sim.Start(); err != nil {
 			t.Fatalf("failed to run simulator: %s", err)
 		}
 		defer func() { _ = sim.Stop() }()
 
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "offline")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "offline")
 
-		stdout, stderr, err := vm.RunCommand(
+		stdout, stderr, err := env.RunCommand(
 			"podman",
 			fmt.Sprintf("--runtime=%s", installedRuntimeBin.Path()),
 			"run", "-d",
 			"--annotation", fmt.Sprintf("remoteproc.name=%s", remoteprocName),
 			imageName)
 		require.NoError(t, err, "stderr: %s", stderr)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "running")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "running")
 
 		containerID := strings.TrimSpace(stdout)
-		_, stderr, err = vm.RunCommand("podman", "stop", containerID)
+		_, stderr, err = env.RunCommand("podman", "stop", containerID)
 		assert.NoError(t, err, "stderr: %s", stderr)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "offline")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "offline")
 
-		_, stderr, err = vm.RunCommand("podman", "start", containerID)
+		_, stderr, err = env.RunCommand("podman", "start", containerID)
 		assert.NoError(t, err, "stderr: %s", stderr)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "running")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "running")
 
-		_, stderr, err = vm.RunCommand("podman", "stop", containerID)
+		_, stderr, err = env.RunCommand("podman", "stop", containerID)
 		assert.NoError(t, err, "stderr: %s", stderr)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "offline")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "offline")
 	})
 }
diff --git a/e2e/shim_via_docker_test.go b/e2e/shim_via_docker_test.go
index dc9f2455..95f7deae 100644
--- a/e2e/shim_via_docker_test.go
+++ b/e2e/shim_via_docker_test.go
@@ -9,79 +9,75 @@ import (
 	"testing"
 	"time"
 
-	"github.com/arm/remoteproc-runtime/e2e/limavm"
 	"github.com/arm/remoteproc-runtime/e2e/remoteproc"
 	"github.com/arm/remoteproc-runtime/e2e/repo"
+	"github.com/arm/remoteproc-runtime/e2e/testenv"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestDocker(t *testing.T) {
-	limavm.Require(t)
+	rootpathPrefix := filepath.Join("/tmp", "fake-root")
 
-	rootpathPrefixInVM := filepath.Join("/tmp", "fake-root")
+	env := testenv.New(t)
 
-	bins, err := repo.BuildBothBins(t.TempDir(), rootpathPrefixInVM, limavm.BinBuildEnv)
+	bins, err := repo.BuildBothBins(t.TempDir(), rootpathPrefix, testenv.BuildEnv())
 	require.NoError(t, err)
 
-	vm, err := limavm.NewDocker()
-	require.NoError(t, err)
-	defer vm.Cleanup()
-
 	for _, bin := range bins {
-		_, err := vm.InstallBin(bin)
+		_, err := env.InstallBin(bin)
 		require.NoError(t, err)
 	}
 
 	simulatorBin, err := remoteproc.DownloadSimulator(context.Background())
 	require.NoError(t, err)
-	installedSimulator, err := vm.InstallBin(simulatorBin)
+	installedSimulator, err := env.InstallBin(simulatorBin)
 	require.NoError(t, err)
 
 	imageName := "test-image"
-	require.NoError(t, vm.BuildImage("../testdata", imageName))
+	require.NoError(t, env.BuildImage("docker", "../testdata", imageName))
 
 	t.Run("basic container lifecycle", func(t *testing.T) {
 		remoteprocName := "yolo-docker-device"
-		sim := remoteproc.NewSimulator(installedSimulator, vm.VM, rootpathPrefixInVM).WithName(remoteprocName)
+		sim := remoteproc.NewSimulator(installedSimulator, env, rootpathPrefix).WithName(remoteprocName)
 		if err := sim.Start(); err != nil {
 			t.Fatalf("failed to run simulator: %s", err)
 		}
 		defer func() { _ = sim.Stop() }()
 
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "offline")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "offline")
 
-		containerID, stderr, err := vm.RunCommand(
+		containerID, stderr, err := env.RunCommand(
 			"docker", "run", "-d",
 			"--runtime", "io.containerd.remoteproc.v1",
 			"--annotation", fmt.Sprintf("remoteproc.name=%s", remoteprocName),
 			imageName)
 		require.NoError(t, err, "stderr: %s", stderr)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "running")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "running")
 
-		_, stderr, err = vm.RunCommand("docker", "stop", containerID)
+		_, stderr, err = env.RunCommand("docker", "stop", containerID)
 		assert.NoError(t, err, "stderr: %s", stderr)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "offline")
-		requireRecentFinishOfDockerContainer(t, vm, containerID)
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "offline")
+		requireRecentFinishOfDockerContainer(t, env, containerID)
 
-		_, stderr, err = vm.RunCommand("docker", "start", containerID)
+		_, stderr, err = env.RunCommand("docker", "start", containerID)
 		assert.NoError(t, err, "stderr: %s", stderr)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "running")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "running")
 
-		_, stderr, err = vm.RunCommand("docker", "stop", containerID)
+		_, stderr, err = env.RunCommand("docker", "stop", containerID)
 		assert.NoError(t, err, "stderr: %s", stderr)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "offline")
-		requireRecentFinishOfDockerContainer(t, vm, containerID)
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "offline")
+		requireRecentFinishOfDockerContainer(t, env, containerID)
 	})
 
 	t.Run("errors when requested remoteproc name doesn't exist", func(t *testing.T) {
-		sim := remoteproc.NewSimulator(installedSimulator, vm.VM, rootpathPrefixInVM).WithName("a-processor")
+		sim := remoteproc.NewSimulator(installedSimulator, env, rootpathPrefix).WithName("a-processor")
 		if err := sim.Start(); err != nil {
 			t.Fatalf("failed to run simulator: %s", err)
 		}
 		defer func() { _ = sim.Stop() }()
 
-		_, stderr, err := vm.RunCommand(
+		_, stderr, err := env.RunCommand(
 			"docker", "run", "-d",
 			"--runtime", "io.containerd.remoteproc.v1",
 			"--annotation", fmt.Sprintf("remoteproc.name=%s", "other-processor"),
@@ -92,39 +88,39 @@ func TestDocker(t *testing.T) {
 
 	t.Run("killing process by pid stops the running container", func(t *testing.T) {
 		remoteprocName := "another-yolo-docker-device"
-		sim := remoteproc.NewSimulator(installedSimulator, vm.VM, rootpathPrefixInVM).WithName(remoteprocName)
+		sim := remoteproc.NewSimulator(installedSimulator, env, rootpathPrefix).WithName(remoteprocName)
 		if err := sim.Start(); err != nil {
 			t.Fatalf("failed to run simulator: %s", err)
 		}
 		defer func() { _ = sim.Stop() }()
 
-		containerID, stderr, err := vm.RunCommand(
+		containerID, stderr, err := env.RunCommand(
 			"docker", "run", "-d",
 			"--runtime", "io.containerd.remoteproc.v1",
 			"--annotation", fmt.Sprintf("remoteproc.name=%s", remoteprocName),
 			imageName)
 		require.NoError(t, err, "stderr: %s", stderr)
-		remoteproc.AssertState(t, vm.VM, sim.DeviceDir(), "running")
+		remoteproc.AssertState(t, env, sim.DeviceDir(), "running")
 
-		stdout, stderr, err := vm.RunCommand("docker", "inspect", "--format={{.State.Pid}}", containerID)
+		stdout, stderr, err := env.RunCommand("docker", "inspect", "--format={{.State.Pid}}", containerID)
 		require.NoError(t, err, "stderr: %s", stderr)
 		pid, parseErr := strconv.Atoi(strings.TrimSpace(stdout))
 		require.NoError(t, parseErr)
 
-		_, _, err = vm.RunCommand("kill", "-TERM", fmt.Sprintf("%d", pid))
+		_, _, err = env.RunCommand("sudo", "kill", "-TERM", fmt.Sprintf("%d", pid))
 		require.NoError(t, err)
-		remoteproc.RequireState(t, vm.VM, sim.DeviceDir(), "offline")
-		requireRecentFinishOfDockerContainer(t, vm, containerID)
+		remoteproc.RequireState(t, env, sim.DeviceDir(), "offline")
+		requireRecentFinishOfDockerContainer(t, env, containerID)
 	})
 }
 
-func requireDockerContainerFinished(t *testing.T, vm limavm.Docker, containerID string) {
+func requireDockerContainerFinished(t *testing.T, env testenv.Env, containerID string) {
 	t.Helper()
 
 	const retryWindow = 15 * time.Second
 
 	require.EventuallyWithT(t, func(c *assert.CollectT) {
-		exitCodeStr, stderr, err := vm.RunCommand(
+		exitCodeStr, stderr, err := env.RunCommand(
 			"docker", "inspect", "--format={{.State.ExitCode}}", containerID,
 		)
 		require.NoErrorf(c, err, "docker inspect error:\nstderr:\n%s", stderr)
@@ -137,14 +133,14 @@ func requireDockerContainerFinished(t *testing.T, vm limavm.Docker, containerID
 	}, retryWindow, time.Second)
 }
 
-func requireRecentFinishOfDockerContainer(t *testing.T, vm limavm.Docker, containerID string) {
+func requireRecentFinishOfDockerContainer(t *testing.T, env testenv.Env, containerID string) {
 	t.Helper()
 
-	requireDockerContainerFinished(t, vm, containerID)
+	requireDockerContainerFinished(t, env, containerID)
 
 	const acceptableTimeDelta = 5 * time.Second
 
-	finishedAt, stderr, err := vm.RunCommand(
+	finishedAt, stderr, err := env.RunCommand(
 		"docker", "inspect", "--format={{.State.FinishedAt}}", containerID,
 	)
 	require.NoError(t, err, "docker inspect error:\nstderr:\n%s", stderr)
@@ -154,11 +150,15 @@ func requireRecentFinishOfDockerContainer(t *testing.T, vm limavm.Docker, contai
 	parsed, err := time.Parse(time.RFC3339Nano, raw)
 	require.NoError(t, err, "failed to parse FinishedAt %q", raw)
 
-	now := time.Now().UTC()
+	nowStr, _, err := env.RunCommand("date", "-u", "+%Y-%m-%dT%H:%M:%S.%NZ")
+	require.NoError(t, err, "failed to get current time from env")
+	now, err := time.Parse(time.RFC3339Nano, strings.TrimSpace(nowStr))
+	require.NoError(t, err, "failed to parse env time")
+
 	delta := now.Sub(parsed)
 	if delta < 0 {
 		delta = -delta
 	}
 
-	require.LessOrEqual(t, delta, acceptableTimeDelta, "FinishedAt delta exceeds acceptable range: expected ≤%v, actual %v", acceptableTimeDelta, delta)
+	require.LessOrEqual(t, delta, acceptableTimeDelta, "FinishedAt delta exceeds acceptable range: expected <=%v, actual %v", acceptableTimeDelta, delta)
 }
diff --git a/e2e/testenv/env.go b/e2e/testenv/env.go
new file mode 100644
index 00000000..eb6b2b4a
--- /dev/null
+++ b/e2e/testenv/env.go
@@ -0,0 +1,74 @@
+package testenv
+
+import (
+	"os/exec"
+	"runtime"
+	"testing"
+)
+
+type Env interface {
+	RunCommand(name string, args ...string) (stdout, stderr string, err error)
+	Command(name string, args ...string) *exec.Cmd
+	InstallBin(binPath string) (InstalledBin, error)
+	CopyDir(hostSrc, envDst string) error
+	RemoveAll(path string) error
+	ReadFile(path string) (string, error)
+	ReadDir(path string) ([]string, error)
+	BuildImage(engine, contextDir, imageName string) error
+}
+
+func New(t *testing.T) Env {
+	t.Helper()
+	if runtime.GOOS == "linux" {
+		return &hostEnv{}
+	}
+	if _, err := exec.LookPath("limactl"); err != nil {
+		t.Skip("limactl not found, install Lima: https://lima-vm.io/")
+	}
+	env, err := getOrCreateLimaEnv()
+	if err != nil {
+		t.Fatalf("failed to create lima env: %s", err)
+	}
+	return env
+}
+
+func BuildEnv() map[string]string {
+	if runtime.GOOS == "linux" {
+		return nil
+	}
+	return map[string]string{"GOOS": "linux"}
+}
+
+type Runnable interface {
+	Run(args ...string) (stdout, stderr string, err error)
+}
+
+type InstalledBin struct {
+	env       Env
+	pathToBin string
+}
+
+func (b InstalledBin) Run(args ...string) (stdout, stderr string, err error) {
+	return b.env.RunCommand(b.pathToBin, args...)
+}
+
+func (b InstalledBin) Command(args ...string) *exec.Cmd {
+	return b.env.Command(b.pathToBin, args...)
+}
+
+func (b InstalledBin) Path() string {
+	return b.pathToBin
+}
+
+type Sudo struct {
+	env       Env
+	pathToBin string
+}
+
+func NewSudo(b InstalledBin) Sudo {
+	return Sudo(b)
+}
+
+func (s Sudo) Run(args ...string) (stdout, stderr string, err error) {
+	return s.env.RunCommand("sudo", append([]string{s.pathToBin}, args...)...)
+}
diff --git a/e2e/testenv/hostenv.go b/e2e/testenv/hostenv.go
new file mode 100644
index 00000000..8691d05d
--- /dev/null
+++ b/e2e/testenv/hostenv.go
@@ -0,0 +1,76 @@
+package testenv
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+type hostEnv struct{}
+
+func (e *hostEnv) RunCommand(name string, args ...string) (string, string, error) {
+	cmd := exec.Command(name, args...)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if err != nil {
+		return stdout.String(), stderr.String(), fmt.Errorf("cmd failed: %w\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String())
+	}
+	return stdout.String(), stderr.String(), nil
+}
+
+func (e *hostEnv) Command(name string, args ...string) *exec.Cmd {
+	return exec.Command(name, args...)
+}
+
+func (e *hostEnv) InstallBin(binPath string) (InstalledBin, error) {
+	name := filepath.Base(binPath)
+	dst := filepath.Join("/usr/local/bin", name)
+	tmp := dst + ".tmp"
+	if out, err := exec.Command("sudo", "cp", binPath, tmp).CombinedOutput(); err != nil {
+		return InstalledBin{}, fmt.Errorf("install %s: %w: %s", name, err, out)
+	}
+	if out, err := exec.Command("sudo", "chmod", "+x", tmp).CombinedOutput(); err != nil {
+		return InstalledBin{}, fmt.Errorf("chmod %s: %w: %s", name, err, out)
+	}
+	if out, err := exec.Command("sudo", "mv", tmp, dst).CombinedOutput(); err != nil {
+		return InstalledBin{}, fmt.Errorf("mv %s: %w: %s", name, err, out)
+	}
+	return InstalledBin{env: e, pathToBin: dst}, nil
+}
+
+func (e *hostEnv) CopyDir(src, dst string) error {
+	return os.CopyFS(dst, os.DirFS(src))
+}
+
+func (e *hostEnv) RemoveAll(path string) error {
+	return os.RemoveAll(path)
+}
+
+func (e *hostEnv) ReadFile(path string) (string, error) {
+	data, err := os.ReadFile(path)
+	return string(data), err
+}
+
+func (e *hostEnv) ReadDir(path string) ([]string, error) {
+	entries, err := os.ReadDir(path)
+	if err != nil {
+		return nil, err
+	}
+	names := make([]string, len(entries))
+	for i, entry := range entries {
+		names[i] = entry.Name()
+	}
+	return names, nil
+}
+
+func (e *hostEnv) BuildImage(engine, contextDir, imageName string) error {
+	cmd := exec.Command(engine, "build", "-t", imageName, contextDir)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("build image: %w: %s", err, out)
+	}
+	return nil
+}
diff --git a/e2e/testenv/limaenv.go b/e2e/testenv/limaenv.go
new file mode 100644
index 00000000..8d469189
--- /dev/null
+++ b/e2e/testenv/limaenv.go
@@ -0,0 +1,182 @@
+package testenv
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+const limaVMName = "remoteproc-e2e"
+
+type limaEnv struct {
+	vmName string
+}
+
+var (
+	sharedLimaEnv     *limaEnv
+	sharedLimaEnvOnce sync.Once
+	sharedLimaEnvErr  error
+)
+
+func getOrCreateLimaEnv() (*limaEnv, error) {
+	sharedLimaEnvOnce.Do(func() {
+		sharedLimaEnv, sharedLimaEnvErr = newLimaEnv()
+	})
+	return sharedLimaEnv, sharedLimaEnvErr
+}
+
+func newLimaEnv() (*limaEnv, error) {
+	env := &limaEnv{vmName: limaVMName}
+
+	switch vmStatus(limaVMName) {
+	case "Running":
+		return env, nil
+	case "Stopped":
+		fmt.Printf("Starting existing VM %s...\n", limaVMName)
+		cmd := exec.Command("limactl", "start", limaVMName)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			return nil, fmt.Errorf("start VM: %w", err)
+		}
+		return env, nil
+	default:
+		return env, createVM(env)
+	}
+}
+
+func createVM(env *limaEnv) error {
+	fmt.Printf("Creating VM %s (first run may take a few minutes)...\n", env.vmName)
+
+	create := exec.Command("limactl", "create", "--tty=false", "--name", env.vmName, "template://docker")
+	create.Stdout = os.Stdout
+	create.Stderr = os.Stderr
+	if err := create.Run(); err != nil {
+		return fmt.Errorf("create VM: %w", err)
+	}
+
+	start := exec.Command("limactl", "start", env.vmName)
+	start.Stdout = os.Stdout
+	start.Stderr = os.Stderr
+	if err := start.Run(); err != nil {
+		return fmt.Errorf("start VM: %w", err)
+	}
+
+	fmt.Println("Installing podman in VM...")
+	if _, _, err := env.RunCommand("sudo", "apt-get", "update", "-qq"); err != nil {
+		return fmt.Errorf("apt update: %w", err)
+	}
+	if _, _, err := env.RunCommand("sudo", "apt-get", "install", "-y", "podman"); err != nil {
+		return fmt.Errorf("install podman: %w", err)
+	}
+
+	return nil
+}
+
+func vmStatus(vmName string) string {
+	out, err := exec.Command("limactl", "list", vmName, "--format", "{{.Status}}").Output()
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(out))
+}
+
+func (e *limaEnv) RunCommand(name string, args ...string) (string, string, error) {
+	cmd := e.Command(name, args...)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if err != nil {
+		return stdout.String(), stderr.String(), fmt.Errorf("cmd failed: %w\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String())
+	}
+	return stdout.String(), stderr.String(), nil
+}
+
+func (e *limaEnv) Command(name string, args ...string) *exec.Cmd {
+	allArgs := append([]string{"shell", e.vmName, name}, args...)
+	return exec.Command("limactl", allArgs...)
+}
+
+func (e *limaEnv) InstallBin(binPath string) (InstalledBin, error) {
+	name := filepath.Base(binPath)
+	tmpDst := filepath.Join("/tmp", name)
+
+	cpCmd := exec.Command("limactl", "copy", binPath, e.vmName+":"+tmpDst)
+	if out, err := cpCmd.CombinedOutput(); err != nil {
+		return InstalledBin{}, fmt.Errorf("copy %s to VM: %w: %s", name, err, out)
+	}
+
+	dst := filepath.Join("/usr/local/bin", name)
+	if _, _, err := e.RunCommand("sudo", "mv", tmpDst, dst); err != nil {
+		return InstalledBin{}, fmt.Errorf("install %s: %w", name, err)
+	}
+	if _, _, err := e.RunCommand("sudo", "chmod", "+x", dst); err != nil {
+		return InstalledBin{}, fmt.Errorf("chmod %s: %w", name, err)
+	}
+
+	return InstalledBin{env: e, pathToBin: dst}, nil
+}
+
+func (e *limaEnv) CopyDir(src, dst string) error {
+	if _, _, err := e.RunCommand("mkdir", "-p", dst); err != nil {
+		return err
+	}
+	cpCmd := exec.Command("limactl", "copy", "-r", src+"/.", e.vmName+":"+dst+"/")
+	if out, err := cpCmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("copy dir to VM: %w: %s", err, out)
+	}
+	return nil
+}
+
+func (e *limaEnv) RemoveAll(path string) error {
+	_, _, err := e.RunCommand("rm", "-rf", path)
+	return err
+}
+
+func (e *limaEnv) ReadFile(path string) (string, error) {
+	stdout, stderr, err := e.RunCommand("cat", path)
+	if err != nil {
+		return "", fmt.Errorf("read %s: %w\nstderr:\n%s", path, err, stderr)
+	}
+	return stdout, nil
+}
+
+func (e *limaEnv) ReadDir(path string) ([]string, error) {
+	stdout, _, err := e.RunCommand("ls", "-1", path)
+	if err != nil {
+		return nil, err
+	}
+	var entries []string
+	for _, line := range strings.Split(stdout, "\n") {
+		line = strings.TrimSpace(line)
+		if line != "" {
+			entries = append(entries, line)
+		}
+	}
+	return entries, nil
+}
+
+func (e *limaEnv) BuildImage(engine, contextDir, imageName string) error {
+	tmpCtx := fmt.Sprintf("/tmp/build-ctx-%d", time.Now().UnixNano())
+	if _, _, err := e.RunCommand("mkdir", "-p", tmpCtx); err != nil {
+		return err
+	}
+
+	cpCmd := exec.Command("limactl", "copy", "-r", contextDir+"/.", e.vmName+":"+tmpCtx+"/")
+	if out, err := cpCmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("copy context to VM: %w: %s", err, out)
+	}
+
+	if _, stderr, err := e.RunCommand(engine, "build", "-t", imageName, tmpCtx); err != nil {
+		return fmt.Errorf("build image: %w: %s", err, stderr)
+	}
+
+	_, _, _ = e.RunCommand("rm", "-rf", tmpCtx)
+	return nil
+}