diff --git a/src/Illuminate/Database/Eloquent/Builder.php b/src/Illuminate/Database/Eloquent/Builder.php
index 4e22b9ae9fa..896b9c38ad0 100755
--- a/src/Illuminate/Database/Eloquent/Builder.php
+++ b/src/Illuminate/Database/Eloquent/Builder.php
@@ -854,9 +854,13 @@ public function get($columns = ['*'])
             $models = $builder->eagerLoadRelations($models);
         }
 
-        return $this->applyAfterQueryCallbacks(
-            $builder->getModel()->newCollection($models)
-        );
+        $collection = $builder->getModel()->newCollection($models);
+
+        if (Model::isAutoloadingRelationsGlobally()) {
+            $collection->withRelationshipAutoloading();
+        }
+
+        return $this->applyAfterQueryCallbacks($collection);
     }
 
     /**
diff --git a/src/Illuminate/Database/Eloquent/Collection.php b/src/Illuminate/Database/Eloquent/Collection.php
index d030a3bc93e..927d33c2551 100755
--- a/src/Illuminate/Database/Eloquent/Collection.php
+++ b/src/Illuminate/Database/Eloquent/Collection.php
@@ -248,6 +248,35 @@ public function loadMissing($relations)
         return $this;
     }
 
+    /**
+     * Load a relationship path for models of the given type if it is not already eager loaded.
+     *
+     * @param  array  $tuples
+     * @return void
+     */
+    public function loadMissingRelationsViaRelationAndClassTuples(array $tuples)
+    {
+        [$relation, $class] = array_shift($tuples);
+
+        $this->filter(function ($model) use ($relation, $class) {
+            return ! is_null($model) &&
+                ! $model->relationLoaded($relation) &&
+                $model::class === $class;
+        })->load($relation);
+
+        if (empty($tuples)) {
+            return;
+        }
+
+        $models = $this->pluck($relation)->whereNotNull();
+
+        if ($models->first() instanceof BaseCollection) {
+            $models = $models->collapse();
+        }
+
+        (new static($models))->loadMissingRelationsViaRelationAndClassTuples($tuples);
+    }
+
     /**
      * Load a relationship path if it is not already eager loaded.
      *
@@ -721,6 +750,24 @@ protected function duplicateComparator($strict)
         return fn ($a, $b) => $a->is($b);
     }
 
+    /**
+     * Enable relationship autoloading for all models in this collection.
+     *
+     * @return $this
+     */
+    public function withRelationshipAutoloading()
+    {
+        $callback = fn ($tuples) => $this->loadMissingRelationsViaRelationAndClassTuples($tuples);
+
+        foreach ($this as $model) {
+            if (! $model->hasRelationAutoloadCallback()) {
+                $model->autoloadRelationsUsing($callback);
+            }
+        }
+
+        return $this;
+    }
+
     /**
      * Get the type of the entities being queued.
      *
diff --git a/src/Illuminate/Database/Eloquent/Concerns/HasAttributes.php b/src/Illuminate/Database/Eloquent/Concerns/HasAttributes.php
index 8c06e658e47..0d0fc454bf0 100644
--- a/src/Illuminate/Database/Eloquent/Concerns/HasAttributes.php
+++ b/src/Illuminate/Database/Eloquent/Concerns/HasAttributes.php
@@ -551,6 +551,10 @@ public function getRelationValue($key)
             return;
         }
 
+        if ($this->attemptToAutoloadRelation($key)) {
+            return $this->relations[$key];
+        }
+
         if ($this->preventsLazyLoading) {
             $this->handleLazyLoadingViolation($key);
         }
diff --git a/src/Illuminate/Database/Eloquent/Concerns/HasRelationships.php b/src/Illuminate/Database/Eloquent/Concerns/HasRelationships.php
index df89155e938..2f30de88a2b 100644
--- a/src/Illuminate/Database/Eloquent/Concerns/HasRelationships.php
+++ b/src/Illuminate/Database/Eloquent/Concerns/HasRelationships.php
@@ -39,6 +39,13 @@ trait HasRelationships
      */
     protected $touches = [];
 
+    /**
+     * The relationship autoloader callback.
+     *
+     * @var \Closure|null
+     */
+    protected $relationAutoloadCallback = null;
+
     /**
      * The many to many relationship methods.
      *
@@ -92,6 +99,97 @@ public static function resolveRelationUsing($name, Closure $callback)
         );
     }
 
+    /**
+     * Determine if a relationship autoloader callback has been defined.
+     *
+     * @return bool
+     */
+    public function hasRelationAutoloadCallback()
+    {
+        return ! is_null($this->relationAutoloadCallback);
+    }
+
+    /**
+     * Define an automatic relationship autoloader callback for this model and its relations.
+     *
+     * @param  \Closure  $callback
+     * @param  mixed  $context
+     * @return $this
+     */
+    public function autoloadRelationsUsing(Closure $callback, $context = null)
+    {
+        $this->relationAutoloadCallback = $callback;
+
+        foreach ($this->relations as $key => $value) {
+            $this->propagateRelationAutoloadCallbackToRelation($key, $value, $context);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Attempt to autoload the given relationship using the autoload callback.
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    protected function attemptToAutoloadRelation($key)
+    {
+        if (! $this->hasRelationAutoloadCallback()) {
+            return false;
+        }
+
+        $this->invokeRelationAutoloadCallbackFor($key, []);
+
+        return $this->relationLoaded($key);
+    }
+
+    /**
+     * Invoke the relationship autoloader callback for the given relationships.
+     *
+     * @param  string  $key
+     * @param  array  $tuples
+     * @return void
+     */
+    protected function invokeRelationAutoloadCallbackFor($key, $tuples)
+    {
+        $tuples = array_merge([[$key, get_class($this)]], $tuples);
+
+        call_user_func($this->relationAutoloadCallback, $tuples);
+    }
+
+    /**
+     * Propagate the relationship autoloader callback to the given related models.
+     *
+     * @param  string  $key
+     * @param  mixed  $values
+     * @param  mixed  $context
+     * @return void
+     */
+    protected function propagateRelationAutoloadCallbackToRelation($key, $models, $context = null)
+    {
+        if (! $this->hasRelationAutoloadCallback() || ! $models) {
+            return;
+        }
+
+        if ($models instanceof Model) {
+            $models = [$models];
+        }
+
+        if (! is_iterable($models)) {
+            return;
+        }
+
+        $callback = fn (array $tuples) => $this->invokeRelationAutoloadCallbackFor($key, $tuples);
+
+        foreach ($models as $model) {
+            // Check if relation autoload contexts are different to avoid circular relation autoload...
+            if (is_null($context) || $context !== $model) {
+                $model->autoloadRelationsUsing($callback, $context);
+            }
+        }
+    }
+
     /**
      * Define a one-to-one relationship.
      *
@@ -988,6 +1086,8 @@ public function setRelation($relation, $value)
     {
         $this->relations[$relation] = $value;
 
+        $this->propagateRelationAutoloadCallbackToRelation($relation, $value, $this);
+
         return $this;
     }
 
diff --git a/src/Illuminate/Database/Eloquent/Model.php b/src/Illuminate/Database/Eloquent/Model.php
index f730ec3cd24..2ddc64fc37d 100644
--- a/src/Illuminate/Database/Eloquent/Model.php
+++ b/src/Illuminate/Database/Eloquent/Model.php
@@ -178,6 +178,13 @@ abstract class Model implements Arrayable, ArrayAccess, CanBeEscapedWhenCastToSt
      */
     protected static $modelsShouldPreventLazyLoading = false;
 
+    /**
+     * Indicates whether relations should be automatically loaded on all models.
+     *
+     * @var bool
+     */
+    protected static $modelsShouldGlobalAutoloadRelations = false;
+
     /**
      * The callback that is responsible for handling lazy loading violations.
      *
@@ -446,6 +453,17 @@ public static function preventLazyLoading($value = true)
         static::$modelsShouldPreventLazyLoading = $value;
     }
 
+    /**
+     * Determine if model relationships should be automatically loaded.
+     *
+     * @param  bool  $value
+     * @return void
+     */
+    public static function globalAutoloadRelations($value = true)
+    {
+        static::$modelsShouldGlobalAutoloadRelations = $value;
+    }
+
     /**
      * Register a callback that is responsible for handling lazy loading violations.
      *
@@ -2231,6 +2249,16 @@ public static function preventsLazyLoading()
         return static::$modelsShouldPreventLazyLoading;
     }
 
+    /**
+     * Determine if relations autoload is enabled.
+     *
+     * @return bool
+     */
+    public static function isAutoloadingRelationsGlobally()
+    {
+        return static::$modelsShouldGlobalAutoloadRelations;
+    }
+
     /**
      * Determine if discarding guarded attribute fills is disabled.
      *
diff --git a/tests/Database/DatabaseEloquentBelongsToManyWithCastedAttributesTest.php b/tests/Database/DatabaseEloquentBelongsToManyWithCastedAttributesTest.php
index c7cab6453df..08f1bd45a56 100644
--- a/tests/Database/DatabaseEloquentBelongsToManyWithCastedAttributesTest.php
+++ b/tests/Database/DatabaseEloquentBelongsToManyWithCastedAttributesTest.php
@@ -27,6 +27,7 @@ public function testModelsAreProperlyMatchedToParents()
         $model1->shouldReceive('getAttribute')->with('foo')->passthru();
         $model1->shouldReceive('hasGetMutator')->andReturn(false);
         $model1->shouldReceive('hasAttributeMutator')->andReturn(false);
+        $model1->shouldReceive('hasRelationAutoloadCallback')->andReturn(false);
         $model1->shouldReceive('getCasts')->andReturn([]);
         $model1->shouldReceive('getRelationValue', 'relationLoaded', 'relationResolver', 'setRelation', 'isRelation')->passthru();
 
@@ -36,6 +37,7 @@ public function testModelsAreProperlyMatchedToParents()
         $model2->shouldReceive('getAttribute')->with('foo')->passthru();
         $model2->shouldReceive('hasGetMutator')->andReturn(false);
         $model2->shouldReceive('hasAttributeMutator')->andReturn(false);
+        $model2->shouldReceive('hasRelationAutoloadCallback')->andReturn(false);
         $model2->shouldReceive('getCasts')->andReturn([]);
         $model2->shouldReceive('getRelationValue', 'relationLoaded', 'relationResolver', 'setRelation', 'isRelation')->passthru();
 
diff --git a/tests/Integration/Database/EloquentModelRelationAutoloadTest.php b/tests/Integration/Database/EloquentModelRelationAutoloadTest.php
new file mode 100644
index 00000000000..8f80c5bb514
--- /dev/null
+++ b/tests/Integration/Database/EloquentModelRelationAutoloadTest.php
@@ -0,0 +1,183 @@
+<?php
+
+namespace Illuminate\Tests\Integration\Database\EloquentModelRelationAutoloadTest;
+
+use DB;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+use Illuminate\Tests\Integration\Database\DatabaseTestCase;
+
+class EloquentModelRelationAutoloadTest extends DatabaseTestCase
+{
+    protected function afterRefreshingDatabase()
+    {
+        Schema::create('posts', function (Blueprint $table) {
+            $table->increments('id');
+        });
+
+        Schema::create('videos', function (Blueprint $table) {
+            $table->increments('id');
+        });
+
+        Schema::create('comments', function (Blueprint $table) {
+            $table->increments('id');
+            $table->unsignedInteger('parent_id')->nullable();
+            $table->morphs('commentable');
+        });
+
+        Schema::create('likes', function (Blueprint $table) {
+            $table->increments('id');
+            $table->morphs('likeable');
+        });
+    }
+
+    public function testRelationAutoload()
+    {
+        $post1 = Post::create();
+        $comment1 = $post1->comments()->create(['parent_id' => null]);
+        $comment2 = $post1->comments()->create(['parent_id' => $comment1->id]);
+        $comment2->likes()->create();
+        $comment2->likes()->create();
+
+        $post2 = Post::create();
+        $comment3 = $post2->comments()->create(['parent_id' => null]);
+        $comment3->likes()->create();
+
+        $posts = Post::get();
+
+        DB::enableQueryLog();
+
+        $likes = [];
+
+        $posts->withRelationshipAutoloading();
+
+        foreach ($posts as $post) {
+            foreach ($post->comments as $comment) {
+                $likes = array_merge($likes, $comment->likes->all());
+            }
+        }
+
+        $this->assertCount(2, DB::getQueryLog());
+        $this->assertCount(3, $likes);
+        $this->assertTrue($posts[0]->comments[0]->relationLoaded('likes'));
+    }
+
+    public function testRelationAutoloadVariousNestedMorphRelations()
+    {
+        tap(Post::create(), function ($post) {
+            $post->likes()->create();
+            $post->comments()->create();
+            tap($post->comments()->create(), function ($comment) {
+                $comment->likes()->create();
+                $comment->likes()->create();
+            });
+        });
+
+        tap(Post::create(), function ($post) {
+            $post->likes()->create();
+            tap($post->comments()->create(), function ($comment) {
+                $comment->likes()->create();
+            });
+        });
+
+        tap(Video::create(), function ($video) {
+            tap($video->comments()->create(), function ($comment) {
+                $comment->likes()->create();
+            });
+        });
+
+        tap(Video::create(), function ($video) {
+            tap($video->comments()->create(), function ($comment) {
+                $comment->likes()->create();
+            });
+        });
+
+        $likes = Like::get();
+
+        DB::enableQueryLog();
+
+        $videos = [];
+        $videoLike = null;
+
+        $likes->withRelationshipAutoloading();
+
+        foreach ($likes as $like) {
+            $likeable = $like->likeable;
+
+            if (($likeable instanceof Comment) && ($likeable->commentable instanceof Video)) {
+                $videos[] = $likeable->commentable;
+                $videoLike = $like;
+            }
+        }
+
+        $this->assertCount(4, DB::getQueryLog());
+        $this->assertCount(2, $videos);
+        $this->assertTrue($videoLike->relationLoaded('likeable'));
+        $this->assertTrue($videoLike->likeable->relationLoaded('commentable'));
+    }
+}
+
+class Comment extends Model
+{
+    public $timestamps = false;
+
+    protected $guarded = [];
+
+    public function parent()
+    {
+        return $this->belongsTo(self::class);
+    }
+
+    public function likes()
+    {
+        return $this->morphMany(Like::class, 'likeable');
+    }
+
+    public function commentable()
+    {
+        return $this->morphTo();
+    }
+}
+
+class Post extends Model
+{
+    public $timestamps = false;
+
+    public function comments()
+    {
+        return $this->morphMany(Comment::class, 'commentable');
+    }
+
+    public function likes()
+    {
+        return $this->morphMany(Like::class, 'likeable');
+    }
+}
+
+class Video extends Model
+{
+    public $timestamps = false;
+
+    public function comments()
+    {
+        return $this->morphMany(Comment::class, 'commentable');
+    }
+
+    public function likes()
+    {
+        return $this->morphMany(Like::class, 'likeable');
+    }
+}
+
+class Like extends Model
+{
+    public $timestamps = false;
+
+    protected $guarded = [];
+
+    public function likeable()
+    {
+        return $this->morphTo();
+    }
+}