Index: boot/Makefile.build
===================================================================
--- boot/Makefile.build	(revision 209cd41cc4d57974356cbf19757223b50b39f78e)
+++ boot/Makefile.build	(revision dcc2c5d1ea2cf6e1487e83ae2b5362fe7b527161)
@@ -69,4 +69,8 @@
 DEPENDS := $(addsuffix .d,$(basename $(SOURCES)))
 
+ifeq ($(CONFIG_COMPRESSED_INIT),y)
+	COMPONENTS := $(addsuffix .gz, $(COMPONENTS))
+endif
+
 all: $(VERSION_DEF) $(COMMON_MAKEFILE) $(COMMON_HEADER) $(CONFIG_MAKEFILE) $(CONFIG_HEADER) $(BOOT_OUTPUT)
 
@@ -101,5 +105,5 @@
 	gzip -n -k -f $<
 
-$(COMPS).tar: $(addsuffix .gz, $(COMPONENTS))
+$(COMPS).tar: $(COMPONENTS)
 	tar --mtime='2032-01-01 00:00:00' --group=0 --owner=0 --no-acls --no-selinux --no-xattrs --format=ustar --transform 's/.*\///g' -cvf $@ $^
 
Index: boot/arch/ppc32/src/main.c
===================================================================
--- boot/arch/ppc32/src/main.c	(revision 209cd41cc4d57974356cbf19757223b50b39f78e)
+++ boot/arch/ppc32/src/main.c	(revision dcc2c5d1ea2cf6e1487e83ae2b5362fe7b527161)
@@ -73,8 +73,8 @@
 	    (void *) LOADER_ADDRESS, loader_address_pa);
 
-	size_t uncompressed_size = payload_uncompressed_size();
-	printf("Payload uncompressed size: %d bytes\n", uncompressed_size);
+	size_t unpacked_size = payload_unpacked_size();
+	printf("Payload uncompressed size: %d bytes\n", unpacked_size);
 
-	if (uncompressed_size >= (size_t) loader_address_pa) {
+	if (unpacked_size >= (size_t) loader_address_pa) {
 		printf("Inflated components overlap loader area.\n");
 		printf("The boot image is too large. Halting.\n");
@@ -91,8 +91,8 @@
 	void *inflate_base_pa;
 	ofw_alloc("inflate area", &inflate_base, &inflate_base_pa,
-	    uncompressed_size, loader_address_pa);
+	    unpacked_size, loader_address_pa);
 	printf(" %p|%p: inflate area\n", inflate_base, inflate_base_pa);
 
-	uintptr_t balloc_start = ALIGN_UP(uncompressed_size, PAGE_SIZE);
+	uintptr_t balloc_start = ALIGN_UP(unpacked_size, PAGE_SIZE);
 	size_t pages = (balloc_start + ALIGN_UP(BALLOC_MAX_SIZE, PAGE_SIZE)) >>
 	    PAGE_WIDTH;
@@ -109,5 +109,5 @@
 	/* Inflate components. */
 	extract_payload(&bootinfo.taskmap, inflate_base,
-	    inflate_base + uncompressed_size, PA2KA(0), NULL);
+	    inflate_base + unpacked_size, PA2KA(0), NULL);
 
 	printf("Setting up boot allocator ...\n");
Index: boot/arch/sparc64/src/main.c
===================================================================
--- boot/arch/sparc64/src/main.c	(revision 209cd41cc4d57974356cbf19757223b50b39f78e)
+++ boot/arch/sparc64/src/main.c	(revision dcc2c5d1ea2cf6e1487e83ae2b5362fe7b527161)
@@ -225,5 +225,5 @@
 	 */
 
-	size_t sz = ALIGN_UP(payload_uncompressed_size(), PAGE_SIZE);
+	size_t sz = ALIGN_UP(payload_unpacked_size(), PAGE_SIZE);
 	ofw_claim_phys((void *) (bootinfo.physmem_start + KERNEL_ADDRESS), sz);
 	ofw_map((void *) (bootinfo.physmem_start + KERNEL_ADDRESS),
Index: boot/generic/include/payload.h
===================================================================
--- boot/generic/include/payload.h	(revision 209cd41cc4d57974356cbf19757223b50b39f78e)
+++ boot/generic/include/payload.h	(revision dcc2c5d1ea2cf6e1487e83ae2b5362fe7b527161)
@@ -40,5 +40,5 @@
 extern uint8_t loader_end[];
 
-size_t payload_uncompressed_size(void);
+size_t payload_unpacked_size(void);
 void extract_payload(taskmap_t *, uint8_t *, uint8_t *, uintptr_t,
     void (*)(void *, size_t));
Index: boot/generic/src/payload.c
===================================================================
--- boot/generic/src/payload.c	(revision 209cd41cc4d57974356cbf19757223b50b39f78e)
+++ boot/generic/src/payload.c	(revision dcc2c5d1ea2cf6e1487e83ae2b5362fe7b527161)
@@ -41,7 +41,7 @@
 #include <halt.h>
 
-static void basename(char *s)
-{
-	char *last = s;
+static const char *ext(const char *s)
+{
+	const char *last = s;
 
 	while (*s) {
@@ -53,5 +53,19 @@
 
 	if (*last == '.')
-		*last = '\0';
+		return last;
+
+	return NULL;
+}
+
+static void basename(char *s)
+{
+	char *e = (char *) ext(s);
+	if (str_cmp(e, ".gz") == 0)
+		*e = '\0';
+}
+
+static bool isgzip(const char *s)
+{
+	return str_cmp(ext(s), ".gz") == 0;
 }
 
@@ -68,14 +82,16 @@
 	const char *name;
 	const uint8_t *data;
-	size_t compressed_size;
-	size_t uncompressed_size;
-
-	if (!tar_info(*cstart, cend, &name, &compressed_size))
+	size_t packed_size;
+	size_t unpacked_size;
+
+	if (!tar_info(*cstart, cend, &name, &packed_size))
 		return false;
 
 	data = *cstart + TAR_BLOCK_SIZE;
-	*cstart += TAR_BLOCK_SIZE + ALIGN_UP(compressed_size, TAR_BLOCK_SIZE);
-
-	uncompressed_size = gzip_size(data, compressed_size);
+	*cstart += TAR_BLOCK_SIZE + ALIGN_UP(packed_size, TAR_BLOCK_SIZE);
+
+	bool gz = isgzip(name);
+
+	unpacked_size = gz ? gzip_size(data, packed_size) : packed_size;
 
 	/* Components must be page-aligned. */
@@ -83,5 +99,5 @@
 	actual_ustart += new_ustart - ustart;
 	ustart = new_ustart;
-	uint8_t *comp_end = ustart + uncompressed_size;
+	uint8_t *comp_end = ustart + unpacked_size;
 
 	/* Check limits and overlap. */
@@ -92,5 +108,5 @@
 		actual_ustart += new_ustart - ustart;
 		ustart = new_ustart;
-		comp_end = ustart + uncompressed_size;
+		comp_end = ustart + unpacked_size;
 	}
 
@@ -102,39 +118,47 @@
 
 	printf(" %p|%p: %s image (%zu/%zu bytes)\n", (void *) actual_ustart,
-	    ustart, name, uncompressed_size, compressed_size);
+	    ustart, name, unpacked_size, packed_size);
 
 	if (task) {
 		task->addr = (void *) actual_ustart;
-		task->size = uncompressed_size;
+		task->size = unpacked_size;
 		str_cpy(task->name, BOOTINFO_TASK_NAME_BUFLEN, name);
 		/* Remove .gz extension */
-		basename(task->name);
-	}
-
-	int rc = gzip_expand(data, compressed_size, ustart, uncompressed_size);
-	if (rc != EOK) {
-		printf("\n%s: Inflating error %d\n", name, rc);
-		halt();
+		if (gz)
+			basename(task->name);
+	}
+
+	if (gz) {
+		int rc = gzip_expand(data, packed_size, ustart, unpacked_size);
+		if (rc != EOK) {
+			printf("\n%s: Inflating error %d\n", name, rc);
+			halt();
+		}
+	} else {
+		memcpy(ustart, data, unpacked_size);
 	}
 
 	if (clear_cache)
-		clear_cache(ustart, uncompressed_size);
+		clear_cache(ustart, unpacked_size);
+
 	return true;
 }
 
-/* @return Bytes needed for uncompressed payload. */
-size_t payload_uncompressed_size(void)
+/* @return Bytes needed for unpacked payload. */
+size_t payload_unpacked_size(void)
 {
 	size_t sz = 0;
 	uint8_t *start = payload_start;
 	const char *name;
-	size_t compressed_size;
-
-	while (tar_info(start, payload_end, &name, &compressed_size)) {
+	size_t packed_size;
+
+	while (tar_info(start, payload_end, &name, &packed_size)) {
 		sz = ALIGN_UP(sz, PAGE_SIZE);
-		sz += gzip_size(start + TAR_BLOCK_SIZE, compressed_size);
-
-		start += TAR_BLOCK_SIZE +
-		    ALIGN_UP(compressed_size, TAR_BLOCK_SIZE);
+		if (isgzip(name))
+			sz += gzip_size(start + TAR_BLOCK_SIZE, packed_size);
+		else
+			sz += packed_size;
+
+		start += TAR_BLOCK_SIZE + ALIGN_UP(packed_size, TAR_BLOCK_SIZE);
 	}
 
@@ -186,5 +210,5 @@
 		/*
 		 * First, move the payload to the very end of available memory,
-		 * to make space for the decompressed data.
+		 * to make space for the unpacked data.
 		 */
 		real_payload_start = (uint8_t *) ALIGN_DOWN((uintptr_t)(mem_end - payload_size), PAGE_SIZE);