Basic structure of Drupal

Classes for annotation discovery and implementation of annotation plugins. Annotations are the appropriately formatted descriptions in the comments of classes that use certain tags such as @return, @param, and @see. The parser is based on the parser from the Doctrine project.

Provides helper functionality for runtime assertions.

Defines a bridge between the Laminas service manager to Symfony container.

Provides a class finding utility.

Wraps the PHP DateTime class with more flexible initialization parameters, allowing a date to be created from an existing date object, a timestamp, a string with an unknown format, a string with a known format, or an array of date parts. It also adds an errors  array and a __toString() method to the date object.

Dependency Injection container optimized for Drupal's needs.

Uses Diff engine based on PERL Algorithm::Diff that computes 'intelligent'' differences between two files or lists.

Provides an interface for providing a type of class discovery and classes for discovery of YAML files.

Provides a forward-compatibility layer for the Symfony 5 event class. Symfony 5 relies on the  Symfony\Contracts\EventDispatcher\Event class. In order to prepare for updates, code that wishes to extend Symfony's Event class should extend this intermediary class, which will handle switching from Symfony\Component to Symfony\Contracts without a further change.

Handles the caching of data based on file modification dates.

Provides methods for .htaccess and web.config files.

Provides a regex file iterator and a helper for temporary directories.

Component for parsing front matter from a source. Front matter is used as a way to provide additional static data associated with a source without affecting the contents of the source. Typically this is used in templates to denote special handling or categorization. Front matter must be the first thing in the source and must take the form of valid YAML set in between triple-hyphen lines.

PHP library for the GNU gettext project. The GNU gettext utilities are a set of tools that provides a framework within which other free packages may produce multi-lingual messages.

Directed acyclic graph manipulation.

Provides a common base class for safe redirects.

Stores and loads PHP code.

Base building blocks for a scalable and extensible plug-in system for PHP components and application framework extensions.

Provides a lightweight mechanism to provide lazy loaded proxies.

Renders placeholder variables for HTML and plain-text display.

Base serialization for JSON, PHP, and YAML.

Classes for mapping from one system of writing to another. Based loosely on the utfnormal class from the Wikimedia project.

Mostly static utility classes for string, xss, array, image, and other commonly needed manipulations.

UUID generation and validation.

Utility classes for processing Drupal specific version information.

Route access control. See the Entity API section on "Access checking on entities", and the Node access API reference, and the access section of the Routing system documentation.

Action entity plugin.

Ajax is the process of dynamically updating parts of a page's HTML based on data from the server. When a specified event takes place, a PHP callback is triggered, which performs server-side logic and may return updated markup or JavaScript commands to run. After the return, the browser runs the JavaScript or updates the markup on the fly, with no full page refresh necessary.

Building on the Annotation Component, this provides annotations for class discovery and metadata description. The Drupal plugin system has a set of reusable components that developers can use, override, and extend in their modules. Most of the plugins use annotations, which let classes register themselves as plugins and describe their metadata. (Annotations can also be used for other purposes, though at the moment, Drupal only uses them for the plugin system.)

Handles the tar and zip archiving tools.

Handles the library, CSS, and JavaScript asset collections.

Handles authentication services using an authentication manager.

Batch functions allow forms processing to be spread out over several page requests, thus ensuring that the processing does not get interrupted because of a PHP timeout, while allowing the user to receive feedback on the progress of the ongoing operations. The API is primarily designed to integrate nicely with the Form API workflow, but can also be used by non-Form API scripts (like update.php) or even simple page callbacks.

Blocks in Drupal 8 are made up of two separate API structures: the Block Plugin API and the Block Entity API. The Block Plugin API is a stand-alone reusable API and the Block Entity API addresses use cases for block placement and visibility control.

Handles breadcrumb building and caching.

The Cache API is used to store data that takes a long time to compute. Caching can either be permanent or valid only for a certain timespan, and the cache can contain any type of data.

Simple cache decorator interface.

Wrappers for console command component for various commands, including database dump, database import, generate proxy, install Drupal site, quick start to run a Drupal web server, and the running of a PHP web server.

Provides static functions for composer script events.

Handles what conditions are active in certain contexts.

The configuration API provides a central place for modules to store configuration data. This data can be simple configuration like your site name, or more complex information managed with configuration entities, such as views and content types. Configuration is a place to store information that you would want to synchronize from development to production. This information is often created  during site-building and is not typically generated by regular users during normal site operation.

Base classes for thin controllers, form controllers, and a title resolver interface for generating the title from a given route.

Drupal's database abstraction layer provides a unified database query API that can query different underlying databases. It is built upon PHP's PDO (PHP Data Objects) database API, and inherits much of its syntax and semantics. Besides providing a unified API for database queries, the database abstraction layer also provides a structured way to construct complex queries, and it protects the database by using good security practices.

Building on the Datetime Component, this provides base classes for date list and datetime elements, date format entity, timestamp widget plugin, date formatter, and formatted date diff.

Building on the Dependency Injection Component, this provides classes for compiler handling of dependency injection. It also has classes for dependency injection for containers, serialization, YAML files, and service providers.

Building on the Diff Component, this provides a Diff Formatter class.

Based on the Discovery Component, this provides a decode method for YAML files.

Display variant plugins, interfaces, and classes to determine display of output in Drupal.

The Entity System is the API for entities manipulation (CRUD: create, read, update, delete). Entity types in core come in two variants - Configuration Entity and Content Entity. The extensive Entity System is arguably at the core of the Drupal's unsurpassed flexibility as a CMS.

Building on Symfony's and Drupal's EventDispathcher Component, this manages and validates subscribed events.

Interfaces and abstract classes for executable plugins.

Base classes for managing Drupal extensions like modules and themes. Also some helper classes like parsers for info files.

Extensive base classes, interfaces, and plugins for different types of fields and for their formatting.

Building on FileSystem Component and PHP file functions, numerous helper functions to manage files.

Manage file transfer via FTP and SSH.

Interface and base classes for handling flood control, e.g. too many login attempts.

Form classes implement the \Drupal\Core\Form\FormInterface and the basic workflow of a form is defined by the buildForm, validateForm, and submitForm methods of the interface.

Numerous exception classes and some factory, helper, and bridge classes for managing HTTP requests.

Wrapper classes for handling image objects from image files.

An image toolkit provides common image file manipulations like scaling, cropping, and rotating. Provides base classes, interfaces, and management classes.

Installation classes for services, route builders, module extensions, theme extensions, and a kernel installer for handling Drupal installations.

Interfaces, factory, memory, and database classes for key-value storage.

Interfaces and base classes for i18n multilingual support for websites.

Plugin, interfaces and base classes for layout of regions in a display page.

Handles country codes.

Handles database locking.

The Logging API is object oriented and PSR-3 compatible.

Handles Drupal's default mail backend using PHP's native mail function.

The association of a path with a controller, coupled with parameter upcasting and access checking, is handled in the routing system. This system serves as a basis for path access on a Drupal site. The Drupal menu system is a collection of different APIs for menu items defined by modules as well as local tasks, actions and contextual links.

Stores runtime messages sent out to individual users on the page.

Implements policy rules for caching of page content.

Interfaces and base classes for the pages when there are multiple pages to be managed.

Responsible for converting a path parameter to the object it represents. An example is for the path: /admin/structure/block/manage/{block}. In this case, '{block}' would be the path parameter which should be turned into a block object representing the block in question. ParamConverters are defined as services tagged with 'paramconverter', and are managed by the 'paramconverter_manager' service. 

Secure password hashing functions for user authentication along with a password generator.

Validators and path matcher for URL paths.

Managing and decoding the inbound and outbound URL paths.

Factory for instantiating storage for generated PHP code.

The Drupal Plugin API allows a module or subsystem to provide functionality (plugin instances) in an object-oriented way. Plugins that perform similar functionality are of the same plugin type. Module developers write plugins to extend various systems like blocks, field widgets, and image effects and add new options for administrators to choose from. 

Class to extend the
proxy builder component by using the DependencySerializationTrait.

Proxy classes for numerous different functionalities including batch storage, module install, database lock, bare HTML page render, and route builder.

Implements a queue type of data structure for Drupal that includes a queue factory and classes for garbage collection, database factory queue, queue in memory, and batches. 

Drupal's Render API roughly consists of two parts: (1) the render pipeline — which is format-agnostic (HTML, JSON, anything) and (2) render arrays, which are a representation of a HTML page. They allow nesting (like HTML) and altering (necessary for Drupal's flexibility). 

Based on Symfony's routing classes, this processes outbound routes for priority and other considerations.

A route is a path which is defined for Drupal to return some sort of content on. For example, the default front page is a route. When Drupal receives a request, it tries to match the requested path to a route it knows about. If the route is found, then the route's  definition is used to return content. Otherwise, Drupal returns a 404. Drupal 8's routing system is heavily based on Symfony's. Drupal's routing system can do everything Symfony's can (and more), and both use the same syntax to define routes.

Classes for sanitizing user input and concerning the trustworthiness of callbacks.

The Serialization API is largely based on the Drupal Serialization Component, which is a wrapper for the Symofny Serializer Component. The Drupal Core Serialization module then builds on the Serialization API.

Manages user session data, including permissions and securely switching between accounts.

Handles site settings and maintenance mode.

Drupal 8 has a Middleware API that is adapted from the the StackPHP project (https://github.com/stackphp). StackPHP builds on top of Symfony's HttpKernelInterface and is a convention for composing HttpKernelInterface middleware. 

The State API is simple system for the storage of information about the system's state. The information is stored in the database and will be lost when the database is dropped or the site is re-installed from configuration. For storing data which needs to be edited by humans or needs to be shared between environments use the Configuration API. 

Wrappers for handling file streaming for public, private, and local files.

When you include text in code, and the text will be displayed in the Drupal user interface, it needs to be internationalized (prepared properly) so that it can be localized (translated), so that users can make Drupal sites that are completely displayed in different languages. In Drupal, all interface text must use English as its default language. Also, the project uses automatic mechanisms to  extract translatable text strings from the code base, so that translation teams can use Drupal translations to translate the text of  Drupal Core and contributed projects. 

Handles template files by managing twig storage, extensions, environment and policies as well as attributes in the template files. 

Private and shared non-cached temporary storage of data that is that available across requests. 

Base classes, interfaces, and traits for testing the Drupal core and subsystems. 

Handles Drupal themes with a registry, theme manager, theme negotiator, and theme access check. 

Enhances PhpTransliteration component with an alter hook. 

PHP is a very loosely typed language. It doesn’t have a clear definition of the different types of data it deals with. The Typed Data API provides developers a consistent way of interacting with data and also provides means of fetching metadata about the actual data. 

The Update API allows modules to provide code that will update their data models between minor versions and releases within one major version (that is, between different software/data versions all within Drupal 8+). 

For updating modules and themes. 

Various utility classes, including for link generation, error processing, table sorting, theme registry, token and URL assembly. 

Entity validation is a separate Entity validation API that is decoupled from form validation. Decoupling entity validation from forms allows validation entities to be independent of form submissions, such as when changed via the RESTful web service. The validation API implementation is based on the Symfony validator.