Jump to content

Drupal

From ZelocoreCMS Wiki
Revision as of 22:50, 28 July 2026 by Digiwayen (talk | contribs) (Publishing comprehensive CMS article)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

🤝 Community Page — This page is maintained by the ZelocoreCMS community. Information may not reflect the latest official details. If you are the official CMS owner, claim your page to manage it officially.

Drupal
Status 🤝 Community
Type CMS / CMF
License GPL v2
Language PHP
Database MySQL / PostgreSQL / SQLite
Latest Version 10.3
Release Date January 15, 2001
Website Official Site
GitHub Repository

Drupal is a free, open-source content management system (CMS) and content management framework (CMF) written in PHP and distributed under the GNU General Public License. Drupal provides a robust back-end framework for at least 2.5% of all websites worldwide, ranging from personal blogs to enterprise, corporate, political, and government sites. It is maintained and developed by a community of over 1.3 million members and developers worldwide.

Known for its modular architecture, granular access control, and powerful content modeling capabilities, Drupal serves both as a traditional monolithic CMS and as a modern headless or decoupled CMS.

Overview

Drupal is designed to allow site builders and developers to construct complex, content-rich websites without needing to rewrite fundamental web architectures. Unlike platforms focused strictly on blogging, Drupal operates as a true Content Management Framework (CMF), providing a set of core services and APIs that developers can extend.

The platform is structured around a modular paradigm where functionality is extended through core and contributed modules. Content is represented as abstract data entities composed of configurable fields, allowing for arbitrary schema design. Drupal's permission system features fine-grained access control, enabling administrators to define role-based permissions down to individual content types, fields, and operational actions.

Drupal is widely favored by large organizations, higher education institutions, governments, and global media corporations due to its security standards, scalability, and ability to handle high volumes of concurrent traffic and complex data structures.

History

Drupal was originally created in 2000 by Belgian computer scientist Dries Buytaert as an internal message board for students at Ghent University. The name "Drupal" derives from the Dutch word druppel, which translates to "drop" in English. When Buytaert launched the project website in 2001, he accidentally misspelled the domain name as "drop.org" instead of "dorp" (Dutch for "village"), and the project eventually took its permanent name from the Dutch word for raindrop.

Key milestones in the history of Drupal include:

  • Drupal 1.0–4.0 (2001–2002): Initial releases focused on basic message board features, user accounts, and topic indexing.
  • Drupal 4.6–5.0 (2005–2007): Introduced the Form API, taxonomy system improvements, and custom module hooks, establishing Drupal as a major open-source web application platform.
  • Drupal 6 (2008): Enhanced user experience, multilingual foundations, and developer APIs.
  • Drupal 7 (2011): A landmark release that introduced the Field API into core, redesigned the administrative interface, and significantly expanded the module ecosystem. Drupal 7 remained supported for over a decade due to its wide adoption.
  • Drupal 8 (2015): A revolutionary paradigm shift in Drupal's architecture. The codebase was re-architected to incorporate modern object-oriented PHP practices, adopting components from the Symfony framework, the Twig templating engine, and built-in configuration management.
  • Drupal 9 (2020): Transitioned to a continuous upgrade model, matching Symfony dependency cycles and removing deprecated code without requiring total site rewrites.
  • Drupal 10 (2022–2024): Introduced release 10.3, featuring the Olivero front-end theme, Claro administration theme, CKEditor 5 integration, automated updates initiatives, and support for modern PHP 8.1+ environments.

Key Features

Content Types

Drupal enables administrators to define custom content types (such as Articles, Products, Events, or Case Studies) without editing code. Each content type can be customized with various field types, including text, media, taxonomy references, entity references, and dates.

Views

The Views module—fully integrated into Drupal core—is a visual query builder that allows site builders to fetch, filter, format, and display entities across the website. Views can output content as lists, tables, grids, RSS feeds, JSON endpoints, or interactive blocks.

Blocks

Drupal uses a region-based UI block system to place static or dynamic content into specific regions defined by the active theme. The core Layout Builder further expands this by providing a drag-and-drop visual interface for creating custom page layouts for individual nodes or entire content types.

Entity System

At the core of Drupal's data layer is the Entity API. Everything in Drupal—including content nodes, taxonomy terms, user profiles, media items, comments, and block instances—is an entity. Entities can be content entities (storing dynamic data) or configuration entities (storing site settings and structural definitions).

Multilingual

Drupal features built-in internationalization (i18n). Out of the box, sites can translate content entities, interface strings, taxonomy terms, and configuration files into over 100 languages with automated translation file fetching.

REST API

Drupal core includes native support for RESTful Web Services and the JSON:API specification. Any entity in Drupal can be automatically exposed via standard HTTP methods (GET, POST, PATCH, DELETE) with complete adherence to security and field-level permissions.

Architecture

Symfony Components

Since version 8, Drupal relies heavily on component libraries from the Symfony PHP framework. Core infrastructure utilizes Symfony components such as:

  • `HttpFoundation` for HTTP request/response modeling
  • `HttpKernel` for handling the application request lifecycle
  • `EventDispatcher` for event-driven hook architectures
  • `DependencyInjection` for service containers and inversion of control
  • `Routing` for URL matching and controller dispatching

Plugin System

Drupal's Plugin system provides reusable units of functionality. Plugins are defined using PHP attributes or annotations, allowing modules to expose extendable components like block types, field formatters, view displays, and migrate source plugins cleanly without relying solely on legacy procedural hooks.

Entity API

The Entity API abstracts database operations into Object-Relational Mapping (ORM) paradigms. Content items are instantiated as PHP objects, providing standardized methods (`save()`, `delete()`, `label()`) and unified QueryBuilder tools (`EntityQuery`) to query content independently of the underlying database system.

Theme Layer

Drupal's front-end rendering uses a render array pipeline (nested array representations of HTML) combined with preprocess functions and the Twig templating engine. This separation guarantees secure output generation and flexible template overriding across theme inheritance chains.

Modules

Module Ecosystem

Drupal's functionality is divided into three tiers of modules:

  1. Core Modules: Maintained directly by the Drupal project team and shipped with every installation.
  2. Contributed (Contrib) Modules: Community-developed add-ons hosted on the official `drupal.org` repository and installed using Composer.
  3. Custom Modules: Site-specific code written by developers to fulfill unique business logic.

Key Modules

  • Views: Integrated into core, enabling complex dynamic database query displays.
  • Token: Provides a universal framework for text replacement tokens (e.g., `[node:title]`, `[site:name]`).
  • Pathauto: Automatically generates search-engine-optimized (SEO) URL aliases based on configurable token patterns.
  • Webform: A full-featured form builder and submission management framework used for surveys, contact forms, and complex workflow applications.

Themes

Twig Templating

Drupal uses Twig, an open-source PHP template engine created by SensioLabs. Twig separates application logic from presentation templates, enforcing clean `.html.twig` syntax and automatic HTML escaping to protect against Cross-Site Scripting (XSS) vulnerabilities.

Claro Admin Theme

Claro is Drupal's modern, accessible administration theme designed to comply with WCAG 2.1 AA standards. It offers an intuitive visual layout, responsive administration controls, and refined touch targets for mobile administration.

  • Olivero: The modern, accessible front-end core theme featuring clean typography and responsive design.
  • Radix / Barrio: Starter base themes providing integration with modern CSS frameworks such as Bootstrap and Tailwind CSS.
  • Zen & Classy: Flexible base starter themes used as clean foundation layouts for custom enterprise theme development.

Drupal as Headless CMS

Drupal can be deployed in a decoupled (headless) architecture, serving as a headless content store while front-end applications are built using JavaScript frameworks like React, Vue.js, Next.js, or Nuxt.js.

Configurations include:

  • Fully Decoupled: Drupal acts strictly as a back-end content API (via JSON:API or GraphQL), while front-end rendering and routing are completely handled by a client-side or SSR application.
  • Progressively Decoupled: Drupal handles overall page rendering and layout, while embedding interactive JavaScript widgets or Single Page Applications (SPAs) into specific page regions or blocks.

Decoupled Drupal leverages built-in OAuth2 support (via Simple OAuth), allowing secure cross-domain authentication and seamless content syndication across web, mobile apps, digital signage, and IoT devices.

Enterprise Use Cases

Drupal is widely chosen for mission-critical enterprise applications:

  • Government & Public Sector: Used by the U.S. Department of Veterans Affairs, the Australian Government (GovCMS), and numerous European state platforms requiring strict security and accessibility compliance.
  • Higher Education: Deployed across major universities including Harvard, Oxford, and MIT to manage multi-departmental sites via Drupal Multisite architecture.
  • Media & Publishing: Employed by high-traffic outlets like NBC Sports, BBC, and major news networks to distribute real-time content at massive scale.
  • Global Enterprises: Utilized by corporations like General Electric, Pfizer, and Lufthansa for multi-brand and multilingual global web ecosystems.

Security

Drupal Security Team

The Drupal project maintains a dedicated, international Security Team consisting of security experts who review contrib modules, investigate reported vulnerabilities, and coordinate security releases. Security advisories are published predictably every Wednesday ("Security Wednesday"), accompanied by patch releases.

Update Process

Modern Drupal installations utilize Composer for dependency management, ensuring clean updates of core code, libraries, and modules. Administrators update database schemas using the built-in update tool (`update.php`) or the Drush command-line tool (`drush updatedb`). The ongoing Automatic Updates initiative aims to provide one-click background security updates directly from the admin dashboard.

Comparison

Drupal vs WordPress

Feature Drupal WordPress
Target Audience Enterprise, developers, complex data architecture Small businesses, bloggers, general site owners
Learning Curve Steeper; requires understanding of entities and OOP concepts Gentler; low barrier to entry for non-technical users
Content Modeling Advanced out-of-the-box entity and field customization Basic posts/pages by default; relies on custom post type plugins
Out-of-the-box Security Exceptionally strong; dedicated Security Team oversight Strong, but larger attack surface due to unvetted plugin ecosystem
Multilingual Support Built into core across all content and configuration Requires third-party plugins (e.g., WPML, Polylang)

Drupal vs Joomla

Feature Drupal Joomla
Architecture Object-oriented, Symfony component integration Model-View-Controller (MVC) pattern
Extensibility Unified Entity API and robust plugin architecture Component / Module / Plugin multi-tier architecture
Developer Adoption Strong enterprise developer community and CLI tools (Drush) Moderate developer ecosystem focused on mid-tier sites
API Integration Native JSON:API, REST, and GraphQL integration Built-in Web Services API in Joomla 4+
Retrieved from "https://zelocorecms.org/index.php?title=Drupal&oldid=46"