diff --git a/metropolis/node/build/mkimage/BUILD.bazel b/metropolis/node/build/mkimage/BUILD.bazel
index 80c434e..a18bb85 100644
--- a/metropolis/node/build/mkimage/BUILD.bazel
+++ b/metropolis/node/build/mkimage/BUILD.bazel
@@ -5,12 +5,7 @@
     srcs = ["main.go"],
     importpath = "source.monogon.dev/metropolis/node/build/mkimage",
     visibility = ["//visibility:private"],
-    deps = [
-        "@com_github_diskfs_go_diskfs//:go_default_library",
-        "@com_github_diskfs_go_diskfs//disk:go_default_library",
-        "@com_github_diskfs_go_diskfs//filesystem:go_default_library",
-        "@com_github_diskfs_go_diskfs//partition/gpt:go_default_library",
-    ],
+    deps = ["//metropolis/node/build/mkimage/osimage:go_default_library"],
 )
 
 go_binary(
diff --git a/metropolis/node/build/mkimage/main.go b/metropolis/node/build/mkimage/main.go
index f41d643..e5c25df 100644
--- a/metropolis/node/build/mkimage/main.go
+++ b/metropolis/node/build/mkimage/main.go
@@ -14,166 +14,78 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// mkimage is a tool to generate Metropolis node disk images.
+// It can be used both to initialize block devices and to create image
+// files.
+//
+// The tool takes a path to an EFI payload (--efi), and a path to a
+// Metropolis system image (--system) as its only required inputs. In
+// addition, an output path must be supplied (--out).
+// Node parameters file path (--node_parameters) may also be supplied, in
+// which case the file will be copied to the EFI system partition.
+// Partition sizes are fixed and may be overridden by command line flags.
 package main
 
-// mkimage is a tool to generate a Metropolis node disk image containing the
-// given EFI payload, and optionally, a given external initramfs image and
-// node parameters
-
 import (
 	"flag"
-	"fmt"
-	"io"
-	"io/ioutil"
 	"log"
 	"os"
 
-	diskfs "github.com/diskfs/go-diskfs"
-	"github.com/diskfs/go-diskfs/disk"
-	"github.com/diskfs/go-diskfs/filesystem"
-	"github.com/diskfs/go-diskfs/partition/gpt"
+	"source.monogon.dev/metropolis/node/build/mkimage/osimage"
 )
 
-var NodeDataPartition gpt.Type = gpt.Type("9eeec464-6885-414a-b278-4305c51f7966")
-var NodeSystemPartition gpt.Type = gpt.Type("ee96055b-f6d0-4267-8bbb-724b2afea74c")
-
-var (
-	flagEFI                 string
-	flagOut                 string
-	flagSystemPath          string
-	flagNodeParameters      string
-	flagDataPartitionSize   uint64
-	flagESPPartitionSize    uint64
-	flagSystemPartitionSize uint64
-)
-
-func mibToSectors(size uint64) uint64 {
-	return (size * 1024 * 1024) / 512
-}
-
-type devZeroReader struct{}
-
-func (_ devZeroReader) Read(b []byte) (n int, err error) {
-	for i := range b {
-		b[i] = 0
-	}
-	return len(b), nil
-}
-
-// devZero is a /dev/zero-like reader which reads an infinite number of zeroes
-var devZero = devZeroReader{}
-
 func main() {
-	flag.StringVar(&flagEFI, "efi", "", "UEFI payload")
-	flag.StringVar(&flagOut, "out", "", "Output disk image")
-	flag.StringVar(&flagSystemPath, "system", "", "System partition [optional]")
-	flag.StringVar(&flagNodeParameters, "node_parameters", "", "Node parameters [optional]")
-	flag.Uint64Var(&flagDataPartitionSize, "data_partition_size", 2048, "Override the data partition size (default 2048 MiB)")
-	flag.Uint64Var(&flagESPPartitionSize, "esp_partition_size", 128, "Override the ESP partition size (default: 128MiB)")
-	flag.Uint64Var(&flagSystemPartitionSize, "system_partition_size", 1024, "Override the System partition size (default: 1024MiB)")
+	// Fill in the image parameters based on flags.
+	var (
+		efiPayload  string
+		systemImage string
+		nodeParams  string
+		cfg         osimage.Params
+	)
+	flag.StringVar(&efiPayload, "efi", "", "Path to the UEFI payload used")
+	flag.StringVar(&systemImage, "system", "", "Path to the system partition image used")
+	flag.StringVar(&nodeParams, "node_parameters", "", "Path to Node Parameters to be written to the ESP (default: don't write Node Parameters)")
+	flag.StringVar(&cfg.OutputPath, "out", "", "Path to the resulting disk image or block device")
+	flag.Uint64Var(&cfg.PartitionSize.Data, "data_partition_size", 2048, "Override the data partition size (default 2048 MiB). Used only when generating image files.")
+	flag.Uint64Var(&cfg.PartitionSize.ESP, "esp_partition_size", 128, "Override the ESP partition size (default: 128MiB)")
+	flag.Uint64Var(&cfg.PartitionSize.System, "system_partition_size", 1024, "Override the System partition size (default: 1024MiB)")
+	flag.StringVar(&cfg.DiskGUID, "GUID", "", "Disk GUID marked in the resulting image's partition table (default: randomly generated)")
 	flag.Parse()
 
-	if flagEFI == "" || flagOut == "" {
-		log.Fatalf("efi and initramfs must be set")
-	}
-
-	_ = os.Remove(flagOut)
-	diskImg, err := diskfs.Create(flagOut, 4*1024*1024*1024, diskfs.Raw)
+	// Open the input files for osimage.Create, fill in reader objects and
+	// metadata in osimage.Params.
+	// Start with the EFI Payload the OS will boot from.
+	p, err := os.Open(efiPayload)
 	if err != nil {
-		log.Fatalf("diskfs.Create(%q): %v", flagOut, err)
+		log.Fatalf("while opening the EFI payload at %q: %s", efiPayload, err.Error())
 	}
+	defer p.Close()
+	cfg.EFIPayload = p
 
-	table := &gpt.Table{
-		// This is appropriate at least for virtio disks. Might need to be
-		// adjusted for real ones.
-		LogicalSectorSize:  512,
-		PhysicalSectorSize: 512,
-		ProtectiveMBR:      true,
-		Partitions: []*gpt.Partition{
-			{
-				Type:  gpt.EFISystemPartition,
-				Name:  "ESP",
-				Start: mibToSectors(1),
-				End:   mibToSectors(flagESPPartitionSize) - 1,
-			},
-			{
-				Type:  NodeSystemPartition,
-				Name:  "METROPOLIS-SYSTEM",
-				Start: mibToSectors(flagESPPartitionSize),
-				End:   mibToSectors(flagESPPartitionSize+flagSystemPartitionSize) - 1,
-			},
-			{
-				Type:  NodeDataPartition,
-				Name:  "METROPOLIS-NODE-DATA",
-				Start: mibToSectors(flagESPPartitionSize + flagSystemPartitionSize),
-				End:   mibToSectors(flagESPPartitionSize+flagSystemPartitionSize+flagDataPartitionSize) - 1,
-			},
-		},
-	}
-	if err := diskImg.Partition(table); err != nil {
-		log.Fatalf("Failed to apply partition table: %v", err)
-	}
-
-	if flagSystemPath != "" {
-		systemPart, err := os.Open(flagSystemPath)
+	// Attempt to open the system image if its path is set. In case the path
+	// isn't set, the system partition will still be created, but no
+	// contents will be written into it.
+	if systemImage != "" {
+		img, err := os.Open(systemImage)
 		if err != nil {
-			log.Fatalf("Failed to open system partition: %v", err)
+			log.Fatalf("while opening the system image at %q: %s", systemImage, err.Error())
 		}
-		defer systemPart.Close()
-		systemPartMeta, err := systemPart.Stat()
+		defer img.Close()
+		cfg.SystemImage = img
+	}
+
+	// Attempt to open the node parameters file if its path is set.
+	if nodeParams != "" {
+		np, err := os.Open(nodeParams)
 		if err != nil {
-			log.Fatalf("Failed to stat system partition: %v", err)
+			log.Fatalf("while opening node parameters at %q: %s", nodeParams, err.Error())
 		}
-		padding := int64(flagSystemPartitionSize*1024*1024) - systemPartMeta.Size()
-		systemPartMulti := io.MultiReader(systemPart, io.LimitReader(devZero, padding))
-		if _, err := diskImg.WritePartitionContents(2, systemPartMulti); err != nil {
-			log.Fatalf("Failed to write system partition: %v", err)
-		}
+		defer np.Close()
+		cfg.NodeParameters = np
 	}
 
-	fs, err := diskImg.CreateFilesystem(disk.FilesystemSpec{Partition: 1, FSType: filesystem.TypeFat32, VolumeLabel: "ESP"})
-	if err != nil {
-		log.Fatalf("Failed to create filesystem: %v", err)
-	}
-
-	// Create EFI partition structure.
-	for _, dir := range []string{"/EFI", "/EFI/BOOT", "/EFI/metropolis"} {
-		if err := fs.Mkdir(dir); err != nil {
-			log.Fatalf("Mkdir(%q): %v", dir, err)
-		}
-	}
-
-	put(fs, flagEFI, "/EFI/BOOT/BOOTX64.EFI")
-
-	if flagNodeParameters != "" {
-		put(fs, flagNodeParameters, "/EFI/metropolis/parameters.pb")
-	}
-
-	if err := diskImg.File.Close(); err != nil {
-		log.Fatalf("Failed to finalize image: %v", err)
-	}
-	log.Printf("Success! You can now boot %v", flagOut)
-}
-
-// put copies a file from the host filesystem into the target image.
-func put(fs filesystem.FileSystem, src, dst string) {
-	target, err := fs.OpenFile(dst, os.O_CREATE|os.O_RDWR)
-	if err != nil {
-		log.Fatalf("fs.OpenFile(%q): %v", dst, err)
-	}
-	source, err := os.Open(src)
-	if err != nil {
-		log.Fatalf("os.Open(%q): %v", src, err)
-	}
-	defer source.Close()
-	// If this is streamed (e.g. using io.Copy) it exposes a bug in diskfs, so
-	// do it in one go.
-	data, err := ioutil.ReadAll(source)
-	if err != nil {
-		log.Fatalf("Reading %q: %v", src, err)
-	}
-	if _, err := target.Write(data); err != nil {
-		fmt.Printf("writing file %q: %v", dst, err)
-		os.Exit(1)
+	// Write the parametrized OS image.
+	if _, err := osimage.Create(&cfg); err != nil {
+		log.Fatalf("while creating a Metropolis OS image: %s", err.Error())
 	}
 }
diff --git a/metropolis/node/build/mkimage/osimage/BUILD.bazel b/metropolis/node/build/mkimage/osimage/BUILD.bazel
new file mode 100644
index 0000000..d9cacae
--- /dev/null
+++ b/metropolis/node/build/mkimage/osimage/BUILD.bazel
@@ -0,0 +1,15 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["osimage.go"],
+    importpath = "source.monogon.dev/metropolis/node/build/mkimage/osimage",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//metropolis/pkg/efivarfs:go_default_library",
+        "@com_github_diskfs_go_diskfs//:go_default_library",
+        "@com_github_diskfs_go_diskfs//disk:go_default_library",
+        "@com_github_diskfs_go_diskfs//filesystem:go_default_library",
+        "@com_github_diskfs_go_diskfs//partition/gpt:go_default_library",
+    ],
+)
diff --git a/metropolis/node/build/mkimage/osimage/osimage.go b/metropolis/node/build/mkimage/osimage/osimage.go
new file mode 100644
index 0000000..4ad2d5f
--- /dev/null
+++ b/metropolis/node/build/mkimage/osimage/osimage.go
@@ -0,0 +1,389 @@
+// Copyright 2020 The Monogon Project Authors.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// 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.
+
+// This package provides self-contained implementation used to generate
+// Metropolis disk images.
+package osimage
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+
+	diskfs "github.com/diskfs/go-diskfs"
+	"github.com/diskfs/go-diskfs/disk"
+	"github.com/diskfs/go-diskfs/filesystem"
+	"github.com/diskfs/go-diskfs/partition/gpt"
+
+	"source.monogon.dev/metropolis/pkg/efivarfs"
+)
+
+const (
+	systemPartitionType = gpt.Type("ee96055b-f6d0-4267-8bbb-724b2afea74c")
+	SystemVolumeLabel   = "METROPOLIS-SYSTEM"
+
+	dataPartitionType = gpt.Type("9eeec464-6885-414a-b278-4305c51f7966")
+	DataVolumeLabel   = "METROPOLIS-NODE-DATA"
+
+	ESPVolumeLabel = "ESP"
+
+	EFIPayloadPath = "/EFI/BOOT/BOOTx64.EFI"
+	nodeParamsPath = "/EFI/metropolis/parameters.pb"
+
+	mib = 1024 * 1024
+)
+
+// put creates a file on the target filesystem fs and fills it with
+// contents read from an io.Reader object src.
+func put(fs filesystem.FileSystem, dst string, src io.Reader) error {
+	target, err := fs.OpenFile(dst, os.O_CREATE|os.O_RDWR)
+	if err != nil {
+		return fmt.Errorf("while opening %q: %w", dst, err)
+	}
+
+	// If this is streamed (e.g. using io.Copy) it exposes a bug in diskfs, so
+	// do it in one go.
+	// TODO(mateusz@monogon.tech): Investigate the bug.
+	data, err := ioutil.ReadAll(src)
+	if err != nil {
+		return fmt.Errorf("while reading %q: %w", src, err)
+	}
+	if _, err := target.Write(data); err != nil {
+		return fmt.Errorf("while writing to %q: %w", dst, err)
+	}
+	return nil
+}
+
+// initializeESP creates an ESP filesystem in a partition specified by
+// index. It then creates the EFI executable and copies into it contents
+// of the reader object exec, which must not be nil. The node parameters
+// file is optionally created if params is not nil. initializeESP may return
+// an error.
+func initializeESP(image *disk.Disk, index int, exec, params io.Reader) error {
+	// Create a FAT ESP filesystem inside a partition pointed to by
+	// index.
+	spec := disk.FilesystemSpec{
+		Partition:   index,
+		FSType:      filesystem.TypeFat32,
+		VolumeLabel: ESPVolumeLabel,
+	}
+	fs, err := image.CreateFilesystem(spec)
+	if err != nil {
+		return fmt.Errorf("while creating an ESP filesystem: %w", err)
+	}
+
+	// Create the EFI partition structure.
+	for _, dir := range []string{"/EFI", "/EFI/BOOT", "/EFI/metropolis"} {
+		if err := fs.Mkdir(dir); err != nil {
+			return fmt.Errorf("while creating %q: %w", dir, err)
+		}
+	}
+
+	// Copy the EFI payload to the newly created filesystem.
+	if exec == nil {
+		return fmt.Errorf("exec must not be nil")
+	}
+	if err := put(fs, EFIPayloadPath, exec); err != nil {
+		return fmt.Errorf("while writing an EFI payload: %w", err)
+	}
+
+	if params != nil {
+		// Copy Node Parameters into the ESP.
+		if err := put(fs, nodeParamsPath, params); err != nil {
+			return fmt.Errorf("while writing node parameters: %w", err)
+		}
+	}
+	return nil
+}
+
+// zeroSrc is a source of null bytes implementing io.Reader. It acts as a
+// helper data type.
+type zeroSrc struct{}
+
+// Read implements io.Reader for zeroSrc. It fills b with zero bytes. The
+// returned error is always nil.
+func (_ zeroSrc) Read(b []byte) (n int, err error) {
+	for i := range b {
+		b[i] = 0
+	}
+	return len(b), nil
+}
+
+// initializeSystemPartition copies system partition contents into a partition
+// at index. The remaining partition space is zero-padded. This function may
+// return an error.
+func initializeSystemPartition(image *disk.Disk, index int, contents io.Reader) error {
+	// Check the parameters.
+	if contents == nil {
+		return fmt.Errorf("system partition contents parameter must not be nil")
+	}
+	if index <= 0 {
+		return fmt.Errorf("partition index must be greater than zero")
+	}
+
+	// Get the system partition's size.
+	table, err := image.GetPartitionTable()
+	if err != nil {
+		return fmt.Errorf("while accessing a go-diskfs partition table: %w", err)
+	}
+	partitions := table.GetPartitions()
+	if index > len(partitions) {
+		return fmt.Errorf("partition index out of bounds")
+	}
+	size := partitions[index-1].GetSize()
+
+	// Copy the contents of the Metropolis system image into the system partition
+	// at partitionIndex. Zero-pad the remaining space.
+	var zero zeroSrc
+	sys := io.LimitReader(io.MultiReader(contents, zero), size)
+	if _, err := image.WritePartitionContents(index, sys); err != nil {
+		return fmt.Errorf("while copying the system partition: %w", err)
+	}
+	return nil
+}
+
+// mibToSectors converts a size expressed in mebibytes to a number of
+// sectors needed to store data of that size. sectorSize parameter
+// specifies the size of a logical sector.
+func mibToSectors(size, sectorSize uint64) uint64 {
+	return (size * mib) / sectorSize
+}
+
+// PartitionSizeInfo contains parameters used during partition table
+// initialization and, in case of image files, space allocation.
+type PartitionSizeInfo struct {
+	// Size of the EFI System Partition (ESP), in mebibytes. The size must
+	// not be zero.
+	ESP uint64
+	// Size of the Metropolis system partition, in mebibytes. The partition
+	// won't be created if the size is zero.
+	System uint64
+	// Size of the Metropolis data partition, in mebibytes. The partition
+	// won't be created if the size is zero. If the image is output to a
+	// block device, the partition will be extended to fill the remaining
+	// space.
+	Data uint64
+}
+
+// partitionList stores partition definitions in an ascending order.
+type partitionList []*gpt.Partition
+
+// appendPartition puts a new partition at the end of a partitionList,
+// automatically calculating its start and end markers based on data in
+// the list and the argument psize. A partition type and a name are
+// assigned to the partition. The containing image is used to calculate
+// sector addresses based on its logical block size.
+func (pl *partitionList) appendPartition(image *disk.Disk, ptype gpt.Type, pname string, psize uint64) {
+	// Calculate the start and end marker.
+	var pstart, pend uint64
+	if len(*pl) != 0 {
+		pstart = (*pl)[len(*pl)-1].End + 1
+	} else {
+		pstart = mibToSectors(1, uint64(image.LogicalBlocksize))
+	}
+	pend = pstart + mibToSectors(psize, uint64(image.LogicalBlocksize)) - 1
+
+	// Put the new partition at the end of the list.
+	*pl = append(*pl, &gpt.Partition{
+		Type:  ptype,
+		Name:  pname,
+		Start: pstart,
+		End:   pend,
+	})
+}
+
+// extendLastPartition moves the end marker of the last partition in a
+// partitionList to the end of image, assigning all of the remaining free
+// space to it. It may return an error.
+func (pl *partitionList) extendLastPartition(image *disk.Disk) error {
+	if len(*pl) == 0 {
+		return fmt.Errorf("no partitions defined")
+	}
+	if image.Size == 0 {
+		return fmt.Errorf("the image size mustn't be zero")
+	}
+	if image.LogicalBlocksize == 0 {
+		return fmt.Errorf("the image's logical block size mustn't be zero")
+	}
+
+	// The last 33 blocks are occupied by the Secondary GPT.
+	(*pl)[len(*pl)-1].End = uint64(image.Size/image.LogicalBlocksize) - 33
+	return nil
+}
+
+// initializePartitionTable applies a Metropolis-compatible GPT partition
+// table to an image. Logical and physical sector sizes are based on
+// block sizes exposed by Disk. Partition extents are defined by the size
+// argument. A diskGUID is associated with the partition table. In an event
+// the table couldn't have been applied, the function will return an error.
+func initializePartitionTable(image *disk.Disk, size *PartitionSizeInfo, diskGUID string) error {
+	// Start with preparing a partition list.
+	var pl partitionList
+	// Create the ESP.
+	if size.ESP == 0 {
+		return fmt.Errorf("ESP size mustn't be zero")
+	}
+	pl.appendPartition(image, gpt.EFISystemPartition, ESPVolumeLabel, size.ESP)
+	// Create the system partition only if its size is specified.
+	if size.System != 0 {
+		pl.appendPartition(image, systemPartitionType, SystemVolumeLabel, size.System)
+	}
+	// Create the data partition only if its size is specified.
+	if size.Data != 0 {
+		// Don't specify the last partition's length, as it will be extended
+		// to fit the image size anyway. size.Data will still be used in the
+		// space allocation step.
+		pl.appendPartition(image, dataPartitionType, DataVolumeLabel, 0)
+		if err := pl.extendLastPartition(image); err != nil {
+			return fmt.Errorf("while extending the last partition: %w", err)
+		}
+	}
+
+	// Build and apply the partition table.
+	table := &gpt.Table{
+		LogicalSectorSize:  int(image.LogicalBlocksize),
+		PhysicalSectorSize: int(image.PhysicalBlocksize),
+		ProtectiveMBR:      true,
+		GUID:               diskGUID,
+		Partitions:         pl,
+	}
+	if err := image.Partition(table); err != nil {
+		// Return the error unwrapped.
+		return err
+	}
+	return nil
+}
+
+// Params contains parameters used by Create to build a Metropolis OS
+// image.
+type Params struct {
+	// OutputPath is the path an OS image will be written to. If the path
+	// points to an existing block device, the data partition will be
+	// extended to fill it entirely. Otherwise, a regular image file will
+	// be created at OutputPath. The path must not point to an existing
+	// regular file.
+	OutputPath string
+	// EFIPayload provides contents of the EFI payload file. It must not be
+	// nil.
+	EFIPayload io.Reader
+	// SystemImage provides contents of the Metropolis system partition.
+	// If nil, no contents will be copied into the partition.
+	SystemImage io.Reader
+	// NodeParameters provides contents of the node parameters file. If nil,
+	// the node parameters file won't be created in the target ESP
+	// filesystem.
+	NodeParameters io.Reader
+	// DiskGUID is a unique identifier of the image and a part of GPT
+	// header. It's optional and can be left blank if the identifier is
+	// to be randomly generated. Setting it to a predetermined value can
+	// help in implementing reproducible builds.
+	DiskGUID string
+	// PartitionSize specifies a size for the ESP, Metropolis System and
+	// Metropolis data partition.
+	PartitionSize PartitionSizeInfo
+}
+
+// Create writes a Metropolis OS image to either a newly created regular
+// file or a block device. The image is parametrized by the params
+// argument. In case a regular file already exists at params.OutputPath,
+// the function will fail. It returns nil on success or an error, if one
+// did occur.
+func Create(params *Params) (*efivarfs.BootEntry, error) {
+	// Validate each parameter before use.
+	if params.OutputPath == "" {
+		return nil, fmt.Errorf("image output path must be set")
+	}
+
+	// Learn whether we're creating a new image or writing to an existing
+	// block device by stat-ing the output path parameter.
+	outInfo, err := os.Stat(params.OutputPath)
+	if err != nil && !os.IsNotExist(err) {
+		return nil, err
+	}
+
+	// Calculate the image size (bytes) by summing up partition sizes
+	// (mebibytes).
+	minSize := (int64(params.PartitionSize.ESP) +
+		int64(params.PartitionSize.System) +
+		int64(params.PartitionSize.Data) + 1) * mib
+	var diskImg *disk.Disk
+	if !os.IsNotExist(err) && outInfo.Mode()&os.ModeDevice != 0 {
+		// Open the block device. The data partition size parameter won't
+		// matter in this case, as said partition will be extended till the
+		// end of device.
+		diskImg, err = diskfs.Open(params.OutputPath)
+		if err != nil {
+			return nil, fmt.Errorf("couldn't open the block device at %q: %w", params.OutputPath, err)
+		}
+		// Make sure there's at least minSize space available on the block
+		// device.
+		if minSize > diskImg.Size {
+			return nil, fmt.Errorf("not enough space available on the block device at %q", params.OutputPath)
+		}
+	} else {
+		// Attempt to create an image file at params.OutputPath. diskfs.Create
+		// will abort in case a file already exists at the given path.
+		// Calculate the image size expressed in bytes by summing up declared
+		// partition lengths.
+		diskImg, err = diskfs.Create(params.OutputPath, minSize, diskfs.Raw)
+		if err != nil {
+			return nil, fmt.Errorf("couldn't create a disk image at %q: %w", params.OutputPath, err)
+		}
+	}
+
+	// Go through the initialization steps, starting with applying a
+	// partition table according to params.
+	if err := initializePartitionTable(diskImg, &params.PartitionSize, params.DiskGUID); err != nil {
+		return nil, fmt.Errorf("failed to initialize the partition table: %w", err)
+	}
+	// The system partition will be created only if its specified size isn't
+	// equal to zero, making the initialization step optional as well. In
+	// addition, params.SystemImage must be set.
+	if params.PartitionSize.System != 0 && params.SystemImage != nil {
+		if err := initializeSystemPartition(diskImg, 2, params.SystemImage); err != nil {
+			return nil, fmt.Errorf("failed to initialize the system partition: %w", err)
+		}
+	} else if params.PartitionSize.System == 0 && params.SystemImage != nil {
+		// Safeguard against contradicting parameters.
+		return nil, fmt.Errorf("the system image parameter was passed while the associated partition size is zero")
+	}
+	// Attempt to initialize the ESP unconditionally, as it's the only
+	// partition guaranteed to be created regardless of params.PartitionSize.
+	if err := initializeESP(diskImg, 1, params.EFIPayload, params.NodeParameters); err != nil {
+		return nil, fmt.Errorf("failed to initialize the ESP: %w", err)
+	}
+	// The data partition, even if created, is always left uninitialized.
+
+	// Build an EFI boot entry pointing to the image's ESP. go-diskfs won't let
+	// you do that after you close the image.
+	t, err := diskImg.GetPartitionTable()
+	p := t.GetPartitions()
+	esp := (p[0]).(*gpt.Partition)
+	be := efivarfs.BootEntry{
+		Description:     "Metropolis",
+		Path:            EFIPayloadPath,
+		PartitionGUID:   esp.GUID,
+		PartitionNumber: 1,
+		PartitionStart:  esp.Start,
+		PartitionSize:   esp.End - esp.Start + 1,
+	}
+	// Close the image and return the EFI boot entry.
+	if err := diskImg.File.Close(); err != nil {
+		return nil, fmt.Errorf("failed to finalize image: %w", err)
+	}
+	return &be, nil
+}