diff --git a/src/Magnum/Image.cpp b/src/Magnum/Image.cpp
index 98c9cadf3..163ba5640 100644
--- a/src/Magnum/Image.cpp
+++ b/src/Magnum/Image.cpp
@@ -27,7 +27,7 @@
 
 namespace Magnum {
 
-template<UnsignedInt dimensions> Image<dimensions>::Image(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data): _storage{storage}, _format{format}, _type{type}, _size{size}, _data{std::move(data)} {
+template<UnsignedInt dimensions> Image<dimensions>::Image(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept: _storage{storage}, _format{format}, _type{type}, _size{size}, _data{std::move(data)} {
     CORRADE_ASSERT(Implementation::imageDataSize(*this) <= _data.size(), "Image::Image(): bad image data size, got" << _data.size() << "but expected at least" << Implementation::imageDataSize(*this), );
 }
 
diff --git a/src/Magnum/Image.h b/src/Magnum/Image.h
index c62379a44..4bbbfdbe0 100644
--- a/src/Magnum/Image.h
+++ b/src/Magnum/Image.h
@@ -59,19 +59,19 @@ template<UnsignedInt dimensions> class Image {
          * The data are expected to be of proper size for given @p storage
          * parameters.
          */
-        explicit Image(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data);
+        explicit Image(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept;
 
         /** @overload
          * Similar to the above, but uses default @ref PixelStorage parameters.
          */
-        explicit Image(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data): Image{{}, format, type, size, std::move(data)} {}
+        explicit Image(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept: Image{{}, format, type, size, std::move(data)} {}
 
         #ifdef MAGNUM_BUILD_DEPRECATED
         /** @copybrief Image(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&)
          * @deprecated Use @ref Image(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&)
          *      instead.
          */
-        explicit CORRADE_DEPRECATED("use Image(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) instead") Image(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, void* data): Image{{}, format, type, size, Containers::Array<char>{reinterpret_cast<char*>(data), Implementation::imageDataSizeFor(format, type, size)}} {}
+        explicit CORRADE_DEPRECATED("use Image(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) instead") Image(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, void* data) noexcept: Image{{}, format, type, size, Containers::Array<char>{reinterpret_cast<char*>(data), Implementation::imageDataSizeFor(format, type, size)}} {}
         #endif
 
         /**
@@ -87,12 +87,12 @@ template<UnsignedInt dimensions> class Image {
          * @ref AbstractFramebuffer::read() "*Framebuffer::read()" to fill the
          * image with data using @p storage settings.
          */
-        /*implicit*/ Image(PixelStorage storage, PixelFormat format, PixelType type): _storage{storage}, _format{format}, _type{type}, _data{} {}
+        /*implicit*/ Image(PixelStorage storage, PixelFormat format, PixelType type) noexcept: _storage{storage}, _format{format}, _type{type}, _data{} {}
 
         /** @overload
          * Similar to the above, but uses default @ref PixelStorage parameters.
          */
-        /*implicit*/ Image(PixelFormat format, PixelType type): Image{{}, format, type} {}
+        /*implicit*/ Image(PixelFormat format, PixelType type) noexcept: Image{{}, format, type} {}
 
         /** @brief Copying is not allowed */
         Image(const Image<dimensions>&) = delete;
diff --git a/src/Magnum/Trade/AbstractMaterialData.cpp b/src/Magnum/Trade/AbstractMaterialData.cpp
index 029004074..9f9b33d9a 100644
--- a/src/Magnum/Trade/AbstractMaterialData.cpp
+++ b/src/Magnum/Trade/AbstractMaterialData.cpp
@@ -29,7 +29,7 @@
 
 namespace Magnum { namespace Trade {
 
-AbstractMaterialData::AbstractMaterialData(const MaterialType type, const void* const importerState): _type{type}, _importerState{importerState} {}
+AbstractMaterialData::AbstractMaterialData(const MaterialType type, const void* const importerState) noexcept: _type{type}, _importerState{importerState} {}
 
 AbstractMaterialData::~AbstractMaterialData() {}
 
diff --git a/src/Magnum/Trade/AbstractMaterialData.h b/src/Magnum/Trade/AbstractMaterialData.h
index 894d10ea2..1472165bd 100644
--- a/src/Magnum/Trade/AbstractMaterialData.h
+++ b/src/Magnum/Trade/AbstractMaterialData.h
@@ -50,27 +50,19 @@ Subclasses provide access to parameters for given material type.
 */
 class MAGNUM_EXPORT AbstractMaterialData {
     public:
-        /**
-         * @brief Constructor
-         * @param type              Material type
-         * @param importerState     Importer-specific state
-         */
-        explicit AbstractMaterialData(MaterialType type, const void* importerState = nullptr);
-
-        /** @brief Destructor */
-        virtual ~AbstractMaterialData() = 0;
+        virtual ~AbstractMaterialData();
 
         /** @brief Copying is not allowed */
         AbstractMaterialData(const AbstractMaterialData&) = delete;
 
         /** @brief Move constructor */
-        AbstractMaterialData(AbstractMaterialData&&) = default;
+        AbstractMaterialData(AbstractMaterialData&&) noexcept = default;
 
         /** @brief Copying is not allowed */
         AbstractMaterialData& operator=(const AbstractMaterialData&) = delete;
 
         /** @brief Move assignment */
-        AbstractMaterialData& operator=(AbstractMaterialData&&) = default;
+        AbstractMaterialData& operator=(AbstractMaterialData&&) noexcept = default;
 
         /** @brief Material type */
         MaterialType type() const { return _type; }
@@ -82,6 +74,14 @@ class MAGNUM_EXPORT AbstractMaterialData {
          */
         const void* importerState() const { return _importerState; }
 
+    protected:
+        /**
+         * @brief Constructor
+         * @param type              Material type
+         * @param importerState     Importer-specific state
+         */
+        explicit AbstractMaterialData(MaterialType type, const void* importerState = nullptr) noexcept;
+
     private:
         MaterialType _type;
         const void* _importerState;
diff --git a/src/Magnum/Trade/ImageData.cpp b/src/Magnum/Trade/ImageData.cpp
index 587685009..f94b914f9 100644
--- a/src/Magnum/Trade/ImageData.cpp
+++ b/src/Magnum/Trade/ImageData.cpp
@@ -27,7 +27,7 @@
 
 namespace Magnum { namespace Trade {
 
-template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const PixelStorage storage, const PixelFormat format, const PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState): _compressed{false}, _storage{storage}, _format{format}, _type{type}, _size{size}, _data{std::move(data)}, _importerState{importerState} {
+template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const PixelStorage storage, const PixelFormat format, const PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: _compressed{false}, _storage{storage}, _format{format}, _type{type}, _size{size}, _data{std::move(data)}, _importerState{importerState} {
     CORRADE_ASSERT(Implementation::imageDataSize(*this) <= _data.size(), "Trade::ImageData::ImageData(): bad image data size, got" << _data.size() << "but expected at least" << Implementation::imageDataSize(*this), );
 }
 
diff --git a/src/Magnum/Trade/ImageData.h b/src/Magnum/Trade/ImageData.h
index 28f53005c..fc38a63bc 100644
--- a/src/Magnum/Trade/ImageData.h
+++ b/src/Magnum/Trade/ImageData.h
@@ -68,18 +68,18 @@ template<UnsignedInt dimensions> class ImageData {
          * The data are expected to be of proper size for given @p storage
          * parameters.
          */
-        explicit ImageData(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr);
+        explicit ImageData(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr) noexcept;
 
         /** @overload
          * Similar to the above, but uses default @ref PixelStorage parameters.
          */
-        explicit ImageData(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr): ImageData{{}, format, type, size, std::move(data), importerState} {}
+        explicit ImageData(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr) noexcept: ImageData{{}, format, type, size, std::move(data), importerState} {}
 
         #ifdef MAGNUM_BUILD_DEPRECATED
         /** @copybrief ImageData(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, const void*)
          * @deprecated Use @ref ImageData(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, const void*) instead.
          */
-        explicit CORRADE_DEPRECATED("use ImageData(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) instead") ImageData(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, void* data): ImageData{format, type, size, Containers::Array<char>{reinterpret_cast<char*>(data), Magnum::Implementation::imageDataSizeFor(format, type, size)}} {}
+        explicit CORRADE_DEPRECATED("use ImageData(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) instead") ImageData(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, void* data) noexcept: ImageData{format, type, size, Containers::Array<char>{reinterpret_cast<char*>(data), Magnum::Implementation::imageDataSizeFor(format, type, size)}} {}
         #endif
 
         #ifndef MAGNUM_TARGET_GLES
@@ -97,7 +97,7 @@ template<UnsignedInt dimensions> class ImageData {
          * @requires_gl Compressed pixel storage is hardcoded in OpenGL ES and
          *      WebGL.
          */
-        explicit ImageData(CompressedPixelStorage storage, CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr);
+        explicit ImageData(CompressedPixelStorage storage, CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr) noexcept;
         #endif
 
         /**
@@ -110,7 +110,7 @@ template<UnsignedInt dimensions> class ImageData {
          * Similar the above, but uses default @ref CompressedPixelStorage
          * parameters (or the hardcoded ones in OpenGL ES and WebGL).
          */
-        explicit ImageData(CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr);
+        explicit ImageData(CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr) noexcept;
 
         /** @brief Copying is not allowed */
         ImageData(const ImageData<dimensions>&) = delete;
@@ -297,14 +297,14 @@ template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(
     #ifndef MAGNUM_TARGET_GLES
     const CompressedPixelStorage storage,
     #endif
-    const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState): _compressed{true},
+    const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState) noexcept: _compressed{true},
     #ifndef MAGNUM_TARGET_GLES
     _compressedStorage{storage},
     #endif
     _compressedFormat{format}, _size{size}, _data{std::move(data)}, _importerState{importerState} {}
 
 #ifndef MAGNUM_TARGET_GLES
-template<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState): ImageData{{}, format, size, std::move(data), importerState} {}
+template<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: ImageData{{}, format, size, std::move(data), importerState} {}
 #endif
 
 template<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(ImageData<dimensions>&& other) noexcept: _compressed{std::move(other._compressed)}, _size{std::move(other._size)}, _data{std::move(other._data)}, _importerState{std::move(other._importerState)} {
diff --git a/src/Magnum/Trade/MeshData2D.cpp b/src/Magnum/Trade/MeshData2D.cpp
index 0793d63a3..4333e8ee2 100644
--- a/src/Magnum/Trade/MeshData2D.cpp
+++ b/src/Magnum/Trade/MeshData2D.cpp
@@ -33,11 +33,11 @@ MeshData2D::MeshData2D(const MeshPrimitive primitive, std::vector<UnsignedInt> i
     CORRADE_ASSERT(!_positions.empty(), "Trade::MeshData2D: no position array specified", );
 }
 
-MeshData2D::MeshData2D(MeshData2D&&) = default;
+MeshData2D::MeshData2D(MeshData2D&&) noexcept = default;
 
 MeshData2D::~MeshData2D() = default;
 
-MeshData2D& MeshData2D::operator=(MeshData2D&&) = default;
+MeshData2D& MeshData2D::operator=(MeshData2D&&) noexcept = default;
 
 std::vector<UnsignedInt>& MeshData2D::indices() {
     CORRADE_ASSERT(isIndexed(), "Trade::MeshData2D::indices(): the mesh is not indexed", _indices);
diff --git a/src/Magnum/Trade/MeshData2D.h b/src/Magnum/Trade/MeshData2D.h
index 69946251f..bfb566f65 100644
--- a/src/Magnum/Trade/MeshData2D.h
+++ b/src/Magnum/Trade/MeshData2D.h
@@ -62,7 +62,7 @@ class MAGNUM_EXPORT MeshData2D {
         MeshData2D(const MeshData2D&) = delete;
 
         /** @brief Move constructor */
-        MeshData2D(MeshData2D&&);
+        MeshData2D(MeshData2D&&) noexcept;
 
         ~MeshData2D();
 
@@ -70,7 +70,7 @@ class MAGNUM_EXPORT MeshData2D {
         MeshData2D& operator=(const MeshData2D&) = delete;
 
         /** @brief Move assignment */
-        MeshData2D& operator=(MeshData2D&&);
+        MeshData2D& operator=(MeshData2D&&) noexcept;
 
         /** @brief Primitive */
         MeshPrimitive primitive() const { return _primitive; }
diff --git a/src/Magnum/Trade/MeshData3D.cpp b/src/Magnum/Trade/MeshData3D.cpp
index 393584993..549e23311 100644
--- a/src/Magnum/Trade/MeshData3D.cpp
+++ b/src/Magnum/Trade/MeshData3D.cpp
@@ -33,11 +33,11 @@ MeshData3D::MeshData3D(const MeshPrimitive primitive, std::vector<UnsignedInt> i
     CORRADE_ASSERT(!_positions.empty(), "Trade::MeshData3D: no position array specified", );
 }
 
-MeshData3D::MeshData3D(MeshData3D&&) = default;
+MeshData3D::MeshData3D(MeshData3D&&) noexcept = default;
 
 MeshData3D::~MeshData3D() = default;
 
-MeshData3D& MeshData3D::operator=(MeshData3D&&) = default;
+MeshData3D& MeshData3D::operator=(MeshData3D&&) noexcept = default;
 
 std::vector<UnsignedInt>& MeshData3D::indices() {
     CORRADE_ASSERT(isIndexed(), "Trade::MeshData3D::indices(): the mesh is not indexed", _indices);
diff --git a/src/Magnum/Trade/MeshData3D.h b/src/Magnum/Trade/MeshData3D.h
index 060f78bdd..eb3fea4c5 100644
--- a/src/Magnum/Trade/MeshData3D.h
+++ b/src/Magnum/Trade/MeshData3D.h
@@ -63,7 +63,7 @@ class MAGNUM_EXPORT MeshData3D {
         MeshData3D(const MeshData3D&) = delete;
 
         /** @brief Move constructor */
-        MeshData3D(MeshData3D&&);
+        MeshData3D(MeshData3D&&) noexcept;
 
         ~MeshData3D();
 
@@ -71,7 +71,7 @@ class MAGNUM_EXPORT MeshData3D {
         MeshData3D& operator=(const MeshData3D&) = delete;
 
         /** @brief Move assignment */
-        MeshData3D& operator=(MeshData3D&&);
+        MeshData3D& operator=(MeshData3D&&) noexcept;
 
         /** @brief Primitive */
         MeshPrimitive primitive() const { return _primitive; }
diff --git a/src/Magnum/Trade/MeshObjectData2D.h b/src/Magnum/Trade/MeshObjectData2D.h
index 26dad47c5..f103fd10e 100644
--- a/src/Magnum/Trade/MeshObjectData2D.h
+++ b/src/Magnum/Trade/MeshObjectData2D.h
@@ -57,13 +57,13 @@ class MAGNUM_EXPORT MeshObjectData2D: public ObjectData2D {
         MeshObjectData2D(const MeshObjectData2D&) = delete;
 
         /** @brief Move constructor */
-        MeshObjectData2D(MeshObjectData2D&&) = default;
+        MeshObjectData2D(MeshObjectData2D&&) noexcept = default;
 
         /** @brief Copying is not allowed */
         MeshObjectData2D& operator=(const MeshObjectData2D&) = delete;
 
         /** @brief Move assignment */
-        MeshObjectData2D& operator=(MeshObjectData2D&&) = default;
+        MeshObjectData2D& operator=(MeshObjectData2D&&) noexcept = default;
 
         /**
          * @brief Material ID
diff --git a/src/Magnum/Trade/MeshObjectData3D.h b/src/Magnum/Trade/MeshObjectData3D.h
index 305b74d36..082e75166 100644
--- a/src/Magnum/Trade/MeshObjectData3D.h
+++ b/src/Magnum/Trade/MeshObjectData3D.h
@@ -57,13 +57,13 @@ class MAGNUM_EXPORT MeshObjectData3D: public ObjectData3D {
         MeshObjectData3D(const MeshObjectData3D&) = delete;
 
         /** @brief Move constructor */
-        MeshObjectData3D(MeshObjectData3D&&) = default;
+        MeshObjectData3D(MeshObjectData3D&&) noexcept = default;
 
         /** @brief Copying is not allowed */
         MeshObjectData3D& operator=(const MeshObjectData3D&) = delete;
 
         /** @brief Move assignment */
-        MeshObjectData3D& operator=(MeshObjectData3D&&) = default;
+        MeshObjectData3D& operator=(MeshObjectData3D&&) noexcept = default;
 
         /**
          * @brief Material ID
diff --git a/src/Magnum/Trade/ObjectData2D.cpp b/src/Magnum/Trade/ObjectData2D.cpp
index 52926b3ba..8ec678f35 100644
--- a/src/Magnum/Trade/ObjectData2D.cpp
+++ b/src/Magnum/Trade/ObjectData2D.cpp
@@ -31,11 +31,11 @@ ObjectData2D::ObjectData2D(std::vector<UnsignedInt> children, const Matrix3& tra
 
 ObjectData2D::ObjectData2D(std::vector<UnsignedInt> children, const Matrix3& transformation, const void* const importerState): _children{std::move(children)}, _transformation{transformation}, _instanceType{ObjectInstanceType2D::Empty}, _instance{-1}, _importerState{importerState} {}
 
-ObjectData2D::ObjectData2D(ObjectData2D&&) = default;
+ObjectData2D::ObjectData2D(ObjectData2D&&) noexcept = default;
 
 ObjectData2D::~ObjectData2D() = default;
 
-ObjectData2D& ObjectData2D::operator=(ObjectData2D&&) = default;
+ObjectData2D& ObjectData2D::operator=(ObjectData2D&&) noexcept = default;
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 Debug& operator<<(Debug& debug, ObjectInstanceType2D value) {
diff --git a/src/Magnum/Trade/ObjectData2D.h b/src/Magnum/Trade/ObjectData2D.h
index 01b3cd2b2..896e7fff0 100644
--- a/src/Magnum/Trade/ObjectData2D.h
+++ b/src/Magnum/Trade/ObjectData2D.h
@@ -83,7 +83,7 @@ class MAGNUM_EXPORT ObjectData2D {
         ObjectData2D(const ObjectData2D&) = delete;
 
         /** @brief Move constructor */
-        ObjectData2D(ObjectData2D&&);
+        ObjectData2D(ObjectData2D&&) noexcept;
 
         /** @brief Destructor */
         virtual ~ObjectData2D();
@@ -92,7 +92,7 @@ class MAGNUM_EXPORT ObjectData2D {
         ObjectData2D& operator=(const ObjectData2D&) = delete;
 
         /** @brief Move assignment */
-        ObjectData2D& operator=(ObjectData2D&&);
+        ObjectData2D& operator=(ObjectData2D&&) noexcept;
 
         /** @brief Child objects */
         std::vector<UnsignedInt>& children() { return _children; }
diff --git a/src/Magnum/Trade/ObjectData3D.cpp b/src/Magnum/Trade/ObjectData3D.cpp
index d9d1d038e..900156383 100644
--- a/src/Magnum/Trade/ObjectData3D.cpp
+++ b/src/Magnum/Trade/ObjectData3D.cpp
@@ -31,11 +31,11 @@ ObjectData3D::ObjectData3D(std::vector<UnsignedInt> children, const Matrix4& tra
 
 ObjectData3D::ObjectData3D(std::vector<UnsignedInt> children, const Matrix4& transformation, const void* const importerState): _children{std::move(children)}, _transformation{transformation}, _instanceType{ObjectInstanceType3D::Empty}, _instance{-1}, _importerState{importerState} {}
 
-ObjectData3D::ObjectData3D(ObjectData3D&&) = default;
+ObjectData3D::ObjectData3D(ObjectData3D&&) noexcept = default;
 
 ObjectData3D::~ObjectData3D() = default;
 
-ObjectData3D& ObjectData3D::operator=(ObjectData3D&&) = default;
+ObjectData3D& ObjectData3D::operator=(ObjectData3D&&) noexcept = default;
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 Debug& operator<<(Debug& debug, ObjectInstanceType3D value) {
diff --git a/src/Magnum/Trade/ObjectData3D.h b/src/Magnum/Trade/ObjectData3D.h
index 382615bc1..b2aea9419 100644
--- a/src/Magnum/Trade/ObjectData3D.h
+++ b/src/Magnum/Trade/ObjectData3D.h
@@ -85,7 +85,7 @@ class MAGNUM_EXPORT ObjectData3D {
         ObjectData3D(const ObjectData3D&) = delete;
 
         /** @brief Move constructor */
-        ObjectData3D(ObjectData3D&&);
+        ObjectData3D(ObjectData3D&&) noexcept;
 
         /** @brief Destructor */
         virtual ~ObjectData3D();
@@ -94,7 +94,7 @@ class MAGNUM_EXPORT ObjectData3D {
         ObjectData3D& operator=(const ObjectData3D&) = delete;
 
         /** @brief Move assignment */
-        ObjectData3D& operator=(ObjectData3D&&);
+        ObjectData3D& operator=(ObjectData3D&&) noexcept;
 
         /** @brief Child objects */
         std::vector<UnsignedInt>& children() { return _children; }
diff --git a/src/Magnum/Trade/PhongMaterialData.h b/src/Magnum/Trade/PhongMaterialData.h
index dee266602..2b076b2e4 100644
--- a/src/Magnum/Trade/PhongMaterialData.h
+++ b/src/Magnum/Trade/PhongMaterialData.h
@@ -73,7 +73,7 @@ class MAGNUM_EXPORT PhongMaterialData: public AbstractMaterialData {
          * Colors and textures should be specified using member functions based
          * on what flags are set.
          */
-        explicit PhongMaterialData(Flags flags, Float shininess, const void* importerState = nullptr): AbstractMaterialData{MaterialType::Phong, importerState}, _shininess{shininess}, _flags{flags} {}
+        explicit PhongMaterialData(Flags flags, Float shininess, const void* importerState = nullptr) noexcept: AbstractMaterialData{MaterialType::Phong, importerState}, _flags{flags}, _shininess{shininess} {}
 
         /** @brief Material flags */
         Flags flags() const { return _flags; }
@@ -139,15 +139,15 @@ class MAGNUM_EXPORT PhongMaterialData: public AbstractMaterialData {
         union Source {
             Source() {}
 
-            Vector3 color;
+            Color3 color;
             UnsignedInt texture;
         };
 
+        Flags _flags;
+        Float _shininess;
         Source _ambient,
             _diffuse,
             _specular;
-        Float _shininess;
-        Flags _flags;
 };
 
 CORRADE_ENUMSET_OPERATORS(PhongMaterialData::Flags)
diff --git a/src/Magnum/Trade/SceneData.cpp b/src/Magnum/Trade/SceneData.cpp
index f00726a0b..b51449f91 100644
--- a/src/Magnum/Trade/SceneData.cpp
+++ b/src/Magnum/Trade/SceneData.cpp
@@ -29,8 +29,8 @@ namespace Magnum { namespace Trade {
 
 SceneData::SceneData(std::vector<UnsignedInt> children2D, std::vector<UnsignedInt> children3D, const void* const importerState): _children2D{std::move(children2D)}, _children3D{std::move(children3D)}, _importerState{importerState} {}
 
-SceneData::SceneData(SceneData&&) = default;
+SceneData::SceneData(SceneData&&) noexcept = default;
 
-SceneData& SceneData::operator=(SceneData&&) = default;
+SceneData& SceneData::operator=(SceneData&&) noexcept = default;
 
 }}
diff --git a/src/Magnum/Trade/SceneData.h b/src/Magnum/Trade/SceneData.h
index 0c12bb7f0..edaba4bff 100644
--- a/src/Magnum/Trade/SceneData.h
+++ b/src/Magnum/Trade/SceneData.h
@@ -54,13 +54,13 @@ class MAGNUM_EXPORT SceneData {
         SceneData(const SceneData&) = delete;
 
         /** @brief Move constructor */
-        SceneData(SceneData&&);
+        SceneData(SceneData&&) noexcept;
 
         /** @brief Copying is not allowed */
         SceneData& operator=(const SceneData&) = delete;
 
         /** @brief Move assignment */
-        SceneData& operator=(SceneData&&);
+        SceneData& operator=(SceneData&&) noexcept;
 
         /** @brief Two-dimensional child objects */
         const std::vector<UnsignedInt>& children2D() const { return _children2D; }
diff --git a/src/Magnum/Trade/TextureData.h b/src/Magnum/Trade/TextureData.h
index 23cfe3071..b942959b3 100644
--- a/src/Magnum/Trade/TextureData.h
+++ b/src/Magnum/Trade/TextureData.h
@@ -62,19 +62,19 @@ class TextureData {
          * @param image                 Texture image ID
          * @param importerState         Importer-specific state
          */
-        TextureData(Type type, Sampler::Filter minificationFilter, Sampler::Filter magnificationFilter, Sampler::Mipmap mipmapFilter, Array3D<Sampler::Wrapping> wrapping, UnsignedInt image, const void* importerState = nullptr): _type{type}, _minificationFilter{minificationFilter}, _magnificationFilter{magnificationFilter}, _mipmapFilter{mipmapFilter}, _wrapping{wrapping}, _image{image}, _importerState{importerState} {}
+        TextureData(Type type, Sampler::Filter minificationFilter, Sampler::Filter magnificationFilter, Sampler::Mipmap mipmapFilter, Array3D<Sampler::Wrapping> wrapping, UnsignedInt image, const void* importerState = nullptr) noexcept: _type{type}, _minificationFilter{minificationFilter}, _magnificationFilter{magnificationFilter}, _mipmapFilter{mipmapFilter}, _wrapping{wrapping}, _image{image}, _importerState{importerState} {}
 
         /** @brief Copying is not allowed */
         TextureData(const TextureData&) = delete;
 
         /** @brief Move constructor */
-        TextureData(TextureData&&) = default;
+        TextureData(TextureData&&) noexcept = default;
 
         /** @brief Copying is not allowed */
         TextureData& operator=(const TextureData&) = delete;
 
         /** @brief Move assignment */
-        TextureData& operator=(TextureData&&) = default;
+        TextureData& operator=(TextureData&&) noexcept = default;
 
         /** @brief Texture type */
         Type type() const { return _type; }