diff -r 800e4a6ab128 -r 79bc439970cd src/web/app/mu-plugins/bedrock-autoloader.php
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/web/app/mu-plugins/bedrock-autoloader.php	Tue Apr 23 20:19:02 2019 +0200
@@ -0,0 +1,198 @@
+<?php
+/**
+ * Plugin Name: Bedrock Autoloader
+ * Plugin URI: https://github.com/roots/bedrock/
+ * Description: An autoloader that enables standard plugins to be required just like must-use plugins. The autoloaded plugins are included during mu-plugin loading. An asterisk (*) next to the name of the plugin designates the plugins that have been autoloaded.
+ * Version: 1.0.0
+ * Author: Roots
+ * Author URI: https://roots.io/
+ * License: MIT License
+ */
+
+namespace Roots\Bedrock;
+
+if (!is_blog_installed()) {
+    return;
+}
+
+/**
+ * Class Autoloader
+ * @package Roots\Bedrock
+ * @author Roots
+ * @link https://roots.io/
+ */
+class Autoloader
+{
+    /** @var array Store Autoloader cache and site option */
+    private static $cache;
+
+    /** @var array Autoloaded plugins */
+    private static $auto_plugins;
+
+    /** @var array Autoloaded mu-plugins */
+    private static $mu_plugins;
+
+    /** @var int Number of plugins */
+    private static $count;
+
+    /** @var array Newly activated plugins */
+    private static $activated;
+
+    /** @var string Relative path to the mu-plugins dir */
+    private static $relative_path;
+
+    /** @var static Singleton instance */
+    private static $_single;
+
+    /**
+     * Create singleton, populate vars, and set WordPress hooks
+     */
+    public function __construct()
+    {
+        if (isset(self::$_single)) {
+            return;
+        }
+
+        self::$_single = $this;
+        self::$relative_path = '/../' . basename(__DIR__);
+
+        if (is_admin()) {
+            add_filter('show_advanced_plugins', [$this, 'showInAdmin'], 0, 2);
+        }
+
+        $this->loadPlugins();
+    }
+
+   /**
+    * Run some checks then autoload our plugins.
+    */
+    public function loadPlugins()
+    {
+        $this->checkCache();
+        $this->validatePlugins();
+        $this->countPlugins();
+
+        array_map(static function () {
+            include_once WPMU_PLUGIN_DIR . '/' . func_get_args()[0];
+        }, array_keys(self::$cache['plugins']));
+
+        $this->pluginHooks();
+    }
+
+    /**
+     * Filter show_advanced_plugins to display the autoloaded plugins.
+     * @param $show bool Whether to show the advanced plugins for the specified plugin type.
+     * @param $type string The plugin type, i.e., `mustuse` or `dropins`
+     * @return bool We return `false` to prevent WordPress from overriding our work
+     * {@internal We add the plugin details ourselves, so we return false to disable the filter.}
+     */
+    public function showInAdmin($show, $type)
+    {
+        $screen = get_current_screen();
+        $current = is_multisite() ? 'plugins-network' : 'plugins';
+
+        if ($screen->base !== $current || $type !== 'mustuse' || !current_user_can('activate_plugins')) {
+            return $show;
+        }
+
+        $this->updateCache();
+
+        self::$auto_plugins = array_map(function ($auto_plugin) {
+            $auto_plugin['Name'] .= ' *';
+            return $auto_plugin;
+        }, self::$auto_plugins);
+
+        $GLOBALS['plugins']['mustuse'] = array_unique(array_merge(self::$auto_plugins, self::$mu_plugins), SORT_REGULAR);
+
+        return false;
+    }
+
+    /**
+     * This sets the cache or calls for an update
+     */
+    private function checkCache()
+    {
+        $cache = get_site_option('bedrock_autoloader');
+
+        if ($cache === false) {
+            $this->updateCache();
+            return;
+        }
+
+        self::$cache = $cache;
+    }
+
+    /**
+     * Get the plugins and mu-plugins from the mu-plugin path and remove duplicates.
+     * Check cache against current plugins for newly activated plugins.
+     * After that, we can update the cache.
+     */
+    private function updateCache()
+    {
+        require_once ABSPATH . 'wp-admin/includes/plugin.php';
+
+        self::$auto_plugins = get_plugins(self::$relative_path);
+        self::$mu_plugins   = get_mu_plugins();
+        $plugins            = array_diff_key(self::$auto_plugins, self::$mu_plugins);
+        $rebuild            = !is_array(self::$cache['plugins']);
+        self::$activated    = $rebuild ? $plugins : array_diff_key($plugins, self::$cache['plugins']);
+        self::$cache        = ['plugins' => $plugins, 'count' => $this->countPlugins()];
+
+        update_site_option('bedrock_autoloader', self::$cache);
+    }
+
+    /**
+     * This accounts for the plugin hooks that would run if the plugins were
+     * loaded as usual. Plugins are removed by deletion, so there's no way
+     * to deactivate or uninstall.
+     */
+    private function pluginHooks()
+    {
+        if (!is_array(self::$activated)) {
+            return;
+        }
+
+        foreach (self::$activated as $plugin_file => $plugin_info) {
+            do_action('activate_' . $plugin_file);
+        }
+    }
+
+    /**
+     * Check that the plugin file exists, if it doesn't update the cache.
+     */
+    private function validatePlugins()
+    {
+        foreach (self::$cache['plugins'] as $plugin_file => $plugin_info) {
+            if (!file_exists(WPMU_PLUGIN_DIR . '/' . $plugin_file)) {
+                $this->updateCache();
+                break;
+            }
+        }
+    }
+
+    /**
+     * Count the number of autoloaded plugins.
+     *
+     * Count our plugins (but only once) by counting the top level folders in the
+     * mu-plugins dir. If it's more or less than last time, update the cache.
+     *
+     * @return int Number of autoloaded plugins.
+     */
+    private function countPlugins()
+    {
+        if (isset(self::$count)) {
+            return self::$count;
+        }
+
+        $count = count(glob(WPMU_PLUGIN_DIR . '/*/', GLOB_ONLYDIR | GLOB_NOSORT));
+
+        if (!isset(self::$cache['count']) || $count !== self::$cache['count']) {
+            self::$count = $count;
+            $this->updateCache();
+        }
+
+        return self::$count;
+    }
+}
+
+new Autoloader();