Glossary

Technology and processes that ensure interactive experiences are available to the widest possible audience. Each project will have its own accessibility requirements, usually corresponding to a set of public standards.

We track the control panel’s conformance with WCAG 2.2 AA criteria, and provide flexible content modeling and templating tools that grant precise control over the structure and substance of all user-facing markup.

A specific controller method triggered during a web or console request.

Element type specifically designed for storing location information, belonging to a user.

Part of Craft Commerce’s order totaling system that underpins discounts, tax, shipping, and other costs. Adjustments are always tied to an order, and may be associated with a specific line item.

User with unrestricted access to content and settings.

Special strings beginning with an @ that stand in for partial or complete paths or URIs.

Popular and highly configurable HTTP server.

Element type that tracks a single file within a volume.

Native named and typed value on an object, oftentimes held by a class property.

Entries can have one or more user elements attached. When creating a new entry, the current user is assigned as its author.

Typically used alongside “front end” to delineate privileged spaces (like the control panel) or low-level software (like a database) that powers a website.

Craft captures database backups when performing updates and applying migrations. You can manually capture a backup from the control panel or CLI.

Craft Cloud also provides automatic and manual database backups.

Functionality attached to another object at runtime, often provided by a plugin.

General-purpose temporary data storage used to reduce or avoid expensive, repetitive computational tasks. Craft supports file, database, redis, and Memcached cache drivers.

A designation given to elements that are not drafts or revisions of another element. Provisional (or “unsaved”) drafts can be canonical elements prior to being saved for the first time.

Craft Commerce’s order element is used to represent the content of a customer’s cart, prior to (and during) checkout.

Every price for a variant in Craft Commerce is determined via the pricing catalog engine. This system is flexible enough to handle all kinds of dynamic pricing conditions, from timed promotions to wholesaling.

The pricing catalog determines the base prices shown to customers; discounts provide an additional layer of control for purchasables in a cart.

Element type appropriate for hierarchical taxonomies. Most features of categories can be replicated with entries.

Organizational unit for category elements, defining their name, handle, and field layout.

One of the three section types, best suited for lists or catalogs of content that are always ordered by one or more properties, and flat, tag-like taxonomies.

Our first-party rich text editor that supports nested entries for fluid composition.

A text-based interface to Craft, accessed via your computer’s terminal program. It provides a powerful suite of tools for developers, like user moderation, search indexing, migrations, and an updater.

Craft is a content management system, or collection of tools designed for publishing multimedia across a number of channels.

Craft returns Laravel Collections in place of arrays in some circumstances. They can be used just like arrays in your templates, but have a number of methods attached to streamline common tasks.

Sometimes used interchangeably with (or as a superset of) models, components in Craft represent instantiable or configurable objects. Services, entry types, widgets, and filesystems are all examples of components you’ll encounter in the control panel that also provide points of extension.

Components are also the foundation of Yii’s events system.

The PHP package manager used by every Craft project.

An individual rule that is part of a condition builder. The available conditions for a given builder depend on the type of element it will be used to match against.

A graphical interface that allows Control Panel users to filter or match sets of elements by combining conditions. Craft uses these on element indices (to search and define custom sources), as well as field layouts (to determine tab and field visibility).

The collection of code, state, and settings that together determine how Craft behaves. Config includes settings determined by general.php, app.php, project config, environment overrides, and CLI flags.

A single action available via the CLI. To view the available commands, arguments, and options, run php craft help in your terminal.

The text, options, and media users have added as elements, via the control panel or front end.

A special type of PHP class that processes an HTTP or console request and returns a response.

Craft’s built-in administration interface that requires an active user account to access. Most content authoring and schema design happens here.

The first-party hosting platform for Craft CMS. Learn more about Craft Cloud.

Our self-hosted CMS product, which gave rise to Craft Console, Craft Cloud, the Plugin Store, and more!

Our powerful, first-party ecommerce plugin. Learn more about Craft Commerce.

The centralized platform for license management, the plugin store, and Craft Cloud projects.

Craft has a special distinction for users who are able to log in or may be able to log in under their own power. Any user in the Active or Pending status is also considered credentialed.

Cross-site request forgery tokens help keep Craft secure by mandating that every POST request (like a user logging in, or someone updating an entry) contains a secure value matching that user’s session.

In Craft Commerce, a collection of enhancements to Craft’s built-in user element that makes it easier to work with orders, addresses, payment methods, and so on.

Control Panel users each have their own customizable landing page. You can add and arrange any number of built-in or plugin-provided widgets to suit your use.

Craft uses a MySQL or Postgres database to store and retrieve your content. Databases underpin many of Craft’s powerful and highly-optimized query and relational features.

Our recommended local development environment, based on Docker.

The process of applying changes to code and configuration to a remote environment for testing or public release. Deployments also typically involve applying migrations and project config.

A message logged at runtime alerting developers that they are using a feature that is scheduled to be removed from Craft (or a plugin) in a future version. You can view deprecation warnings in the control panel by visiting the Deprecation Warnings utility.

An element that was split (or “derived”) from a canonical element. Drafts and revisions are examples of derivative elements.

A special setting for development environments that enables verbose logging, profiling, and error reporting. It can be enabled via the devMode config setting, or by setting CRAFT_DEV_MODE=true in your .env file.

A directory contains files and other directories. Traditional filesystems often use this interchangeably with folder. Every Craft project contains a number of nested directories, each with a specific purpose.

A built-in adjuster that applies special pricing to items in a customer’s cart.

A popular containerization engine that simplifies development and deployment of Craft projects by providing stable, replicable services and configuration. Our recommended development environment, DDEV, is based on Docker, as are many modern “platform-as-a-service” products.

One of the default purchasable implementations provided by Craft Commerce. Customers can define their own “amount” when adding a donation to their cart.

Edits to a canonical element that have been automatically saved (or explicitly saved with a temporary name). Drafts can be applied to the element they were derived from.

An element query optimization feature that loads sets of nested or related elements together. It is commonly used to avoid N+1 problems.

Craft (and many plugins) use editions to provide different functionality at different price-points. Licenses are tied to specific editions; new Craft projects use the free Solo edition, and can be upgraded to Team or Pro at any time. Some plugins may require specific Craft editions.

The core unit of content in a Craft application, usually encountered as one of the built-in element types.

A table or grid of elements in the control panel (often separated into sources) designed for finding elements to edit, or attaching elements to a relational field. Matrix fields also provide a streamlined “element index” View mode for managing nested entries.

An extension of the base database query class, tailored for loading a specific type of element. Element queries expose methods for narrowing results by custom field values, relations, and search keywords.

An implementation of the generic element interface, distinguished by special methods, properties, or management tools. Craft includes seven primary, built-in element types (addresses, assets, categories, entries, global sets, tags, and users), which many plugins supplement.

The primary status control for element. Unless explicitly configured otherwise, element queries only return enabled elements, and an element must be enabled for Craft to respond at its URI.

As the capabilities of entries grow, we have gradually recommended their use over global sets, categories, and tags. Craft 5.0 was the first release to remove an element type, by consolidating the “Matrix block” element type into nested elements.

One of Craft’s built-in element types, and the most flexible content container. Entries can belong to a section or owned by another entry via a Matrix or CKEditor field.

Globally-configured content types that can be selected from sections, Matrix fields, and CKEditor fields. Entries’ field layouts are defined via enrtry types.

Values read from a server’s environment or a .env file at the root of your project. Environment variables can be used to dynamically resolve some config values, or directly override specific settings like database connection details.

When there is a problem serving a request, Craft reports the issue as an exception in the logs (with the error level), as well as a stack trace (when dev mode is on), a succinct message (for user-facing exceptions), or a generic “server error” when no additional information is available or suitable.

Emitted by many system components and models as certain actions take place, providing plugins an opportunity to extend, customize, or prevent certain behavior.

An error raised by the system at runtime. Exceptions always include a message and are logged by Craft, but only some are surfaced to users. When Dev Mode is on, Craft displays a full exception view and stack trace.

An instance of a field type attached to a field layout. Sometimes referred to as custom fields, they are the foundation of your content schema.

A group of tabs, field layout elements, and conditions that govern the authoring experience for a particular type of element. Field layouts are configured on entry types, category groups, tag groups, global sets, and other system components that implement craft\base\FieldLayoutProviderInterface.

Custom fields, native properties, and other features are added to a field layouts and displayed based on conditions.

When defining custom fields for a project, you choose from the registered field types, which provide distinct user interfaces and storage mechanisms. Examples of built-in field types are: Plain Text, Entries, Dropdown, and Matrix. The field type determines what kind of value it stores, and how you use that value in templates.

Adapter for asset storage on various media like a local disk (a traditional computer “filesystem”) or cloud bucket (a proprietary API). Each volume is tied to a filesystem, but any underlying differences are standardized by Craft into a single file management interface.

Twig language feature that operates on and returns a value, accepting optional arguments to customize behavior.

Filter is also used in conjunction with Yii’s request middleware, action filters.

A message held in the session for display on a subsequent request. Flashes are typically keyed as notice or error, and (in addition to the HTTP response code) contain information about the result of a POST request. You may encounter flashes when working with Craft’s actions via a front-end forms.

HTML element that can submit data in an HTTP GET or POST request. Forms are used to submit data from your front end to Craft’s controller actions.

Often used to describe the public-facing portion of a website, viewed in a browser, or to differentiate from privileged back end resources, like the control panel.

Twig language feature that accepts arguments and (usually) returns a value.

A periodic process triggered by the system to cull dangling records and trashed elements from the database.

Virtual “fields” added to elements via their field layout provider, whose values are computed from an object template instead of direct editing. Generated fields can be used in templates via their handle, or as element query params.

Our first-party code generation extension can scaffold plugins, modules, Craft system components, and more.

One of Craft’s built-in element types, designed to hold content that is used in many places throughout a site, or which is not strictly owned by another page or record.

Model for delegating access to (or responsibility for) content, processes, and other system functions. This is most often associated with user groups and permissions, but may involve other, complex field-level conditions.

A popular query language designed for decoupled or “headless” front-ends. You can expose your content via Craft’s built-in GraphQL API using schemas and tokens.

A stable, human-readable, alphanumeric identifier for many configurable system components. Handles are used on custom fields, entry types, sections, category groups, and more. They are often referenced from templates in element queries or conditional statements.

Handles and slugs have many similarities, but slugs are typically defined as content by authors, and may change.

Website and app front-ends that are not rendered by a server are sometimes referred to as “headless” or “decoupled.” A headless site might use Craft as an API-only CMS, via GraphQL, the Element API plugin, or custom controllers.

Event-like extension point in the view layer, allowing modification of the context’s variables, as well as direct output when rendering a template.

Hardware, software, and other infrastructure typically rented from a provider for storing your site’s content and code, and handling requests from visitors.

Craft Cloud is our first-party hosting platform.

The process of localizing interfaces and labels for the user. Combined with translations, you can create fully-localized front end and control panel experiences.

A single item in the queue. Jobs leave the queue once they are completed, but remain if they fail so that they can be retried later.

Informally, a layout is a template extended by a child. It might contain high-level HTML tags like the <head> and define blocks that the child can inject content into.

Craft doesn’t make any assumptions about how your templates are structured, so you won’t see any references to layouts in the control panel; you can also have multiple layouts in a single project (and choose between them in each template), or establish a chain of inheritance (say, to use a consistent header and footer but switch between general structures for the main content of pages).

One of Craft’s built-in image transform options. Images are resized to fit within the defined width and height, with the remaining space becoming a “mat” of the chosen color.

Terms that govern your use of Craft (or a plugin). Every Craft install is “licensed,” but use of the Team and Pro editions require payment.

One of Craft’s built-in field types, which uses a “switch” or toggle UI and stores its value as a boolean.

Craft Commerce’s representation of a purchasable in a customer’s cart (or order), including quantity, adjusters, custom options, notes, and more.

A feature available to most element types that lets authors preview changes in a simplified side-by-side editor. Developers can configure each type of content with multiple preview targets.

Another word used to describe the process of internationalization or translation.

Some information, warnings, and errors emitted at runtime are sent to one or more log targets for later review. At a minimum, this is typically a record of a request having been processed, along with the path, HTTP status code, and memory usage statistics. When Dev Mode is enabled, logs contain additional context and are extremely verbose.

A plain-text format that supports basic structure and style instructions, often processed into HTML. You can parse Markdown stored in a custom field using the md filter.

A field type that manages a set of nested entries.

This may refer to the HTTP request verb (like GET and POST) you use in conjunction with an HTML form, or a function member of a PHP class.

Craft (and many plugins) periodically need to make changes to the structure of the database. It does so through special PHP classes called migrations, which run exactly once in each environment.

A lightweight container for configuration, data, and validation rules. Some models are saved to the database as records, while others are serialized to project config.

A bundle of custom functionality (like Controllers, Event handlers, and Behaviors) tied to a project. Plugins are a special kind of module, intended for distribution via the Plugin Store.

Craft’s system for acquiring “mutually exclusive” locks across multiple requests and servers. This helps prevent concurrent writes and other mishaps when there are many authors using the control panel—and supports advanced features like making payments and deducting inventory in Craft Commerce!

One of Craft’s supported database engines, and the default for new projects created with DDEV.

An element owned by another element, often within a specific field. Addresses are nested elements, as are the entries within Matrix and CKEditor fields.

Craft Commerce also uses nested elements for variants.

A popular HTTP server and reverse proxy. Special configuration is required to pass enough information to PHP for Craft to work correctly.

Single-line, simplified Twig templates often defined in project config and rendered at runtime. Entry URLs, title formats, and asset subpaths are some examples of settings that are evaluated as object templates.

One of the element types provided by Craft Commerce, which represents incomplete carts and finalized orders, and contains line items, addresses, payment transactions, status history, custom field data, and more.

An object template that is evaluated when a cart is turned into an order to create a unique, custom identifier.

In Craft Console, you can collaborate with other developers and clients by creating an organization.

Individual developers and agencies in our Partner program enjoy visibility in our official directory, and can be vetted and matched for specific capabilities.

This may refer to the location of a file on disk, a portion of a URI or URL, or the $PATH variable on Unix systems.

Craft’s directory structure is determined by a handful of path constants, and it builds a variety of filesystem paths and URLs using object templates.

Websites and applications often need to test and manipulate text while routing or validating and sanitizing input. Pattern-matching is typically handled using regular expressions.

Pattern may also refer to a component (or collections of components) within a design systems.

Capability granted to a user, directly or via membership in a user group.

An extension to Craft CMS published to the Plugin Store or included in a project, privately.

The first-party publishing, discovery, and licensing platform for Craft CMS extensions.

One of Craft’s supported database engines.

Developers may define any number of locations that an element can be previewed, alongside its main URI format.

An element type provided by Craft Commerce that contains one or more variants, custom field content, and organizational information.

Customizable definitions for broad “types” of products that determine the number of supported variants, localization settings, and define field layouts for products and variants.

We often refer to any individual Craft installation as a project, instead of a site (of which a project may have many). This holds true for Craft Cloud, as well—each paid plan, trial, and sandbox is a project, within Craft Console.

Projects are often backed by a git repository and tied to a license.

Craft’s system for tracking changes to a project’s content schema and settings. Project Config is updated any time you change settings in the control panel, and should be applied to other environments when you integrate code or deploy.

Elements (and their field values) have a variety of settings that determine how content is created and synchronized across sites and site groups.

Changes to an element that have not been explicitly saved are stored in a special draft visible only to you. Those edits can be discarded, applied to the canonical element, or saved as a named draft.

The base element type provided by Craft Commerce underpinning all items that can be added to a cart. variants and donations are the two built-in purchasables, but plugins can provide others (like a ticket, membership, or license).

Craft loads content and configuration from the database via queries. A query is constructed from criteria in an abstract way, then translated into the language the database understands before execution.

The most common kind of query you will use in Craft is an element query.

Portion of a URL containing key-value parameters, following a ?. Craft uses query strings to add context to URLs (like ?draftId=1 on an element edit screen), and provides access to them from templates (via craft.app.request.getQueryParam('searchKeywords')), allowing front end pages to react to additional parameters, like faceted search.

Long-running or low-priority tasks (called jobs) can be delegated to a background task runner so the HTTP server is free to send a response to the client.

Models that are saved to the database often use an intermediate record to marshal fields or columns into a single table. Saving an element (or other complex objects like sections and sites) may involve multiple models, tables, and records.

Popular key-value database that Craft can use for caches, user sessions, and mutex locks.

Simple syntax for loading and interpolating values from other elements into another string. A reference tag always includes the element type and an identifier, and may specify a property or getter method. If no property is requested, Craft replaces the tag with the element’s URL. To parse references in a piece of text, pass it to the parseRefs Twig filter.

A connection between two elements defined in a custom field. Related elements are returned by their field handles, and can be used to filter an element query via the .relatedTo() method.

Information about incoming traffic is encapsulated in a request. Craft inspects the request, figures out how to route it, and assembles a response that is sent back to the client.

Not every HTTP request that arrives at your server is necessarily handled by Craft, though! Typically, files in your web root are automatically accessible without Craft—and Craft can generate URLs to resources that it may not be involved with serving (like an asset).

Internally, Craft also handles CLI actions as “requests.”

The document and headers returned by an HTTP server. Craft determines most aspects of the response based on information in the request, including any active user session.

An interactive design philosophy or process that involves deep consideration of many devices and modes of access. Combined with accessibility, it provides a framework for delivering your experience to the widest possible audience.

Each time an element is saved, Craft duplicates is previous state into a revision, which can be viewed or restored later. Revisions are a special kind of derivative element, like a draft.

A path or rule that determines how a request is handled. Routes may be defined statically (by Craft itself or via configuration) or dynamically (based on your content architecture). Any request that can’t be matched to a route is considered an error.

Legacy promotion feature of Craft Commerce, replaced by catalog pricing.

Craft automatically indexes your elements and eligible fields so that they can be searched in the control panel and front end. Search terms can be taken from the query string and passed to an element query to provide ranked, on-site results.

Most entries in Craft exist within a section. Sections can be set up as channels, structures, or singles. Each section determines which entry types can exist within it, what sites entries can be created in, and what those entries’ URLs look like.

Craft’s core API is composed of singleton classes, mounted to the main application instance. Yii refers to these as components, a special type of object that accepts deep configuration and supports dependency injection.

Your first exposure to services will likely be in Twig, using features exposed via the craft.app global variable.

Many websites and applications require that context is preserved across multiple requests and responses. A session is opened to keep users logged in, validate form submissions, or track personalizations.

In the control panel, admin users have a great deal of control over Craft’s content model and behavior via the Settings screen. In live environments (or anywhere the allowAdminChanges config option is off), this area is read-only.

One of three section types. Singles are limited to one entry, have a predefined URI, and are never created or deleted by authors—just edited. Most developers use singles for evergreen pages, or as containers for arbitrary content that they may need to access in multiple places throughout a site.

Every Craft project has at least one site. Sites provide a way to localize content for multiple audiences, manage different sitemaps across distinct properties, or some combination of the two. Craft can serve sites at different paths, domains, and subdomains.

Sites can be organized into groups to manage complex localization and propagation rules. Groups do not impose restrictions on their sites’ base URLs or languages.

A human-readable identifier for a piece of content. Slugs are not inherently unique across all elements (or even within a section), but if they’re used as part of a URI format, Craft validates the entire URI’s uniqueness.

Content authors are typically able to update slugs, so they are not a stable identifier for use in hard-coded element queries.

Many records in Craft (including elements and some project config features) are not immediately deleted. Instead, they are marked with a dateDeleted and can be restored within the softDeleteDuration (at which point they may be permanently deleted during garbage collection).

In an element index, sources appear in the sidebar. Each source contains some default criteria or conditions that determine what elements can be displayed therein, as well as information about which view modes and columns to use.

Every element has a status, typically synthesized from its enabled and enabledForSite properties. Entries also use their postDate and expiryDate properties; users eschew enabled for specific moderation flags; Craft Commerce order elements explicitly store custom statuses.

Statuses are represented in the control panel by colored pips, labels, or shapes (when the corresponding accessibility {entry:glossary/user-preference:linkLower} is enabled).

One of three section types. Structures store entries in a hierarchical, ordered “tree.” Entries can be relocated within a structure by dragging-and-dropping on an element index, or by selecting a new Parent on an individual entry’s edit screen.

One of Craft’s built-in element types, best suited for loose folksonomies. Tags are non-hierarchical, and have no implicit order.

A tag is also a Twig language feature, primarily used for logic or control flow.

Tags are created via tag fields, within a predetermined group. Tag groups have a name, handle, and define a field layout.

With very few exceptions, the front end HTML output by a Craft site is the product of Twig templates created by the developer. Templates can have static text, markup, interpolated content, scripts, styles, loops, and other logic of varying complexity. Templates can also include or extend other templates.

The program through which you issue commands on your computer. Terminals can be dedicated applications or integrated into a code editor for convenience. You use a terminal to interact with Craft via its CLI.

This may refer to:

Craft can create and track different optimized versions of image-like assets. Developers configure named transforms via the control panel, or define them ad-hoc in templates.

Content and static strings can be translated via Craft’s powerful internationalization features. A translation might refer to content that is managed discretely per-language (via sites and site groups), or a piece of UI text passed through Craft::t() or the |t Twig filter.

Soft-deleted elements are accessible via this special status in the control panel, or with the .trashed() element query method.

Craft uses templates as part of most front-end HTML responses. These templates are written in Twig, a fast and powerful language for merging content and data with markup.

The user who originally uploaded an asset (or, if the file is replaced, the user who last replaced it).

Acronym for Uniform Resource Identifier. URIs in Craft are often path-like strings generated from URI Format settings in various places (like sections), and stored in such a way that makes routing requests efficient and accurate. An additional benefit of this is that Craft’s database is portable between environments—as opposed to storing the full url (including the domain) for every element or resource.

Acronym for uniform resource locator, typically differentiated from a URI by the inclusion of a host and scheme. Craft is capable of generates absolute URLs for most elements, as well as when using the url() and siteUrl() Twig functions. Multi-site installations use the requested URL to determine which site should be served.

One of Craft’s built-in element types, representing people with some relationship to your site. The control panel is accessible only to credentialed users, via flexible authentication and permissions schemes.

A role that collects permissions or otherwise organizes your site’s users.

Each control panel user can customize their experience with a handful of localization and accessibility settings.

Users can also manage their personal address book via their account’s edit screen.

Special control panel pages that provide back-office functionality (like clearing caches, running updates, or observing the queue) to users with the necessary permissions.

This might refer to a bit of information available to Twig as a global variable, or an environment variable used in a control panel or project config setting, or a config file.

Craft Commerce’s primary purchasable, owned by a product. Variants hold pricing information, physical characteristics, tax and shipping categories, and custom field data.

Traditionally, the V in MVC. In Craft, you deal mostly with Twig templates; the model and controller layers are handled for you.

The primary organizational tool for assets. Each volume is connected to a filesystem, and can have any number of nested folders (so long as they don’t overlap with another volume).

A generic description for software built on open web standards, accessible from a browser. Craft is a type of self-hosted web application known as a CMS.

The top-level public directory containing the index.php entry script, typically determined by the HTTP server’s configuration. Static files in this directory may be served without Craft’s involvement.

Users can add widgets to their dashboard to customize or optimize their experience of the control panel. Craft has a handful of built-in widgets, which can be supplemented by plugins.

A common acronym for What You See Is What You Get, or visual “rich text” editors. Craft does not have a rich text field built in, but we maintain the first-party CKEditor plugin, which can be configured with as much or as little freedom as your users require—including the ability to embed nested entries.

The PHP framework that Craft is built on, and which forms the basis of many familiar systems like services, models, queries, and controllers. Most development with Craft does not require an understanding of Yii—or the architecture of web applications in general.