diff --git a/__tests__/undock/undock.test.ts b/__tests__/undock/undock.test.ts
new file mode 100644
index 0000000..c8d2e71
--- /dev/null
+++ b/__tests__/undock/undock.test.ts
@@ -0,0 +1,63 @@
+/**
+ * Copyright 2024 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {describe, expect, it, jest, test} from '@jest/globals';
+import * as semver from 'semver';
+
+import {Exec} from '../../src/exec';
+import {Undock} from '../../src/undock/undock';
+
+describe('isAvailable', () => {
+  it('checks undock is available', async () => {
+    const execSpy = jest.spyOn(Exec, 'getExecOutput');
+    const undock = new Undock();
+    await undock.isAvailable();
+    // eslint-disable-next-line jest/no-standalone-expect
+    expect(execSpy).toHaveBeenCalledWith(`undock`, [], {
+      silent: true,
+      ignoreReturnCode: true
+    });
+  });
+});
+
+describe('printVersion', () => {
+  it('prints undock version', async () => {
+    const execSpy = jest.spyOn(Exec, 'exec');
+    const undock = new Undock();
+    await undock.printVersion();
+    expect(execSpy).toHaveBeenCalledWith(`undock`, ['--version'], {
+      failOnStdErr: false
+    });
+  });
+});
+
+describe('version', () => {
+  it('valid', async () => {
+    const undock = new Undock();
+    expect(semver.valid(await undock.version())).not.toBeUndefined();
+  });
+});
+
+describe('versionSatisfies', () => {
+  test.each([
+    ['v0.4.1', '>=0.3.2', true],
+    ['v0.8.0', '>0.6.0', true],
+    ['v0.8.0', '<0.3.0', false]
+  ])('given %p', async (version, range, expected) => {
+    const undock = new Undock();
+    expect(await undock.versionSatisfies(range, version)).toBe(expected);
+  });
+});
diff --git a/dev.Dockerfile b/dev.Dockerfile
index 18d6e66..e551ab5 100644
--- a/dev.Dockerfile
+++ b/dev.Dockerfile
@@ -17,6 +17,7 @@
 ARG NODE_VERSION=20
 ARG DOCKER_VERSION=27.2.1
 ARG BUILDX_VERSION=0.17.1
+ARG UNDOCK_VERSION=0.8.0
 
 FROM node:${NODE_VERSION}-alpine AS base
 RUN apk add --no-cache cpio findutils git
@@ -75,6 +76,7 @@ RUN --mount=type=bind,target=.,rw \
 
 FROM docker:${DOCKER_VERSION} as docker
 FROM docker/buildx-bin:${BUILDX_VERSION} as buildx
+FROM crazymax/undock:${UNDOCK_VERSION} as undock
 
 FROM deps AS test
 RUN --mount=type=bind,target=.,rw \
@@ -83,6 +85,7 @@ RUN --mount=type=bind,target=.,rw \
     --mount=type=bind,from=docker,source=/usr/local/bin/docker,target=/usr/bin/docker \
     --mount=type=bind,from=buildx,source=/buildx,target=/usr/libexec/docker/cli-plugins/docker-buildx \
     --mount=type=bind,from=buildx,source=/buildx,target=/usr/bin/buildx \
+    --mount=type=bind,from=undock,source=/usr/local/bin/undock,target=/usr/bin/undock \
     --mount=type=secret,id=GITHUB_TOKEN \
   GITHUB_TOKEN=$(cat /run/secrets/GITHUB_TOKEN) yarn run test:coverage --coverageDirectory=/tmp/coverage
 
diff --git a/src/toolkit.ts b/src/toolkit.ts
index 2566ea5..4b0edfb 100644
--- a/src/toolkit.ts
+++ b/src/toolkit.ts
@@ -20,6 +20,7 @@ import {Bake as BuildxBake} from './buildx/bake';
 import {Install as BuildxInstall} from './buildx/install';
 import {Builder} from './buildx/builder';
 import {BuildKit} from './buildkit/buildkit';
+import {Undock} from './undock/undock';
 import {GitHub} from './github';
 
 export interface ToolkitOpts {
@@ -38,6 +39,7 @@ export class Toolkit {
   public buildxInstall: BuildxInstall;
   public builder: Builder;
   public buildkit: BuildKit;
+  public undock: Undock;
 
   constructor(opts: ToolkitOpts = {}) {
     this.github = new GitHub({token: opts.githubToken});
@@ -47,5 +49,6 @@ export class Toolkit {
     this.buildxInstall = new BuildxInstall();
     this.builder = new Builder({buildx: this.buildx});
     this.buildkit = new BuildKit({buildx: this.buildx});
+    this.undock = new Undock();
   }
 }
diff --git a/src/undock/undock.ts b/src/undock/undock.ts
new file mode 100644
index 0000000..aac0858
--- /dev/null
+++ b/src/undock/undock.ts
@@ -0,0 +1,97 @@
+/**
+ * Copyright 2024 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import os from 'os';
+import path from 'path';
+import * as core from '@actions/core';
+import * as semver from 'semver';
+
+import {Exec} from '../exec';
+
+export interface UndockOpts {
+  binPath?: string;
+}
+
+export class Undock {
+  private readonly binPath: string;
+  private _version: string;
+  private _versionOnce: boolean;
+
+  constructor(opts?: UndockOpts) {
+    this.binPath = opts?.binPath || 'undock';
+    this._version = '';
+    this._versionOnce = false;
+  }
+
+  static get cacheDir(): string {
+    return process.env.UNDOCK_CACHE_DIR || path.join(os.homedir(), '.local', 'share', 'undock', 'cache');
+  }
+
+  public async isAvailable(): Promise<boolean> {
+    const ok: boolean = await Exec.getExecOutput(this.binPath, [], {
+      ignoreReturnCode: true,
+      silent: true
+    })
+      .then(res => {
+        if (res.stderr.length > 0 && res.exitCode != 0) {
+          core.debug(`Undock.isAvailable cmd err: ${res.stderr.trim()}`);
+          return false;
+        }
+        return res.exitCode == 0;
+      })
+      .catch(error => {
+        core.debug(`Undock.isAvailable error: ${error}`);
+        return false;
+      });
+
+    core.debug(`Undock.isAvailable: ${ok}`);
+    return ok;
+  }
+
+  public async version(): Promise<string> {
+    if (this._versionOnce) {
+      return this._version;
+    }
+    this._versionOnce = true;
+    this._version = await Exec.getExecOutput(this.binPath, ['--version'], {
+      ignoreReturnCode: true,
+      silent: true
+    }).then(res => {
+      if (res.stderr.length > 0 && res.exitCode != 0) {
+        throw new Error(res.stderr.trim());
+      }
+      return res.stdout.trim();
+    });
+    return this._version;
+  }
+
+  public async printVersion() {
+    await Exec.exec(this.binPath, ['--version'], {
+      failOnStdErr: false
+    });
+  }
+
+  public async versionSatisfies(range: string, version?: string): Promise<boolean> {
+    const ver = version ?? (await this.version());
+    if (!ver) {
+      core.debug(`Undock.versionSatisfies false: undefined version`);
+      return false;
+    }
+    const res = semver.satisfies(ver, range) || /^[0-9a-f]{7}$/.exec(ver) !== null;
+    core.debug(`Undock.versionSatisfies ${ver} statisfies ${range}: ${res}`);
+    return res;
+  }
+}