diff --git a/src/TextureTools/distance-field.cpp b/src/TextureTools/distance-field.cpp
index b148565cf..021430853 100644
--- a/src/TextureTools/distance-field.cpp
+++ b/src/TextureTools/distance-field.cpp
@@ -83,7 +83,7 @@ int DistanceFieldConverter::exec() {
     CORRADE_INTERNAL_ASSERT(importer && converter);
 
     /* Open input file */
-    Trade::ImageData2D* image = nullptr;
+    std::optional<Trade::ImageData2D> image;
     if(!importer->openFile(args.value("input")) || !(image = importer->image2D(0))) {
         Error() << "Cannot open file" << args.value("input");
         delete importer;
@@ -114,7 +114,6 @@ int DistanceFieldConverter::exec() {
     /* Do it */
     Debug() << "Converting image of size" << image->size() << "to distance field...";
     TextureTools::distanceField(input, output, {{}, args.value<Vector2i>("output-size")}, args.value<Int>("radius"), image->size());
-    delete image;
 
     /* Save image */
     Image2D result(ImageFormat::Red, ImageType::UnsignedByte);
diff --git a/src/Trade/AbstractImporter.cpp b/src/Trade/AbstractImporter.cpp
index 9d985b3dc..c4b3005e6 100644
--- a/src/Trade/AbstractImporter.cpp
+++ b/src/Trade/AbstractImporter.cpp
@@ -28,6 +28,14 @@
 #include <Containers/Array.h>
 #include <Utility/Assert.h>
 
+#include "Trade/CameraData.h"
+#include "Trade/ImageData.h"
+#include "Trade/LightData.h"
+#include "Trade/MeshData2D.h"
+#include "Trade/MeshData3D.h"
+#include "Trade/SceneData.h"
+#include "Trade/TextureData.h"
+
 namespace Magnum { namespace Trade {
 
 AbstractImporter::AbstractImporter() = default;
@@ -111,13 +119,13 @@ std::string AbstractImporter::sceneName(const UnsignedInt id) {
 
 std::string AbstractImporter::doSceneName(UnsignedInt) { return {}; }
 
-SceneData* AbstractImporter::scene(const UnsignedInt id) {
+std::optional<SceneData> AbstractImporter::scene(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::scene(): no file opened", {});
     CORRADE_ASSERT(id < doSceneCount(), "Trade::AbstractImporter::scene(): index out of range", {});
     return doScene(id);
 }
 
-SceneData* AbstractImporter::doScene(UnsignedInt) { return nullptr; }
+std::optional<SceneData> AbstractImporter::doScene(UnsignedInt) { return std::nullopt; }
 
 UnsignedInt AbstractImporter::lightCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::lightCount(): no file opened", {});
@@ -141,13 +149,13 @@ std::string AbstractImporter::lightName(const UnsignedInt id) {
 
 std::string AbstractImporter::doLightName(UnsignedInt) { return {}; }
 
-LightData* AbstractImporter::light(const UnsignedInt id) {
+std::optional<LightData> AbstractImporter::light(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::light(): no file opened", {});
     CORRADE_ASSERT(id < doLightCount(), "Trade::AbstractImporter::light(): index out of range", {});
     return doLight(id);
 }
 
-LightData* AbstractImporter::doLight(UnsignedInt) { return nullptr; }
+std::optional<LightData> AbstractImporter::doLight(UnsignedInt) { return std::nullopt; }
 
 UnsignedInt AbstractImporter::cameraCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::cameraCount(): no file opened", {});
@@ -171,13 +179,13 @@ std::string AbstractImporter::cameraName(const UnsignedInt id) {
 
 std::string AbstractImporter::doCameraName(UnsignedInt) { return {}; }
 
-CameraData* AbstractImporter::camera(const UnsignedInt id) {
+std::optional<CameraData> AbstractImporter::camera(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::camera(): no file opened", {});
     CORRADE_ASSERT(id < doCameraCount(), "Trade::AbstractImporter::camera(): index out of range", {});
     return doCamera(id);
 }
 
-CameraData* AbstractImporter::doCamera(UnsignedInt) { return nullptr; }
+std::optional<CameraData> AbstractImporter::doCamera(UnsignedInt) { return std::nullopt; }
 
 UnsignedInt AbstractImporter::object2DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::object2DCount(): no file opened", {});
@@ -261,13 +269,13 @@ std::string AbstractImporter::mesh2DName(const UnsignedInt id) {
 
 std::string AbstractImporter::doMesh2DName(UnsignedInt) { return {}; }
 
-MeshData2D* AbstractImporter::mesh2D(const UnsignedInt id) {
+std::optional<MeshData2D> AbstractImporter::mesh2D(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::mesh2D(): no file opened", {});
     CORRADE_ASSERT(id < doMesh2DCount(), "Trade::AbstractImporter::object2D(): index out of range", {});
     return doMesh2D(id);
 }
 
-MeshData2D* AbstractImporter::doMesh2D(UnsignedInt) { return nullptr; }
+std::optional<MeshData2D> AbstractImporter::doMesh2D(UnsignedInt) { return std::nullopt; }
 
 UnsignedInt AbstractImporter::mesh3DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::mesh3DCount(): no file opened", {});
@@ -291,13 +299,13 @@ std::string AbstractImporter::mesh3DName(const UnsignedInt id) {
 
 std::string AbstractImporter::doMesh3DName(UnsignedInt) { return {}; }
 
-MeshData3D* AbstractImporter::mesh3D(const UnsignedInt id) {
+std::optional<MeshData3D> AbstractImporter::mesh3D(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::mesh3D(): no file opened", {});
     CORRADE_ASSERT(id < doMesh3DCount(), "Trade::AbstractImporter::mesh3D(): index out of range", {});
     return doMesh3D(id);
 }
 
-MeshData3D* AbstractImporter::doMesh3D(UnsignedInt) { return nullptr; }
+std::optional<MeshData3D> AbstractImporter::doMesh3D(UnsignedInt) { return std::nullopt; }
 
 UnsignedInt AbstractImporter::materialCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::materialCount(): no file opened", {});
@@ -351,13 +359,13 @@ std::string AbstractImporter::textureName(const UnsignedInt id) {
 
 std::string AbstractImporter::doTextureName(UnsignedInt) { return {}; }
 
-TextureData* AbstractImporter::texture(const UnsignedInt id) {
+std::optional<TextureData> AbstractImporter::texture(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::texture(): no file opened", {});
     CORRADE_ASSERT(id < doTextureCount(), "Trade::AbstractImporter::texture(): index out of range", {});
     return doTexture(id);
 }
 
-TextureData* AbstractImporter::doTexture(UnsignedInt) { return nullptr; }
+std::optional<TextureData> AbstractImporter::doTexture(UnsignedInt) { return std::nullopt; }
 
 UnsignedInt AbstractImporter::image1DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::image1DCount(): no file opened", {});
@@ -381,13 +389,13 @@ std::string AbstractImporter::image1DName(const UnsignedInt id) {
 
 std::string AbstractImporter::doImage1DName(UnsignedInt) { return {}; }
 
-ImageData1D* AbstractImporter::image1D(const UnsignedInt id) {
+std::optional<ImageData1D> AbstractImporter::image1D(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::image1D(): no file opened", {});
     CORRADE_ASSERT(id < doImage1DCount(), "Trade::AbstractImporter::image1D(): index out of range", {});
     return doImage1D(id);
 }
 
-ImageData1D* AbstractImporter::doImage1D(UnsignedInt) { return nullptr; }
+std::optional<ImageData1D> AbstractImporter::doImage1D(UnsignedInt) { return std::nullopt; }
 
 UnsignedInt AbstractImporter::image2DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::image2DCount(): no file opened", {});
@@ -411,13 +419,13 @@ std::string AbstractImporter::image2DName(const UnsignedInt id) {
 
 std::string AbstractImporter::doImage2DName(UnsignedInt) { return {}; }
 
-ImageData2D* AbstractImporter::image2D(const UnsignedInt id) {
+std::optional<ImageData2D> AbstractImporter::image2D(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::image2D(): no file opened", {});
     CORRADE_ASSERT(id < doImage2DCount(), "Trade::AbstractImporter::image2D(): index out of range", {});
     return doImage2D(id);
 }
 
-ImageData2D* AbstractImporter::doImage2D(UnsignedInt) { return nullptr; }
+std::optional<ImageData2D> AbstractImporter::doImage2D(UnsignedInt) { return std::nullopt; }
 
 UnsignedInt AbstractImporter::image3DCount() const {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::image3DCount(): no file opened", {});
@@ -441,12 +449,12 @@ std::string AbstractImporter::image3DName(const UnsignedInt id) {
 
 std::string AbstractImporter::doImage3DName(UnsignedInt) { return {}; }
 
-ImageData3D* AbstractImporter::image3D(const UnsignedInt id) {
+std::optional<ImageData3D> AbstractImporter::image3D(const UnsignedInt id) {
     CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::image3D(): no file opened", {});
     CORRADE_ASSERT(id < doImage3DCount(), "Trade::AbstractImporter::image3D(): index out of range", {});
     return doImage3D(id);
 }
 
-ImageData3D* AbstractImporter::doImage3D(UnsignedInt) { return nullptr; }
+std::optional<ImageData3D> AbstractImporter::doImage3D(UnsignedInt) { return std::nullopt; }
 
 }}
diff --git a/src/Trade/AbstractImporter.h b/src/Trade/AbstractImporter.h
index c760ab477..356a636e2 100644
--- a/src/Trade/AbstractImporter.h
+++ b/src/Trade/AbstractImporter.h
@@ -31,6 +31,8 @@
 #include <Containers/EnumSet.h>
 #include <PluginManager/AbstractPlugin.h>
 
+#include "Optional/optional.hpp"
+
 #include "Magnum.h"
 #include "magnumVisibility.h"
 #include "Trade/Trade.h"
@@ -157,10 +159,9 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
          * @brief %Scene
          * @param id        %Scene ID, from range [0, sceneCount()).
          *
-         * Returns given scene or `nullptr` if import failed. Deleting the data
-         * is user responsibility.
+         * Returns given scene or `std::nullopt` if import failed.
          */
-        SceneData* scene(UnsignedInt id);
+        std::optional<SceneData> scene(UnsignedInt id);
 
         /** @brief %Light count */
         UnsignedInt lightCount() const;
@@ -185,10 +186,9 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
          * @brief %Light
          * @param id        %Light ID, from range [0, lightCount()).
          *
-         * Returns given light or `nullptr` if importing failed. Deleting the
-         * data is user responsibility.
+         * Returns given light or `std::nullopt` if importing failed.
          */
-        LightData* light(UnsignedInt id);
+        std::optional<LightData> light(UnsignedInt id);
 
         /** @brief Camera count */
         UnsignedInt cameraCount() const;
@@ -213,10 +213,9 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
          * @brief Camera
          * @param id        Camera ID, from range [0, cameraCount()).
          *
-         * Returns given camera or `nullptr` if importing failed. Deleting the
-         * data is user responsibility.
+         * Returns given camera or `std::nullopt` if importing failed.
          */
-        CameraData* camera(UnsignedInt id);
+        std::optional<CameraData> camera(UnsignedInt id);
 
         /** @brief Two-dimensional object count */
         UnsignedInt object2DCount() const;
@@ -297,10 +296,9 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
          * @brief Two-dimensional mesh
          * @param id        %Mesh ID, from range [0, mesh2DCount()).
          *
-         * Returns given mesh or `nullptr` if importing failed. Deleting the
-         * data is user responsibility.
+         * Returns given mesh or `std::nullopt` if importing failed.
          */
-        MeshData2D* mesh2D(UnsignedInt id);
+        std::optional<MeshData2D> mesh2D(UnsignedInt id);
 
         /** @brief Three-dimensional mesh count */
         UnsignedInt mesh3DCount() const;
@@ -325,10 +323,9 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
          * @brief Three-dimensional mesh
          * @param id        %Mesh ID, from range [0, mesh3DCount()).
          *
-         * Returns given mesh or `nullptr` if importing failed. Deleting the
-         * data is user responsibility.
+         * Returns given mesh or `std::nullopt` if importing failed.
          */
-        MeshData3D* mesh3D(UnsignedInt id);
+        std::optional<MeshData3D> mesh3D(UnsignedInt id);
 
         /** @brief Material count */
         UnsignedInt materialCount() const;
@@ -381,10 +378,9 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
          * @brief %Texture
          * @param id        %Texture ID, from range [0, textureCount()).
          *
-         * Returns given texture or `nullptr` if importing failed. Deleting the
-         * data is user responsibility.
+         * Returns given texture or `std::nullopt` if importing failed.
          */
-        TextureData* texture(UnsignedInt id);
+        std::optional<TextureData> texture(UnsignedInt id);
 
         /** @brief One-dimensional image count */
         UnsignedInt image1DCount() const;
@@ -409,10 +405,9 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
          * @brief One-dimensional image
          * @param id        %Image ID, from range [0, image1DCount()).
          *
-         * Returns given image or `nullptr` if importing failed. Deleting the
-         * data is user responsibility.
+         * Returns given image or `std::nullopt` if importing failed.
          */
-        ImageData1D* image1D(UnsignedInt id);
+        std::optional<ImageData1D> image1D(UnsignedInt id);
 
         /** @brief Two-dimensional image count */
         UnsignedInt image2DCount() const;
@@ -437,10 +432,9 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
          * @brief Two-dimensional image
          * @param id        %Image ID, from range [0, image2DCount()).
          *
-         * Returns given image or `nullptr` if importing failed. Deleting the
-         * data is user responsibility.
+         * Returns given image or `std::nullopt` if importing failed.
          */
-        ImageData2D* image2D(UnsignedInt id);
+        std::optional<ImageData2D> image2D(UnsignedInt id);
 
         /** @brief Three-dimensional image count */
         UnsignedInt image3DCount() const;
@@ -465,10 +459,9 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
          * @brief Three-dimensional image
          * @param id        %Image ID, from range [0, image3DCount()).
          *
-         * Returns given image or `nullptr` if importing failed. Deleting the
-         * data is user responsibility.
+         * Returns given image or `std::nullopt` if importing failed.
          */
-        ImageData3D* image3D(UnsignedInt id);
+        std::optional<ImageData3D> image3D(UnsignedInt id);
 
         /*@}*/
 
@@ -510,7 +503,7 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
         virtual std::string doSceneName(UnsignedInt id);
 
         /** @brief Implementation for scene() */
-        virtual SceneData* doScene(UnsignedInt id);
+        virtual std::optional<SceneData> doScene(UnsignedInt id);
 
         /** @brief Implementation for lightCount() */
         virtual UnsignedInt doLightCount() const;
@@ -522,7 +515,7 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
         virtual std::string doLightName(UnsignedInt id);
 
         /** @brief Implementation for light() */
-        virtual LightData* doLight(UnsignedInt id);
+        virtual std::optional<LightData> doLight(UnsignedInt id);
 
         /** @brief Implementation for cameraCount() */
         virtual UnsignedInt doCameraCount() const;
@@ -534,7 +527,7 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
         virtual std::string doCameraName(UnsignedInt id);
 
         /** @brief Implementation for camera() */
-        virtual CameraData* doCamera(UnsignedInt id);
+        virtual std::optional<CameraData> doCamera(UnsignedInt id);
 
         /** @brief Implementation for object2DCount() */
         virtual UnsignedInt doObject2DCount() const;
@@ -570,7 +563,7 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
         virtual std::string doMesh2DName(UnsignedInt id);
 
         /** @brief Implementation for mesh2D() */
-        virtual MeshData2D* doMesh2D(UnsignedInt id);
+        virtual std::optional<MeshData2D> doMesh2D(UnsignedInt id);
 
         /** @brief Implementation for mesh3DCount() */
         virtual UnsignedInt doMesh3DCount() const;
@@ -582,7 +575,7 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
         virtual std::string doMesh3DName(UnsignedInt id);
 
         /** @brief Implementation for mesh3D() */
-        virtual MeshData3D* doMesh3D(UnsignedInt id);
+        virtual std::optional<MeshData3D> doMesh3D(UnsignedInt id);
 
         /** @brief Implementation for materialCount() */
         virtual UnsignedInt doMaterialCount() const;
@@ -606,7 +599,7 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
         virtual std::string doTextureName(UnsignedInt id);
 
         /** @brief Implementation for texture() */
-        virtual TextureData* doTexture(UnsignedInt id);
+        virtual std::optional<TextureData> doTexture(UnsignedInt id);
 
         /** @brief Implementation for image1DCount() */
         virtual UnsignedInt doImage1DCount() const;
@@ -618,7 +611,7 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
         virtual std::string doImage1DName(UnsignedInt id);
 
         /** @brief Implementation for image1D() */
-        virtual ImageData1D* doImage1D(UnsignedInt id);
+        virtual std::optional<ImageData1D> doImage1D(UnsignedInt id);
 
         /** @brief Implementation for image2DCount() */
         virtual UnsignedInt doImage2DCount() const;
@@ -630,7 +623,7 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
         virtual std::string doImage2DName(UnsignedInt id);
 
         /** @brief Implementation for image2D() */
-        virtual ImageData2D* doImage2D(UnsignedInt id);
+        virtual std::optional<ImageData2D> doImage2D(UnsignedInt id);
 
         /** @brief Implementation for image3DCount() */
         virtual UnsignedInt doImage3DCount() const;
@@ -642,7 +635,7 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractPlugin {
         virtual std::string doImage3DName(UnsignedInt id);
 
         /** @brief Implementation for image3D() */
-        virtual ImageData3D* doImage3D(UnsignedInt id);
+        virtual std::optional<ImageData3D> doImage3D(UnsignedInt id);
 };
 
 CORRADE_ENUMSET_OPERATORS(AbstractImporter::Features)