5.x module.inc module_enable($module_list)
6.x module.inc module_enable($module_list)
7.x module.inc module_enable($module_list, $enable_dependencies = TRUE)

Enables or installs a given list of modules.


  • "Enabling" is the process of activating a module for use by Drupal.
  • "Disabling" is the process of deactivating a module.
  • "Installing" is the process of enabling it for the first time or after it has been uninstalled.
  • "Uninstalling" is the process of removing all traces of a module.

Order of events:

  • Gather and add module dependencies to $module_list (if applicable).
  • For each module that is being enabled:
    • Install module schema and update system registries and caches.
    • If the module is being enabled for the first time or had been uninstalled, invoke hook_install() and add it to the list of installed modules.
    • Invoke hook_enable().
  • Invoke hook_modules_installed().
  • Invoke hook_modules_enabled().


string[] $module_list: An array of module names.

bool $enable_dependencies: If TRUE, dependencies will automatically be added and enabled in the correct order. This incurs a significant performance cost, so use FALSE if you know $module_list is already complete and in the correct order.

Return value

bool FALSE if one or more dependencies are missing, TRUE otherwise.

See also







27 calls to module_enable()
BlockHashTestCase::testBlockRehash in modules/block/block.test
Tests that block rehashing does not write to the database too often.
BlockTestCase::testBlockRehash in modules/block/block.test
Test _block_rehash().
CronRunTestCase::testCronCacheExpiration in modules/system/system.test
Tests that hook_flush_caches() is not invoked on every single cron run.
DrupalWebTestCase::setUp in modules/simpletest/drupal_web_test_case.php
Sets up a Drupal site for running functional and integration tests.
EnableDisableTestCase::testEntityInfoCacheWatchdog in modules/system/system.test
Tests entity info cache after enabling a module with a dependency on an entity providing module.

... See full list


includes/module.inc, line 400
API for loading and interacting with Drupal modules.


function module_enable($module_list, $enable_dependencies = TRUE) {
  if ($enable_dependencies) {

    // Get all module data so we can find dependencies and sort.
    $module_data = system_rebuild_module_data();

    // Create an associative array with weights as values.
    $module_list = array_flip(array_values($module_list));
    while (list($module) = each($module_list)) {
      if (!isset($module_data[$module])) {

        // This module is not found in the filesystem, abort.
        return FALSE;
      if ($module_data[$module]->status) {

        // Skip already enabled modules.
      $module_list[$module] = $module_data[$module]->sort;

      // Add dependencies to the list, with a placeholder weight.
      // The new modules will be processed as the while loop continues.
      foreach (array_keys($module_data[$module]->requires) as $dependency) {
        if (!isset($module_list[$dependency])) {
          $module_list[$dependency] = 0;
    if (!$module_list) {

      // Nothing to do. All modules already enabled.
      return TRUE;

    // Sort the module list by pre-calculated weights.
    $module_list = array_keys($module_list);

  // Required for module installation checks.
  include_once DRUPAL_ROOT . '/includes/install.inc';
  $modules_installed = array();
  $modules_enabled = array();
  foreach ($module_list as $module) {

    // Only process modules that are not already enabled.
    $existing = db_query("SELECT status FROM {system} WHERE type = :type AND name = :name", array(
      ':type' => 'module',
      ':name' => $module,
    if ($existing->status == 0) {

      // Load the module's code.
      drupal_load('module', $module);

      // Update the database and module list to reflect the new module. This
      // needs to be done first so that the module's hook implementations,
      // hook_schema() in particular, can be called while it is being
      // installed.
        'status' => 1,
        ->condition('type', 'module')
        ->condition('name', $module)

      // Refresh the module list to include it.
      module_implements('', FALSE, TRUE);

      // Update the registry to include it.

      // Refresh the schema to include it.
      drupal_get_schema(NULL, TRUE);

      // Update the theme registry to include it.

      // Clear entity cache.

      // Now install the module if necessary.
      if (drupal_get_installed_schema_version($module, TRUE) == SCHEMA_UNINSTALLED) {

        // Set the schema version to the number of the last update provided
        // by the module.
        $versions = drupal_get_schema_versions($module);
        $version = $versions ? max($versions) : SCHEMA_INSTALLED;

        // If the module has no current updates, but has some that were
        // previously removed, set the version to the value of
        // hook_update_last_removed().
        if ($last_removed = module_invoke($module, 'update_last_removed')) {
          $version = max($version, $last_removed);
        drupal_set_installed_schema_version($module, $version);

        // Allow the module to perform install tasks.
        module_invoke($module, 'install');

        // Record the fact that it was installed.
        $modules_installed[] = $module;
        watchdog('system', '%module module installed.', array(
          '%module' => $module,
        ), WATCHDOG_INFO);

      // Enable the module.
      module_invoke($module, 'enable');

      // Record the fact that it was enabled.
      $modules_enabled[] = $module;
      watchdog('system', '%module module enabled.', array(
        '%module' => $module,
      ), WATCHDOG_INFO);

  // If any modules were newly installed, invoke hook_modules_installed().
  if (!empty($modules_installed)) {
    module_invoke_all('modules_installed', $modules_installed);

  // If any modules were newly enabled, invoke hook_modules_enabled().
  if (!empty($modules_enabled)) {
    module_invoke_all('modules_enabled', $modules_enabled);
  return TRUE;


alberto56’s picture

What is the equivalent in D8?

xmacinfo’s picture

This is what I am using in a hook_install to install a list of modules :

\Drupal::moduleHandler()->install($module_list, FALSE);

aaronbauman’s picture

Use \Drupal::service('module_installer')->install($module_list, $enable_dependencies)
see comment below.

alberto56’s picture

Here is the reference to ModuleHandler::install in D8. Regarding @xmacinfo's solution, make sure you use FALSE only if you want to skip dependencies. In my experience, generally you will want to use TRUE instead, thus enabling all dependencies.

Anonymous’s picture

It is now handled by the 'module_installer' service in D8:

\Drupal::service('module_installer')->install($module_list, $enable_dependencies);

See the change record.

aubjr_drupal’s picture

A maintainer of this page needs to change that "string[] $module_list:" to "array $module_list:".

That can lead to some confusion because passing just a string (ex. a single module's name) into module_enable() doesn't work, and it doesn't return any "expected array - received a string" type of Drupal/PHP warning. It just silently fails to enable the module.

The same should probably be done for module_disable() as well.

ZeiP’s picture

The parameter description string[] refers to an array of strings, so it is correct. The brackets indicate that it is an array with elements of the specified type.