diff --git a/src/Magnum/AbstractImage.h b/src/Magnum/AbstractImage.h
index a9b99be8b..7f76718d5 100644
--- a/src/Magnum/AbstractImage.h
+++ b/src/Magnum/AbstractImage.h
@@ -26,7 +26,7 @@
 */
 
 /** @file
- * @brief Class @ref Magnum::AbstractImage
+ * @brief Class @ref Magnum::AbstractImage, @ref Magnum::AbstractCompressedImage
  */
 
 #include <cstddef>
@@ -43,10 +43,11 @@ namespace Implementation {
 }
 
 /**
-@brief Non-templated base for one-, two- or three-dimensional images
+@brief Non-templated base for one-, two- or three-dimensional uncompressed images
 
 See @ref Image, @ref ImageView, @ref BufferImage and @ref Trade::ImageData
 documentation for more information.
+@see @ref AbstractCompressedImage
 @todo Where to put glClampColor() and glPixelStore() encapsulation? It is
     needed in AbstractFramebuffer::read(), Texture::setImage() etc (i.e. all
     functions operating with images). It also possibly needs to be "stackable"
@@ -66,6 +67,18 @@ class AbstractImage {
         Int _dummy;
 };
 
+/**
+@brief Non-templated base for one-, two- or three-dimensional compressed images
+
+See @ref CompressedImage, @ref CompressedImageView, @ref CompressedBufferImage
+and @ref Trade::ImageData documentation for more information.
+@see @ref AbstractImage
+*/
+class AbstractCompressedImage: public AbstractImage {
+    protected:
+        ~AbstractCompressedImage() = default;
+};
+
 }
 
 #endif
diff --git a/src/Magnum/BufferImage.cpp b/src/Magnum/BufferImage.cpp
index 2c59369c9..716036202 100644
--- a/src/Magnum/BufferImage.cpp
+++ b/src/Magnum/BufferImage.cpp
@@ -41,10 +41,27 @@ template<UnsignedInt dimensions> void BufferImage<dimensions>::setData(ColorForm
     _buffer.setData({data, dataSize(size)}, usage);
 }
 
+template<UnsignedInt dimensions> CompressedBufferImage<dimensions>::CompressedBufferImage(CompressedColorFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::ArrayView<const void> data, BufferUsage usage): _format{format}, _size{size}, _buffer{Buffer::TargetHint::PixelPack}, _dataSize{data.size()} {
+    _buffer.setData(data, usage);
+}
+
+template<UnsignedInt dimensions> CompressedBufferImage<dimensions>::CompressedBufferImage(): _format{}, _buffer{Buffer::TargetHint::PixelPack}, _dataSize{} {}
+
+template<UnsignedInt dimensions> void CompressedBufferImage<dimensions>::setData(CompressedColorFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::ArrayView<const void> data, BufferUsage usage) {
+    _format = format;
+    _size = size;
+    _buffer.setData(data, usage);
+    _dataSize = data.size();
+}
+
 #ifndef DOXYGEN_GENERATING_OUTPUT
 template class MAGNUM_EXPORT BufferImage<1>;
 template class MAGNUM_EXPORT BufferImage<2>;
 template class MAGNUM_EXPORT BufferImage<3>;
+
+template class MAGNUM_EXPORT CompressedBufferImage<1>;
+template class MAGNUM_EXPORT CompressedBufferImage<2>;
+template class MAGNUM_EXPORT CompressedBufferImage<3>;
 #endif
 #endif
 
diff --git a/src/Magnum/BufferImage.h b/src/Magnum/BufferImage.h
index 31728a2f7..d6b9dc908 100644
--- a/src/Magnum/BufferImage.h
+++ b/src/Magnum/BufferImage.h
@@ -27,7 +27,7 @@
 
 #ifndef MAGNUM_TARGET_GLES2
 /** @file
- * @brief Class @ref Magnum::BufferImage, typedef @ref Magnum::BufferImage1D, @ref Magnum::BufferImage2D, @ref Magnum::BufferImage3D
+ * @brief Class @ref Magnum::BufferImage, @ref Magnum::CompressedBufferImage, typedef @ref Magnum::BufferImage1D, @ref Magnum::BufferImage2D, @ref Magnum::BufferImage3D, @ref Magnum::CompressedBufferImage1D, @ref Magnum::CompressedBufferImage2D, @ref Magnum::CompressedBufferImage3D
  */
 #endif
 
@@ -44,7 +44,8 @@ namespace Magnum {
 
 Stores image data in GPU memory. Interchangeable with @ref Image,
 @ref ImageView or @ref Trade::ImageData.
-@see @ref BufferImage1D, @ref BufferImage2D, @ref BufferImage3D, @ref Buffer
+@see @ref BufferImage1D, @ref BufferImage2D, @ref BufferImage3D,
+    @ref CompressedBufferImage, @ref Buffer
 @requires_gles30 Pixel buffer objects are not available in OpenGL ES 2.0.
 @requires_webgl20 Pixel buffer objects are not available in WebGL 1.0.
 */
@@ -142,10 +143,109 @@ typedef BufferImage<2> BufferImage2D;
 /** @brief Three-dimensional buffer image */
 typedef BufferImage<3> BufferImage3D;
 
+/**
+@brief Compressed buffer image
+
+Stores image data in GPU memory.
+
+See @ref BufferImage for more information. Interchangeable with @ref CompressedImage,
+@ref CompressedImageView or @ref Trade::ImageData.
+@see @ref CompressedBufferImage1D, @ref CompressedBufferImage2D,
+    @ref CompressedBufferImage3D
+@requires_gles30 Pixel buffer objects are not available in OpenGL ES 2.0.
+@requires_webgl20 Pixel buffer objects are not available in WebGL 1.0.
+*/
+template<UnsignedInt dimensions> class CompressedBufferImage: public AbstractCompressedImage {
+    public:
+        enum: UnsignedInt {
+            Dimensions = dimensions /**< Image dimension count */
+        };
+
+        /**
+         * @brief Constructor
+         * @param format            Format of compressed data
+         * @param size              Image size
+         * @param data              Image data
+         * @param usage             Image buffer usage
+         *
+         * The data are *not* deleted after filling the buffer.
+         * @todo Make it more flexible (usable with
+         *      @extension{ARB,buffer_storage}, avoiding relocations...)
+         */
+        explicit CompressedBufferImage(CompressedColorFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::ArrayView<const void> data, BufferUsage usage);
+
+        /**
+         * @brief Constructor
+         *
+         * Format is undefined, size is zero and buffer is empty, call
+         * @ref setData() to fill the image with data.
+         */
+        /*implicit*/ CompressedBufferImage();
+
+        /** @brief Copying is not allowed */
+        CompressedBufferImage(const CompressedBufferImage<dimensions>&) = delete;
+
+        /** @brief Move constructor */
+        CompressedBufferImage(CompressedBufferImage<dimensions>&& other) noexcept;
+
+        /** @brief Copying is not allowed */
+        CompressedBufferImage<dimensions>& operator=(const CompressedBufferImage<dimensions>&) = delete;
+
+        /** @brief Move assignment */
+        CompressedBufferImage<dimensions>& operator=(CompressedBufferImage<dimensions>&& other) noexcept;
+
+        /** @brief Format of compressed data */
+        CompressedColorFormat format() const { return _format; }
+
+        /** @brief Image size */
+        VectorTypeFor<Dimensions, Int> size() const { return _size; }
+
+        /** @brief Image buffer */
+        Buffer& buffer() { return _buffer; }
+
+        /** @brief Raw data size */
+        std::size_t dataSize() const { return _dataSize; }
+
+        /**
+         * @brief Set image data
+         * @param format            Format of compressed data
+         * @param size              Image size
+         * @param data              Image data
+         * @param usage             Image buffer usage
+         *
+         * Updates the image buffer with given data. The data are *not* deleted
+         * after filling the buffer.
+         * @see @ref Buffer::setData()
+         * @todo Make it more flexible (usable with
+         *      @extension{ARB,buffer_storage}, avoiding relocations...)
+         */
+        void setData(CompressedColorFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::ArrayView<const void> data, BufferUsage usage);
+
+    private:
+        CompressedColorFormat _format;
+        Math::Vector<Dimensions, Int> _size;
+        Buffer _buffer;
+        std::size_t _dataSize;
+};
+
+/** @brief One-dimensional compressed buffer image */
+typedef CompressedBufferImage<1> CompressedBufferImage1D;
+
+/** @brief Two-dimensional compressed buffer image */
+typedef CompressedBufferImage<2> CompressedBufferImage2D;
+
+/** @brief Three-dimensional compressed buffer image */
+typedef CompressedBufferImage<3> CompressedBufferImage3D;
+
 template<UnsignedInt dimensions> inline BufferImage<dimensions>::BufferImage(BufferImage<dimensions>&& other) noexcept: AbstractImage{std::move(other)}, _format{std::move(other._format)}, _type{std::move(other._type)}, _size{std::move(other._size)}, _buffer{std::move(other._buffer)} {
     other._size = {};
 }
 
+template<UnsignedInt dimensions> inline CompressedBufferImage<dimensions>::CompressedBufferImage(CompressedBufferImage<dimensions>&& other) noexcept: AbstractCompressedImage{std::move(other)}, _format{std::move(other._format)}, _size{std::move(other._size)}, _buffer{std::move(other._buffer)}, _dataSize{std::move(other._dataSize)} {
+    other._size = {};
+    other._dataSize = {};
+}
+
 template<UnsignedInt dimensions> inline BufferImage<dimensions>& BufferImage<dimensions>::operator=(BufferImage<dimensions>&& other) noexcept {
     AbstractImage::operator=(std::move(other));
     using std::swap;
@@ -155,6 +255,16 @@ template<UnsignedInt dimensions> inline BufferImage<dimensions>& BufferImage<dim
     swap(_buffer, other._buffer);
     return *this;
 }
+
+template<UnsignedInt dimensions> inline CompressedBufferImage<dimensions>& CompressedBufferImage<dimensions>::operator=(CompressedBufferImage<dimensions>&& other) noexcept {
+    AbstractCompressedImage::operator=(std::move(other));
+    using std::swap;
+    swap(_format, other._format);
+    swap(_size, other._size);
+    swap(_buffer, other._buffer);
+    swap(_dataSize, other._dataSize);
+    return *this;
+}
 #else
 #error this header is not available in OpenGL ES 2.0 build
 #endif
diff --git a/src/Magnum/CMakeLists.txt b/src/Magnum/CMakeLists.txt
index 5e9825a97..2a7b2bb68 100644
--- a/src/Magnum/CMakeLists.txt
+++ b/src/Magnum/CMakeLists.txt
@@ -66,6 +66,7 @@ set(Magnum_SRCS
     Trade/AbstractImageConverter.cpp
     Trade/AbstractImporter.cpp
     Trade/AbstractMaterialData.cpp
+    Trade/ImageData.cpp
     Trade/MeshData2D.cpp
     Trade/MeshData3D.cpp
     Trade/MeshObjectData2D.cpp
diff --git a/src/Magnum/Image.cpp b/src/Magnum/Image.cpp
index adecf4b47..9ded95209 100644
--- a/src/Magnum/Image.cpp
+++ b/src/Magnum/Image.cpp
@@ -35,10 +35,20 @@ template<UnsignedInt dimensions> void Image<dimensions>::setData(ColorFormat for
     _data = reinterpret_cast<char*>(data);
 }
 
+template<UnsignedInt dimensions> void CompressedImage<dimensions>::setData(CompressedColorFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) {
+    _format = format;
+    _size = size;
+    _data = std::move(data);
+}
+
 #ifndef DOXYGEN_GENERATING_OUTPUT
 template class MAGNUM_EXPORT Image<1>;
 template class MAGNUM_EXPORT Image<2>;
 template class MAGNUM_EXPORT Image<3>;
+
+template class MAGNUM_EXPORT CompressedImage<1>;
+template class MAGNUM_EXPORT CompressedImage<2>;
+template class MAGNUM_EXPORT CompressedImage<3>;
 #endif
 
 }
diff --git a/src/Magnum/Image.h b/src/Magnum/Image.h
index 6f2fda56e..4402b958a 100644
--- a/src/Magnum/Image.h
+++ b/src/Magnum/Image.h
@@ -26,9 +26,11 @@
 */
 
 /** @file
- * @brief Class @ref Magnum::Image, typedef @ref Magnum::Image1D, @ref Magnum::Image2D, @ref Magnum::Image3D
+ * @brief Class @ref Magnum::Image, @ref Magnum::CompressedImage typedef @ref Magnum::Image1D, @ref Magnum::Image2D, @ref Magnum::Image3D, @ref Magnum::CompressedImage1D, @ref Magnum::CompressedImage2D, @ref Magnum::CompressedImage3D
  */
 
+#include <Corrade/Containers/Array.h>
+
 #include "Magnum/ImageView.h"
 
 namespace Magnum {
@@ -38,7 +40,7 @@ namespace Magnum {
 
 Stores image data on client memory. Interchangeable with @ref ImageView,
 @ref BufferImage or @ref Trade::ImageData.
-@see @ref Image1D, @ref Image2D, @ref Image3D
+@see @ref Image1D, @ref Image2D, @ref Image3D, @ref CompressedImage
 */
 template<UnsignedInt dimensions> class Image: public AbstractImage {
     public:
@@ -171,11 +173,134 @@ typedef Image<2> Image2D;
 /** @brief Three-dimensional image */
 typedef Image<3> Image3D;
 
+/**
+@brief Compressed image
+
+Stores image data in client memory.
+
+See @ref Image for more information. Interchangeable with
+@ref CompressedImageView, @ref CompressedBufferImage or @ref Trade::ImageData.
+@see @ref CompressedImage1D, @ref CompressedImage2D, @ref CompressedImage3D
+*/
+template<UnsignedInt dimensions> class CompressedImage: public AbstractCompressedImage {
+    public:
+        enum: UnsignedInt {
+            Dimensions = dimensions /**< Image dimension count */
+        };
+
+        /**
+         * @brief Constructor
+         * @param format            Format of compressed data
+         * @param size              Image size
+         * @param data              Image data
+         */
+        explicit CompressedImage(CompressedColorFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data): _format{format}, _size{size}, _data{std::move(data)} {}
+
+        /**
+         * @brief Constructor
+         *
+         * Format is undefined, size is zero and data are empty, call
+         * @ref setData() to fill the image with data.
+         */
+        /*implicit*/ CompressedImage(): _format{} {}
+
+        /** @brief Copying is not allowed */
+        CompressedImage(const CompressedImage<dimensions>&) = delete;
+
+        /** @brief Move constructor */
+        CompressedImage(CompressedImage<dimensions>&& other) noexcept;
+
+        /** @brief Copying is not allowed */
+        CompressedImage<dimensions>& operator=(const CompressedImage<dimensions>&) = delete;
+
+        /** @brief Move assignment */
+        CompressedImage<dimensions>& operator=(CompressedImage<dimensions>&& other) noexcept;
+
+        /** @brief Conversion to view */
+        /*implicit*/ operator CompressedImageView<dimensions>()
+        #ifndef CORRADE_GCC47_COMPATIBILITY
+        const &;
+        #else
+        const;
+        #endif
+
+        #ifndef CORRADE_GCC47_COMPATIBILITY
+        /** @overload */
+        /*implicit*/ operator CompressedImageView<dimensions>() const && = delete;
+        #endif
+
+        /** @brief Format of compressed data */
+        CompressedColorFormat format() const { return _format; }
+
+        /** @brief Image size */
+        VectorTypeFor<dimensions, Int> size() const { return _size; }
+
+        /** @brief Raw data */
+        Containers::ArrayView<char> data() { return _data; }
+
+        /** @overload */
+        Containers::ArrayView<const char> data() const { return _data; }
+
+        /**
+         * @brief Pointer to raw data
+         *
+         * @see @ref release()
+         */
+        template<class T> T* data() {
+            return reinterpret_cast<T*>(_data.data());
+        }
+
+        /** @overload */
+        template<class T> const T* data() const {
+            return reinterpret_cast<const T*>(_data.data());
+        }
+
+        /**
+         * @brief Set image data
+         * @param format            Format of compressed data
+         * @param size              Image size
+         * @param data              Image data
+         *
+         * Deletes previous data and replaces them with new. Note that the
+         * data are not copied, but they are deleted on destruction.
+         * @see @ref release()
+         */
+        void setData(CompressedColorFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data);
+
+        /**
+         * @brief Release data storage
+         *
+         * Releases the ownership of the data pointer and resets internal state
+         * to default.
+         * @see @ref setData()
+         */
+        Containers::Array<char> release();
+
+    private:
+        CompressedColorFormat _format;
+        Math::Vector<Dimensions, Int> _size;
+        Containers::Array<char> _data;
+};
+
+/** @brief One-dimensional compressed image */
+typedef CompressedImage<1> CompressedImage1D;
+
+/** @brief Two-dimensional compressed image */
+typedef CompressedImage<2> CompressedImage2D;
+
+/** @brief Three-dimensional compressed image */
+typedef CompressedImage<3> CompressedImage3D;
+
 template<UnsignedInt dimensions> inline Image<dimensions>::Image(Image<dimensions>&& other) noexcept: AbstractImage{std::move(other)}, _format{std::move(other._format)}, _type{std::move(other._type)}, _size{std::move(other._size)}, _data{std::move(other._data)} {
     other._size = {};
     other._data = nullptr;
 }
 
+template<UnsignedInt dimensions> inline CompressedImage<dimensions>::CompressedImage(CompressedImage<dimensions>&& other) noexcept: AbstractCompressedImage{std::move(other)}, _format{std::move(other._format)}, _size{std::move(other._size)}, _data{std::move(other._data)} {
+    other._size = {};
+    other._data = nullptr;
+}
+
 template<UnsignedInt dimensions> inline Image<dimensions>& Image<dimensions>::operator=(Image<dimensions>&& other) noexcept {
     AbstractImage::operator=(std::move(other));
     using std::swap;
@@ -186,6 +311,15 @@ template<UnsignedInt dimensions> inline Image<dimensions>& Image<dimensions>::op
     return *this;
 }
 
+template<UnsignedInt dimensions> inline CompressedImage<dimensions>& CompressedImage<dimensions>::operator=(CompressedImage<dimensions>&& other) noexcept {
+    AbstractCompressedImage::operator=(std::move(other));
+    using std::swap;
+    swap(_format, other._format);
+    swap(_size, other._size);
+    swap(_data, other._data);
+    return *this;
+}
+
 template<UnsignedInt dimensions> inline Image<dimensions>::operator ImageView<dimensions>()
 #ifndef CORRADE_GCC47_COMPATIBILITY
 const &
@@ -196,6 +330,16 @@ const
     return ImageView<dimensions>{_format, _type, _size, _data};
 }
 
+template<UnsignedInt dimensions> inline CompressedImage<dimensions>::operator CompressedImageView<dimensions>()
+#ifndef CORRADE_GCC47_COMPATIBILITY
+const &
+#else
+const
+#endif
+{
+    return CompressedImageView<dimensions>{_format, _size, _data};
+}
+
 template<UnsignedInt dimensions> inline char* Image<dimensions>::release() {
     /** @todo I need `std::exchange` NOW. */
     char* const data = _data;
@@ -204,6 +348,14 @@ template<UnsignedInt dimensions> inline char* Image<dimensions>::release() {
     return data;
 }
 
+template<UnsignedInt dimensions> inline Containers::Array<char> CompressedImage<dimensions>::release() {
+    /** @todo I need `std::exchange` NOW. */
+    Containers::Array<char> data{std::move(_data)};
+    _size = {};
+    _data = nullptr;
+    return data;
+}
+
 }
 
 #endif
diff --git a/src/Magnum/ImageView.h b/src/Magnum/ImageView.h
index 6c51d22b5..e7fc96d72 100644
--- a/src/Magnum/ImageView.h
+++ b/src/Magnum/ImageView.h
@@ -26,9 +26,11 @@
 */
 
 /** @file
- * @brief Class @ref Magnum::ImageView, typedef @ref Magnum::ImageView1D, @ref Magnum::ImageView2D, @ref Magnum::ImageView3D
+ * @brief Class @ref Magnum::ImageView, @ref Magnum::CompressedImageView, typedef @ref Magnum::ImageView1D, @ref Magnum::ImageView2D, @ref Magnum::ImageView3D, @ref Magnum::CompressedImageView1D, @ref Magnum::CompressedImageView2D, @ref Magnum::CompressedImageView3D
  */
 
+#include <Corrade/Containers/ArrayView.h>
+
 #include "Magnum/Math/Vector3.h"
 #include "Magnum/AbstractImage.h"
 #include "Magnum/DimensionTraits.h"
@@ -48,7 +50,8 @@ same properties for each frame, such as video stream. Thus it is not possible
 to change image properties, only data pointer.
 
 Interchangeable with @ref Image, @ref BufferImage or @ref Trade::ImageData.
-@see @ref ImageView1D, @ref ImageView2D, @ref ImageView3D
+@see @ref ImageView1D, @ref ImageView2D, @ref ImageView3D,
+    @ref CompressedImageView
 */
 template<UnsignedInt dimensions> class ImageView: public AbstractImage {
     public:
@@ -129,6 +132,81 @@ typedef ImageView<2> ImageView2D;
 /** @brief Three-dimensional image view */
 typedef ImageView<3> ImageView3D;
 
+/**
+@brief Compressed image view
+
+Adds information about dimensions and compression type to some data in memory.
+
+See @ref ImageView for more information. Interchangeable with
+@ref CompressedImage, @ref CompressedBufferImage or @ref Trade::ImageData.
+@see @ref CompressedImageView1D, @ref CompressedImageView2D,
+    @ref CompressedImageView3D
+*/
+template<UnsignedInt dimensions> class CompressedImageView: public AbstractCompressedImage {
+    public:
+        enum: UnsignedInt {
+            Dimensions = dimensions /**< Image dimension count */
+        };
+
+        /**
+         * @brief Constructor
+         * @param format            Format of compressed data
+         * @param size              Image size
+         * @param data              Image data
+         */
+        constexpr explicit CompressedImageView(CompressedColorFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::ArrayView<const void> data): _format{format}, _size{size}, _data{reinterpret_cast<const char*>(data.data()), data.size()} {}
+
+        /**
+         * @brief Constructor
+         * @param format            Format of compressed data
+         * @param size              Image size
+         *
+         * Data pointer is set to `nullptr`, call @ref setData() to fill the
+         * image with data.
+         */
+        constexpr explicit CompressedImageView(CompressedColorFormat format, const VectorTypeFor<dimensions, Int>& size): _format{format}, _size{size} {}
+
+        /** @brief Format of compressed data */
+        CompressedColorFormat format() const { return _format; }
+
+        /** @brief Image size */
+        constexpr VectorTypeFor<dimensions, Int> size() const { return _size; }
+
+        /** @brief Raw data */
+        constexpr Containers::ArrayView<const char> data() const { return _data; }
+
+        /** @overload */
+        template<class T> const T* data() const {
+            return reinterpret_cast<const T*>(_data.data());
+        }
+
+        /**
+         * @brief Set image data
+         * @param data              Image data
+         *
+         * Dimensions, color compnents and data type remains the same as
+         * passed in constructor. The data are not copied nor deleted on
+         * destruction.
+         */
+        void setData(Containers::ArrayView<const void> data) {
+            _data = {reinterpret_cast<const char*>(data.data()), data.size()};
+        }
+
+    private:
+        CompressedColorFormat _format;
+        Math::Vector<Dimensions, Int> _size;
+        Containers::ArrayView<const char> _data;
+};
+
+/** @brief One-dimensional compressed image view */
+typedef CompressedImageView<1> CompressedImageView1D;
+
+/** @brief Two-dimensional compressed image view */
+typedef CompressedImageView<2> CompressedImageView2D;
+
+/** @brief Three-dimensional compressed image view */
+typedef CompressedImageView<3> CompressedImageView3D;
+
 }
 
 #endif
diff --git a/src/Magnum/Magnum.h b/src/Magnum/Magnum.h
index 10b2bf1a3..7864cbb9a 100644
--- a/src/Magnum/Magnum.h
+++ b/src/Magnum/Magnum.h
@@ -443,6 +443,11 @@ template<UnsignedInt> class BufferImage;
 typedef BufferImage<1> BufferImage1D;
 typedef BufferImage<2> BufferImage2D;
 typedef BufferImage<3> BufferImage3D;
+
+template<UnsignedInt> class CompressedBufferImage;
+typedef CompressedBufferImage<1> CompressedBufferImage1D;
+typedef CompressedBufferImage<2> CompressedBufferImage2D;
+typedef CompressedBufferImage<3> CompressedBufferImage3D;
 #endif
 
 #if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
@@ -480,18 +485,28 @@ typedef Image<1> Image1D;
 typedef Image<2> Image2D;
 typedef Image<3> Image3D;
 
+template<UnsignedInt> class CompressedImage;
+typedef CompressedImage<1> CompressedImage1D;
+typedef CompressedImage<2> CompressedImage2D;
+typedef CompressedImage<3> CompressedImage3D;
+
 template<UnsignedInt> class ImageView;
 typedef ImageView<1> ImageView1D;
 typedef ImageView<2> ImageView2D;
 typedef ImageView<3> ImageView3D;
 
 #ifdef MAGNUM_BUILD_DEPRECATED
-template<UnsignedInt dimensions> using CORRADE_DEPRECATED("use ImageView instead") ImageReference = ImageView<dimensions>;
+template<UnsignedInt dimensions> using ImageReference CORRADE_DEPRECATED("use ImageView instead") = ImageView<dimensions>;
 typedef CORRADE_DEPRECATED("use ImageView1D instead") ImageView1D ImageReference1D;
 typedef CORRADE_DEPRECATED("use ImageView2D instead") ImageView2D ImageReference2D;
 typedef CORRADE_DEPRECATED("use ImageView3D instead") ImageView3D ImageReference3D;
 #endif
 
+template<UnsignedInt> class CompressedImageView;
+typedef CompressedImageView<1> CompressedImageView1D;
+typedef CompressedImageView<2> CompressedImageView2D;
+typedef CompressedImageView<3> CompressedImageView3D;
+
 enum class MeshPrimitive: GLenum;
 
 class Mesh;
diff --git a/src/Magnum/Test/BufferImageGLTest.cpp b/src/Magnum/Test/BufferImageGLTest.cpp
index 9312f7030..7eedf22b2 100644
--- a/src/Magnum/Test/BufferImageGLTest.cpp
+++ b/src/Magnum/Test/BufferImageGLTest.cpp
@@ -35,18 +35,26 @@ struct BufferImageGLTest: AbstractOpenGLTester {
     explicit BufferImageGLTest();
 
     void construct();
+    void constructCompressed();
     void constructCopy();
+    void constructCopyCompressed();
     void constructMove();
+    void constructMoveCompressed();
 
     void setData();
+    void setDataCompressed();
 };
 
 BufferImageGLTest::BufferImageGLTest() {
     addTests({&BufferImageGLTest::construct,
+              &BufferImageGLTest::constructCompressed,
               &BufferImageGLTest::constructCopy,
+              &BufferImageGLTest::constructCopyCompressed,
               &BufferImageGLTest::constructMove,
+              &BufferImageGLTest::constructMoveCompressed,
 
-              &BufferImageGLTest::setData});
+              &BufferImageGLTest::setData,
+              &BufferImageGLTest::setDataCompressed});
 }
 
 void BufferImageGLTest::construct() {
@@ -70,11 +78,37 @@ void BufferImageGLTest::construct() {
     #endif
 }
 
+void BufferImageGLTest::constructCompressed() {
+    const char data[] = { 'a', 0, 0, 0, 'b', 0, 0, 0 };
+    CompressedBufferImage2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, data, BufferUsage::StaticDraw};
+
+    #ifndef MAGNUM_TARGET_GLES
+    const auto imageData = a.buffer().data();
+    #endif
+
+    MAGNUM_VERIFY_NO_ERROR();
+
+    CORRADE_COMPARE(a.format(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(a.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(a.dataSize(), 8);
+
+    /** @todo How to verify the contents in ES? */
+    #ifndef MAGNUM_TARGET_GLES
+    CORRADE_COMPARE_AS(imageData, Containers::ArrayView<const char>{data},
+                       TestSuite::Compare::Container);
+    #endif
+}
+
 void BufferImageGLTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_constructible<BufferImage2D, const BufferImage2D&>{}));
     CORRADE_VERIFY(!(std::is_assignable<BufferImage2D, const BufferImage2D&>{}));
 }
 
+void BufferImageGLTest::constructCopyCompressed() {
+    CORRADE_VERIFY(!(std::is_constructible<CompressedBufferImage2D, const CompressedBufferImage2D&>{}));
+    CORRADE_VERIFY(!(std::is_assignable<CompressedBufferImage2D, const CompressedBufferImage2D&>{}));
+}
+
 void BufferImageGLTest::constructMove() {
     const char data[4] = { 'a', 'b', 'c', 'd' };
     BufferImage2D a(ColorFormat::Red, ColorType::UnsignedByte, {4, 1}, data, BufferUsage::StaticDraw);
@@ -110,6 +144,43 @@ void BufferImageGLTest::constructMove() {
     CORRADE_COMPARE(c.buffer().id(), id);
 }
 
+void BufferImageGLTest::constructMoveCompressed() {
+    const char data[] = { 'a', 0, 0, 0, 'b', 0, 0, 0 };
+    CompressedBufferImage2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, data, BufferUsage::StaticDraw};
+    const Int id = a.buffer().id();
+
+    MAGNUM_VERIFY_NO_ERROR();
+    CORRADE_VERIFY(id > 0);
+
+    CompressedBufferImage2D b{std::move(a)};
+
+    CORRADE_COMPARE(a.buffer().id(), 0);
+    CORRADE_COMPARE(a.size(), Vector2i());
+    CORRADE_COMPARE(a.dataSize(), 0);
+
+    CORRADE_COMPARE(b.format(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(b.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(b.dataSize(), 8);
+    CORRADE_COMPARE(b.buffer().id(), id);
+
+    const unsigned char data2[] = { 'a', 0, 0, 0, 'b', 0, 0, 0, 'c', 0, 0, 0, 'd', 0, 0, 0 };
+    CompressedBufferImage2D c{CompressedColorFormat::RGBAS3tcDxt1, {8, 4}, data2, BufferUsage::StaticDraw};
+    const Int cId = c.buffer().id();
+    c = std::move(b);
+
+    MAGNUM_VERIFY_NO_ERROR();
+
+    CORRADE_VERIFY(cId > 0);
+    CORRADE_COMPARE(b.buffer().id(), cId);
+    CORRADE_COMPARE(b.size(), Vector2i(8, 4));
+    CORRADE_COMPARE(b.dataSize(), 16);
+
+    CORRADE_COMPARE(c.format(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(c.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(c.dataSize(), 8);
+    CORRADE_COMPARE(c.buffer().id(), id);
+}
+
 void BufferImageGLTest::setData() {
     const char data[4] = { 'a', 'b', 'c', 'd' };
     BufferImage2D a(ColorFormat::Red, ColorType::UnsignedByte, {4, 1}, data, BufferUsage::StaticDraw);
@@ -127,6 +198,30 @@ void BufferImageGLTest::setData() {
     CORRADE_COMPARE(a.type(), ColorType::UnsignedShort);
     CORRADE_COMPARE(a.size(), Vector2i(1, 2));
 
+    /** @todo How to verify the contents in ES? */
+    #ifndef MAGNUM_TARGET_GLES
+    CORRADE_COMPARE_AS(imageData, Containers::ArrayView<const UnsignedShort>{data2},
+                       TestSuite::Compare::Container);
+    #endif
+}
+
+void BufferImageGLTest::setDataCompressed() {
+    const char data[] = { 'a', 0, 0, 0, 'b', 0, 0, 0 };
+    CompressedBufferImage2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, data, BufferUsage::StaticDraw};
+
+    const char data2[] = { 'a', 0, 0, 0, 'b', 0, 0, 0, 'c', 0, 0, 0, 'd', 0, 0, 0 };
+    a.setData(CompressedColorFormat::RGBAS3tcDxt3, {8, 4}, data2, BufferUsage::StaticDraw);
+
+    #ifndef MAGNUM_TARGET_GLES
+    const auto imageData = a.buffer().data();
+    #endif
+
+    MAGNUM_VERIFY_NO_ERROR();
+
+    CORRADE_COMPARE(a.format(), CompressedColorFormat::RGBAS3tcDxt3);
+    CORRADE_COMPARE(a.size(), Vector2i(8, 4));
+    CORRADE_COMPARE(a.dataSize(), 16);
+
     /** @todo How to verify the contents in ES? */
     #ifndef MAGNUM_TARGET_GLES
     CORRADE_COMPARE_AS(imageData, Containers::ArrayView<const char>{data2},
diff --git a/src/Magnum/Test/ImageTest.cpp b/src/Magnum/Test/ImageTest.cpp
index 56eab6fdb..d818c9ae4 100644
--- a/src/Magnum/Test/ImageTest.cpp
+++ b/src/Magnum/Test/ImageTest.cpp
@@ -34,22 +34,34 @@ struct ImageTest: TestSuite::Tester {
     explicit ImageTest();
 
     void construct();
+    void constructCompressed();
     void constructCopy();
+    void constructCopyCompressed();
     void constructMove();
+    void constructMoveCompressed();
 
     void setData();
+    void setDataCompressed();
     void toReference();
+    void toReferenceCommpressed();
     void release();
+    void releaseCompressed();
 };
 
 ImageTest::ImageTest() {
     addTests({&ImageTest::construct,
+              &ImageTest::constructCompressed,
               &ImageTest::constructCopy,
+              &ImageTest::constructCopyCompressed,
               &ImageTest::constructMove,
+              &ImageTest::constructMoveCompressed,
 
               &ImageTest::setData,
+              &ImageTest::setDataCompressed,
               &ImageTest::toReference,
-              &ImageTest::release});
+              &ImageTest::toReferenceCommpressed,
+              &ImageTest::release,
+              &ImageTest::releaseCompressed});
 }
 
 void ImageTest::construct() {
@@ -62,11 +74,26 @@ void ImageTest::construct() {
     CORRADE_COMPARE(a.data(), data);
 }
 
+void ImageTest::constructCompressed() {
+    auto data = new char[8];
+    CompressedImage2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, Containers::Array<char>{data, 8}};
+
+    CORRADE_COMPARE(a.format(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(a.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(a.data(), data);
+    CORRADE_COMPARE(a.data().size(), 8);
+}
+
 void ImageTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_constructible<Image2D, const Image2D&>{}));
     CORRADE_VERIFY(!(std::is_assignable<Image2D, const Image2D&>{}));
 }
 
+void ImageTest::constructCopyCompressed() {
+    CORRADE_VERIFY(!(std::is_constructible<CompressedImage2D, const CompressedImage2D&>{}));
+    CORRADE_VERIFY(!(std::is_assignable<CompressedImage2D, const CompressedImage2D&>{}));
+}
+
 void ImageTest::constructMove() {
     auto data = new char[3];
     Image2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 3}, data);
@@ -93,6 +120,33 @@ void ImageTest::constructMove() {
     CORRADE_COMPARE(c.data(), data);
 }
 
+void ImageTest::constructMoveCompressed() {
+    auto data = new char[8];
+    CompressedImage2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, Containers::Array<char>{data, 8}};
+    CompressedImage2D b{std::move(a)};
+
+    CORRADE_COMPARE(a.data(), nullptr);
+    CORRADE_COMPARE(a.size(), Vector2i());
+
+    CORRADE_COMPARE(b.format(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(b.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(b.data(), data);
+    CORRADE_COMPARE(b.data().size(), 8);
+
+    auto data2 = new char[16];
+    CompressedImage2D c{CompressedColorFormat::RGBAS3tcDxt3, {8, 4}, Containers::Array<char>{data2, 16}};
+    c = std::move(b);
+
+    CORRADE_COMPARE_AS(b.data(), data2, char*);
+    CORRADE_COMPARE(b.data().size(), 16);
+    CORRADE_COMPARE(b.size(), Vector2i(8, 4));
+
+    CORRADE_COMPARE(c.format(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(c.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(c.data(), data);
+    CORRADE_COMPARE(c.data().size(), 8);
+}
+
 void ImageTest::setData() {
     auto data = new char[3];
     Image2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 3}, data);
@@ -105,6 +159,18 @@ void ImageTest::setData() {
     CORRADE_COMPARE(a.data(), data2);
 }
 
+void ImageTest::setDataCompressed() {
+    auto data = new char[8];
+    CompressedImage2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, Containers::Array<char>{data, 8}};
+    auto data2 = new char[16];
+    a.setData(CompressedColorFormat::RGBAS3tcDxt3, {8, 4}, Containers::Array<char>{data2, 16});
+
+    CORRADE_COMPARE(a.format(), CompressedColorFormat::RGBAS3tcDxt3);
+    CORRADE_COMPARE(a.size(), Vector2i(8, 4));
+    CORRADE_COMPARE(a.data(), data2);
+    CORRADE_COMPARE(a.data().size(), 16);
+}
+
 void ImageTest::toReference() {
     auto data = new char[3];
     const Image2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 3}, data);
@@ -125,6 +191,26 @@ void ImageTest::toReference() {
     }
 }
 
+void ImageTest::toReferenceCommpressed() {
+    auto data = new char[8];
+    const CompressedImage2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, Containers::Array<char>{data, 8}};
+    CompressedImageView2D b = a;
+
+    CORRADE_COMPARE(b.format(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(b.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(b.data(), data);
+    CORRADE_COMPARE(b.data().size(), 8);
+
+    CORRADE_VERIFY((std::is_convertible<const CompressedImage2D&, CompressedImageView2D>::value));
+    {
+        #ifdef CORRADE_GCC47_COMPATIBILITY
+        CORRADE_EXPECT_FAIL("Rvalue references for *this are not supported in GCC < 4.8.1.");
+        #endif
+        CORRADE_VERIFY(!(std::is_convertible<const CompressedImage2D, CompressedImageView2D>::value));
+        CORRADE_VERIFY(!(std::is_convertible<const CompressedImage2D&&, CompressedImageView2D>::value));
+    }
+}
+
 void ImageTest::release() {
     char data[] = {'c', 'a', 'f', 'e'};
     Image2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 4}, data);
@@ -135,6 +221,16 @@ void ImageTest::release() {
     CORRADE_COMPARE(a.size(), Vector2i());
 }
 
+void ImageTest::releaseCompressed() {
+    char data[8];
+    CompressedImage2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, Containers::Array<char>{data, 8}};
+    const char* const pointer = a.release().release();
+
+    CORRADE_COMPARE(pointer, data);
+    CORRADE_COMPARE(a.data(), nullptr);
+    CORRADE_COMPARE(a.size(), Vector2i());
+}
+
 }}
 
 CORRADE_TEST_MAIN(Magnum::Test::ImageTest)
diff --git a/src/Magnum/Test/ImageViewTest.cpp b/src/Magnum/Test/ImageViewTest.cpp
index aaeee1575..fcef7c7a2 100644
--- a/src/Magnum/Test/ImageViewTest.cpp
+++ b/src/Magnum/Test/ImageViewTest.cpp
@@ -34,12 +34,18 @@ struct ImageViewTest: TestSuite::Tester {
     explicit ImageViewTest();
 
     void construct();
+    void constructCompressed();
+
     void setData();
+    void setDataCompressed();
 };
 
 ImageViewTest::ImageViewTest() {
     addTests({&ImageViewTest::construct,
-              &ImageViewTest::setData});
+              &ImageViewTest::constructCompressed,
+
+              &ImageViewTest::setData,
+              &ImageViewTest::setDataCompressed});
 }
 
 void ImageViewTest::construct() {
@@ -52,6 +58,15 @@ void ImageViewTest::construct() {
     CORRADE_COMPARE(a.data(), data);
 }
 
+void ImageViewTest::constructCompressed() {
+    const char data[8]{};
+    CompressedImageView2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, data};
+
+    CORRADE_COMPARE(a.format(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(a.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(a.data(), data);
+}
+
 void ImageViewTest::setData() {
     const char data[3]{};
     ImageView2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 3}, data);
@@ -64,6 +79,17 @@ void ImageViewTest::setData() {
     CORRADE_COMPARE(a.data(), data2);
 }
 
+void ImageViewTest::setDataCompressed() {
+    const char data[8]{};
+    CompressedImageView2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, data};
+    const char data2[16]{};
+    a.setData(data2);
+
+    CORRADE_COMPARE(a.format(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(a.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(a.data(), data2);
+}
+
 }}
 
 CORRADE_TEST_MAIN(Magnum::Test::ImageViewTest)
diff --git a/src/Magnum/Trade/ImageData.cpp b/src/Magnum/Trade/ImageData.cpp
new file mode 100644
index 000000000..b0bc02027
--- /dev/null
+++ b/src/Magnum/Trade/ImageData.cpp
@@ -0,0 +1,83 @@
+/*
+    This file is part of Magnum.
+
+    Copyright © 2010, 2011, 2012, 2013, 2014, 2015
+              Vladimír Vondruš <mosra@centrum.cz>
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+*/
+
+#include "ImageData.h"
+
+namespace Magnum { namespace Trade {
+
+template<UnsignedInt dimensions> ColorFormat ImageData<dimensions>::format() const {
+    CORRADE_ASSERT(!_compressed, "Trade::ImageData::format(): the image is compressed", {});
+    return _format;
+}
+
+template<UnsignedInt dimensions> ColorType ImageData<dimensions>::type() const {
+    CORRADE_ASSERT(!_compressed, "Trade::ImageData::type(): the image is compressed", {});
+    return _type;
+}
+
+template<UnsignedInt dimensions> CompressedColorFormat ImageData<dimensions>::compressedFormat() const {
+    CORRADE_ASSERT(_compressed, "Trade::ImageData::format(): the image is not compressed", {});
+    return _compressedFormat;
+}
+
+template<UnsignedInt dimensions> std::size_t ImageData<dimensions>::pixelSize() const {
+    CORRADE_ASSERT(!_compressed, "Trade::ImageData::pixelSize(): the image is compressed", {});
+    return Implementation::imagePixelSize(_format, _type);
+}
+
+template<UnsignedInt dimensions> std::size_t ImageData<dimensions>::dataSize(const VectorTypeFor< dimensions, Int >& size) const {
+    CORRADE_ASSERT(!_compressed, "Trade::ImageData::dataSize(): the image is compressed", {});
+    return Implementation::imageDataSize<dimensions>(*this, _format, _type, size);
+}
+
+template<UnsignedInt dimensions> ImageData<dimensions>::operator ImageView<dimensions>()
+#ifndef CORRADE_GCC47_COMPATIBILITY
+const &
+#else
+const
+#endif
+{
+    CORRADE_ASSERT(!_compressed, "Trade::ImageData::type(): the image is compressed", (ImageView<dimensions>{_format, _type, _size}));
+    return ImageView<dimensions>{_format, _type, _size, _data};
+}
+
+template<UnsignedInt dimensions> ImageData<dimensions>::operator CompressedImageView<dimensions>()
+#ifndef CORRADE_GCC47_COMPATIBILITY
+const &
+#else
+const
+#endif
+{
+    CORRADE_ASSERT(_compressed, "Trade::ImageData::type(): the image is not compressed", (CompressedImageView<dimensions>{_compressedFormat, _size}));
+    return CompressedImageView<dimensions>{_compressedFormat, _size, _data};
+}
+
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template class MAGNUM_EXPORT ImageData<1>;
+template class MAGNUM_EXPORT ImageData<2>;
+template class MAGNUM_EXPORT ImageData<3>;
+#endif
+
+}}
diff --git a/src/Magnum/Trade/ImageData.h b/src/Magnum/Trade/ImageData.h
index 26be30561..584943ca3 100644
--- a/src/Magnum/Trade/ImageData.h
+++ b/src/Magnum/Trade/ImageData.h
@@ -29,6 +29,8 @@
  * @brief Class @ref Magnum::Trade::ImageData, typedef @ref Magnum::Trade::ImageData1D, @ref Magnum::Trade::ImageData2D, @ref Magnum::Trade::ImageData3D
  */
 
+#include <Corrade/Containers/Array.h>
+
 #include "Magnum/ImageView.h"
 
 namespace Magnum { namespace Trade {
@@ -36,18 +38,26 @@ namespace Magnum { namespace Trade {
 /**
 @brief Image data
 
-Access to image data provided by @ref AbstractImporter subclasses.
-Interchangeable with @ref Image, @ref ImageView or @ref BufferImage.
+Access to either uncompressed or compressed image data provided by
+@ref AbstractImporter subclasses, the compression state is distinguished with
+@ref isCompressed(). Uncompressed images have @ref format(), @ref type(),
+@ref pixelSize() and @ref dataSize() properties and are convertible to
+@ref ImageView. Compressed images have just the @ref compressedFormat()
+property and are convertible to @ref CompressedImageView.
+
+Uncompressed image is interchangeable with @ref Image, @ref ImageView or
+@ref BufferImage, compressed with @ref CompressedImage, @ref CompressedImageView
+or @ref CompressedBufferImage.
 @see @ref ImageData1D, @ref ImageData2D, @ref ImageData3D
 */
-template<UnsignedInt dimensions> class ImageData: public AbstractImage {
+template<UnsignedInt dimensions> class ImageData: public AbstractCompressedImage {
     public:
         enum: UnsignedInt {
             Dimensions = dimensions /**< Image dimension count */
         };
 
         /**
-         * @brief Constructor
+         * @brief Construct uncompressed image data
          * @param format            Format of pixel data
          * @param type              Data type of pixel data
          * @param size              Image size
@@ -56,7 +66,18 @@ template<UnsignedInt dimensions> class ImageData: public AbstractImage {
          * Note that the image data are not copied on construction, but they
          * are deleted on class destruction.
          */
-        explicit ImageData(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size, void* data): _format{format}, _type{type}, _size{size}, _data{reinterpret_cast<char*>(data)} {}
+        explicit ImageData(ColorFormat format, ColorType type, const VectorTypeFor<dimensions, Int>& size, void* data): _compressed{false}, _format{format}, _type{type}, _size{size}, _data{reinterpret_cast<char*>(data), dataSize(size)} {}
+
+        /**
+         * @brief Construct compressed image data
+         * @param format            Format of compressed data
+         * @param size              Image size
+         * @param data              Image data
+         *
+         * Note that the image data are not copied on construction, but they
+         * are deleted on class destruction.
+         */
+        explicit ImageData(CompressedColorFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data): _compressed{true}, _compressedFormat{format}, _size{size}, _data{std::move(data)} {}
 
         /** @brief Copying is not allowed */
         ImageData(const ImageData<dimensions>&) = delete;
@@ -70,10 +91,15 @@ template<UnsignedInt dimensions> class ImageData: public AbstractImage {
         /** @brief Move assignment */
         ImageData<dimensions>& operator=(ImageData<dimensions>&& other) noexcept;
 
-        /** @brief Destructor */
-        ~ImageData() { delete[] _data; }
+        /** @brief Whether the image is compressed */
+        bool isCompressed() const { return _compressed; }
 
-        /** @brief Conversion to view */
+        /**
+         * @brief Conversion to view
+         *
+         * The image is expected to be uncompressed.
+         * @see @ref isCompressed()
+         */
         /*implicit*/ operator ImageView<dimensions>()
         #ifndef CORRADE_GCC47_COMPATIBILITY
         const &;
@@ -86,35 +112,86 @@ template<UnsignedInt dimensions> class ImageData: public AbstractImage {
         /*implicit*/ operator ImageView<dimensions>() const && = delete;
         #endif
 
-        /** @brief Format of pixel data */
-        ColorFormat format() const { return _format; }
+        /**
+         * @brief Conversion to compressed view
+         *
+         * The image is expected to be compressed.
+         * @see @ref isCompressed()
+         */
+        /*implicit*/ operator CompressedImageView<dimensions>()
+        #ifndef CORRADE_GCC47_COMPATIBILITY
+        const &;
+        #else
+        const;
+        #endif
 
-        /** @brief Data type of pixel data */
-        ColorType type() const { return _type; }
+        #ifndef CORRADE_GCC47_COMPATIBILITY
+        /** @overload */
+        /*implicit*/ operator CompressedImageView<dimensions>() const && = delete;
+        #endif
 
-        /** @brief Pixel size (in bytes) */
-        std::size_t pixelSize() const { return Implementation::imagePixelSize(_format, _type); }
+        /**
+         * @brief Format of pixel data
+         *
+         * The image is expected to be uncompressed.
+         * @see @ref isCompressed()
+         */
+        ColorFormat format() const;
+
+        /**
+         * @brief Data type of pixel data
+         *
+         * The image is expected to be uncompressed.
+         * @see @ref isCompressed()
+         */
+        ColorType type() const;
+
+        /**
+         * @brief Format of compressed data
+         *
+         * The image is expected to be compressed.
+         * @see @ref isCompressed()
+         */
+        CompressedColorFormat compressedFormat() const;
+
+        /**
+         * @brief Pixel size (in bytes)
+         *
+         * The image is expected to be uncompressed.
+         * @see @ref isCompressed()
+         */
+        std::size_t pixelSize() const;
 
         /** @brief Image size */
         VectorTypeFor<dimensions, Int> size() const { return _size; }
 
-        /** @copydoc Image::dataSize() */
-        std::size_t dataSize(const VectorTypeFor<dimensions, Int>& size) const {
-            return Implementation::imageDataSize<dimensions>(*this, _format, _type, size);
-        }
+        /**
+         * @brief Size of data required to store uncompressed image of given size
+         *
+         * The image is expected to be uncompressed. Takes color format, type
+         * and row alignment of this image into account.
+         * @see @ref isCompressed(), @ref pixelSize()
+         */
+        std::size_t dataSize(const VectorTypeFor<dimensions, Int>& size) const;
+
+        /** @brief Raw data */
+        Containers::ArrayView<char> data() { return _data; }
+
+        /** @overload */
+        Containers::ArrayView<const char> data() const { return _data; }
 
         /**
          * @brief Pointer to raw data
          *
          * @see @ref release()
          */
-        template<class T = char> T* data() {
-            return reinterpret_cast<T*>(_data);
+        template<class T> T* data() {
+            return reinterpret_cast<T*>(_data.data());
         }
 
         /** @overload */
-        template<class T = char> const T* data() const {
-            return reinterpret_cast<const T*>(_data);
+        template<class T> const T* data() const {
+            return reinterpret_cast<const T*>(_data.data());
         }
 
         /**
@@ -124,13 +201,17 @@ template<UnsignedInt dimensions> class ImageData: public AbstractImage {
          * to default. Deleting the returned array is then user responsibility.
          * @see @ref data()
          */
-        char* release();
+        Containers::Array<char> release();
 
     private:
-        ColorFormat _format;
+        bool _compressed;
+        union {
+            ColorFormat _format;
+            CompressedColorFormat _compressedFormat;
+        };
         ColorType _type;
         Math::Vector<Dimensions, Int> _size;
-        char* _data;
+        Containers::Array<char> _data;
 };
 
 /** @brief One-dimensional image */
@@ -142,34 +223,28 @@ typedef ImageData<2> ImageData2D;
 /** @brief Three-dimensional image */
 typedef ImageData<3> ImageData3D;
 
-template<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(ImageData<dimensions>&& other) noexcept: AbstractImage{std::move(other)}, _format{std::move(other._format)}, _type{std::move(other._type)}, _size{std::move(other._size)}, _data{std::move(other._data)} {
+template<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(ImageData<dimensions>&& other) noexcept: AbstractCompressedImage{std::move(other)}, _compressed{std::move(other._compressed)}, _type{std::move(other._type)}, _size{std::move(other._size)}, _data{std::move(other._data)} {
+    if(_compressed) _compressedFormat = std::move(other._compressedFormat);
+    else _format = std::move(other._format);
+
     other._size = {};
     other._data = nullptr;
 }
 
 template<UnsignedInt dimensions> inline ImageData<dimensions>& ImageData<dimensions>::operator=(ImageData<dimensions>&& other) noexcept {
-    AbstractImage::operator=(std::move(other));
+    AbstractCompressedImage::operator=(std::move(other));
     using std::swap;
-    swap(_format, other._format);
+    swap(_compressed, other._compressed);
+    if(_compressed) swap(_compressedFormat, other._compressedFormat);
+    else swap(_format, other._format);
     swap(_type, other._type);
     swap(_size, other._size);
     swap(_data, other._data);
     return *this;
 }
 
-template<UnsignedInt dimensions> inline ImageData<dimensions>::operator ImageView<dimensions>()
-#ifndef CORRADE_GCC47_COMPATIBILITY
-const &
-#else
-const
-#endif
-{
-    return ImageView<dimensions>(_format, _type, _size, _data);
-}
-
-template<UnsignedInt dimensions> inline char* ImageData<dimensions>::release() {
-    /** @todo I need `std::exchange` NOW. */
-    char* const data = _data;
+template<UnsignedInt dimensions> inline Containers::Array<char> ImageData<dimensions>::release() {
+    Containers::Array<char> data{std::move(_data)};
     _size = {};
     _data = nullptr;
     return data;
diff --git a/src/Magnum/Trade/Test/ImageDataTest.cpp b/src/Magnum/Trade/Test/ImageDataTest.cpp
index 257b03c92..ca2140249 100644
--- a/src/Magnum/Trade/Test/ImageDataTest.cpp
+++ b/src/Magnum/Trade/Test/ImageDataTest.cpp
@@ -35,32 +35,52 @@ class ImageDataTest: public TestSuite::Tester {
         explicit ImageDataTest();
 
         void construct();
+        void constructCompressed();
         void constructCopy();
         void constructMove();
+        void constructMoveCompressed();
 
         void toReference();
+        void toReferenceCompressed();
         void release();
+        void releaseCompressed();
 };
 
 ImageDataTest::ImageDataTest() {
     addTests({&ImageDataTest::construct,
+              &ImageDataTest::constructCompressed,
               &ImageDataTest::constructCopy,
               &ImageDataTest::constructMove,
+              &ImageDataTest::constructMoveCompressed,
 
               &ImageDataTest::toReference,
-              &ImageDataTest::release});
+              &ImageDataTest::toReferenceCompressed,
+              &ImageDataTest::release,
+              &ImageDataTest::releaseCompressed});
 }
 
 void ImageDataTest::construct() {
     auto data = new char[3];
     Trade::ImageData2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 3}, data);
 
+    CORRADE_VERIFY(!a.isCompressed());
     CORRADE_COMPARE(a.format(), ColorFormat::Red);
     CORRADE_COMPARE(a.type(), ColorType::UnsignedByte);
     CORRADE_COMPARE(a.size(), Vector2i(1, 3));
     CORRADE_COMPARE(a.data(), data);
 }
 
+void ImageDataTest::constructCompressed() {
+    auto data = new char[8];
+    Trade::ImageData2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, Containers::Array<char>{data, 8}};
+
+    CORRADE_VERIFY(a.isCompressed());
+    CORRADE_COMPARE(a.compressedFormat(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(a.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(a.data(), data);
+    CORRADE_COMPARE(a.data().size(), 8);
+}
+
 void ImageDataTest::constructCopy() {
     CORRADE_VERIFY(!(std::is_constructible<Trade::ImageData2D, const Trade::ImageData2D&>{}));
     CORRADE_VERIFY(!(std::is_assignable<Trade::ImageData2D, const Trade::ImageData2D&>{}));
@@ -74,6 +94,7 @@ void ImageDataTest::constructMove() {
     CORRADE_COMPARE(a.data(), nullptr);
     CORRADE_COMPARE(a.size(), Vector2i());
 
+    CORRADE_VERIFY(!b.isCompressed());
     CORRADE_COMPARE(b.format(), ColorFormat::Red);
     CORRADE_COMPARE(b.type(), ColorType::UnsignedByte);
     CORRADE_COMPARE(b.size(), Vector2i(1, 3));
@@ -86,12 +107,42 @@ void ImageDataTest::constructMove() {
     CORRADE_COMPARE(b.data(), data2);
     CORRADE_COMPARE(b.size(), Vector2i(2, 6));
 
+    CORRADE_VERIFY(!c.isCompressed());
     CORRADE_COMPARE(c.format(), ColorFormat::Red);
     CORRADE_COMPARE(c.type(), ColorType::UnsignedByte);
     CORRADE_COMPARE(c.size(), Vector2i(1, 3));
     CORRADE_COMPARE(c.data(), data);
 }
 
+void ImageDataTest::constructMoveCompressed() {
+    auto data = new char[8];
+    Trade::ImageData2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, Containers::Array<char>{data, 8}};
+    Trade::ImageData2D b{std::move(a)};
+
+    CORRADE_COMPARE(a.data(), nullptr);
+    CORRADE_COMPARE(a.size(), Vector2i());
+
+    CORRADE_VERIFY(b.isCompressed());
+    CORRADE_COMPARE(b.compressedFormat(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(b.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(b.data(), data);
+    CORRADE_COMPARE(b.data().size(), 8);
+
+    auto data2 = new char[16];
+    Trade::ImageData2D c{CompressedColorFormat::RGBAS3tcDxt3, {8, 4}, Containers::Array<char>{data2, 16}};
+    c = std::move(b);
+
+    CORRADE_COMPARE_AS(b.data(), data2, char*);
+    CORRADE_COMPARE(b.data().size(), 16);
+    CORRADE_COMPARE(b.size(), Vector2i(8, 4));
+
+    CORRADE_VERIFY(c.isCompressed());
+    CORRADE_COMPARE(c.compressedFormat(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(c.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(c.data(), data);
+    CORRADE_COMPARE(c.data().size(), 8);
+}
+
 void ImageDataTest::toReference() {
     auto data = new char[3];
     const Trade::ImageData2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 3}, data);
@@ -112,10 +163,40 @@ void ImageDataTest::toReference() {
     }
 }
 
+void ImageDataTest::toReferenceCompressed() {
+    auto data = new char[8];
+    const Trade::ImageData2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, Containers::Array<char>{data, 8}};
+    CompressedImageView2D b = a;
+
+    CORRADE_COMPARE(b.format(), CompressedColorFormat::RGBAS3tcDxt1);
+    CORRADE_COMPARE(b.size(), Vector2i(4, 4));
+    CORRADE_COMPARE(b.data(), data);
+    CORRADE_COMPARE(b.data().size(), 8);
+
+    CORRADE_VERIFY((std::is_convertible<const Trade::ImageData2D&, CompressedImageView2D>::value));
+    {
+        #ifdef CORRADE_GCC47_COMPATIBILITY
+        CORRADE_EXPECT_FAIL("Rvalue references for *this are not supported in GCC < 4.8.1.");
+        #endif
+        CORRADE_VERIFY(!(std::is_convertible<const Trade::ImageData2D, CompressedImageView2D>::value));
+        CORRADE_VERIFY(!(std::is_convertible<const Trade::ImageData2D&&, CompressedImageView2D>::value));
+    }
+}
+
 void ImageDataTest::release() {
     char data[] = {'b', 'e', 'e', 'r'};
     Trade::ImageData2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 4}, data);
-    const char* const pointer = a.release();
+    const char* const pointer = a.release().release();
+
+    CORRADE_COMPARE(pointer, data);
+    CORRADE_COMPARE(a.data(), nullptr);
+    CORRADE_COMPARE(a.size(), Vector2i());
+}
+
+void ImageDataTest::releaseCompressed() {
+    char data[8];
+    Trade::ImageData2D a{CompressedColorFormat::RGBAS3tcDxt1, {4, 4}, Containers::Array<char>{data, 8}};
+    const char* const pointer = a.release().release();
 
     CORRADE_COMPARE(pointer, data);
     CORRADE_COMPARE(a.data(), nullptr);