19 Jan 2026

feedDrupal.org aggregator

Aten Design Group: Simplified Drupal Views Styling with Custom Style Plugins

Simplified Drupal Views Styling with Custom Style Plugins

jenna Drupal

Drupal's shift to component based styling has been a much welcome change to how we plan out and organize a Drupal theme. While this has gone a long way in helping reduce duplication within our styles, figuring out the best way to apply the component styles to Drupal structures can sometimes be a challenge. Modules like SDC: Display are beginning to bridge this gap, but this doesn't address every use case. One such scenario is applying component styles to a Views list.

No One Size Fits All

Let's imagine that we have a simple grid component in our design system. This simple component accepts props for the items and column_count. This simple grid is going to be used all throughout the project and specifically across multiple View displays. There are a couple of common approaches to tackle this.

Apply the Styles Globally

One option is to make the grid styles globally available, then use something like the HTML List plugin provided by Views to add the classes we need through the UI. While it keeps all of the config in Drupal's UI where other developers might first look to replicate and make changes, we've made styles global that we likely don't need on every page. It also requires detailed knowledge of the design system to know which CSS classes to apply and where to apply them to accomplish the desired styles.

Override View Twig Templates

Another option is to move all of the styling to the Twig templates for those View displays. For example, on a list of blog posts we could create a template like views-view-unformatted-blog-posts.html.twig. Once we have that template, we call our grid component:

{{ include('my_theme:grid', {
 items: rows|map(row => row.content),
 column_count: '4',
}, with_context = false) }}

Now anytime we want to apply this to a new View, all we have to do is copy/paste this into a template for that View and update any needed props. The drawback here is that the Views UI won't reflect where the styles are coming from, or how to recreate them, and a front-end developer familiar with the theme would have to do the copy/pasting.

Moving Back into the UI

Creating a custom Views style plugin gives us the best of both worlds. We still can leverage all the benefits of SDC, but expose all the options to site builders to apply to Views keeping the UI intact with the output. Let's walk through the steps to get it done.

To start, in a custom module, create a new style plugin within \Drupal\my_module\Plugin\views\style. This plugin should extend \Drupal\views\Plugin\views\style\StylePluginBase. At its simplest, all a style plugin needs is:

<?php
 
declare(strict_types=1);
 
namespace Drupal\my_module\Plugin\views\style;
 
use Drupal\views\Plugin\views\style\StylePluginBase;
 
/**
* Style plugin to render results in a grid.
*
* @ingroup views_style_plugins
*
* @ViewsStyle(
*   id = "my_module_grid",
*   title = @Translation("Custom Grid"),
*   help = @Translation("Render results in a grid layout."),
*   theme = "views_view_my_module_grid",
*   display_types = { "normal" }
* )
*/
class MyModuleGrid extends StylePluginBase {
}

This will provide a new option when configuring a View style called "Custom Grid" without extra configuration. It will output the View rows through a new Twig template defined in the theme option within the annotation. In our case: views-view-my-module-grid.html.twig.

Before getting into the markup, we need to align our new template with other View style plugin templates:

/**
* Implements template_preprocess_HOOK().
*/
function my_module_preprocess_views_view_my_module_grid(&$variables) {
template_preprocess_views_view_unformatted($variables);
}

From there you can customize your new template as you would a standard views-view-my-unformatted.html.twig. template.

Adding Configuration to the Plugin

Currently the way our style plugin is set up assumes we want it to work the same everywhere. However most front-end systems like SDC allow components to be modified by passing props into them. For a grid component, allowing for the number of columns to be configured would give this component more flexibility. We can easily choose which props are exposed in Views to site builders.

First, we modify our plugin class:

class MyModuleGrid extends StylePluginBase {
 
/**
 * {@inheritdoc}
 */
protected function defineOptions(): array {
  return parent::defineOptions() + [
    'column_count' => ['default' => '3'],
  ];
}
 
/**
 * {@inheritdoc}
 */
public function buildOptionsForm(&$form, FormStateInterface $form_state) {
  parent::buildOptionsForm($form, $form_state);
 
  $form['column_count'] = [
    '#type' => 'select',
    '#title' => $this->t('Column Count'),
    '#description' => $this->t('The number of columns for the grid to use on desktop.'),
    '#default_value' => $this->options['column_count'],
    '#options' => [
      '3' => $this->t('Three Columns'),
      '4' => $this->t('Four Columns'),
    ],
  ];
}
 
}

The ::defineOptions() method here provides the default settings for what our form will control. In this case, setting the column_count to 3. ::buildOptionsForm() does exactly what it sounds like: it creates the form that site builders will interact with.

Next, we need to make these options available to our Twig file. To do this, we update our preprocess function from earlier:

function my_module_preprocess_views_view_my_module_grid(&$variables) {
$options = $variables['view']->style_plugin->options;
$variables['options'] = $options;
 
template_preprocess_views_view_unformatted($variables);
}

Finally, we update our Twig template to use the new options:

{{ include('my_theme:grid', {
 items: rows|map(row => row.content),
 column_count: options.column_count,
}, with_context = false) }}

Scratching the Surface

With all this in place, we can now update our Views to use this new Style plugin. And anyone with a basic understanding of Drupal views can recreate these styles when setting up new Views. There's a lot more that can be done with Views style plugins. What other Views style plugins functionality do you want us to demonstrate? Let us know in the comments.

James Nettik

19 Jan 2026 8:23pm GMT

Talking Drupal: Talking Drupal #536 - Composer Patches 2.0

Today we are talking about Patching Drupal, Composer, and Composer Patches 2.0 with guest Cameron Eagans. We'll also cover Configuration Development as our module of the week.

For show notes visit: https://www.talkingDrupal.com/536

Topics

Resources

Guests

Cameron Eagans - cweagans.net cweagans

Hosts

Nic Laflin - nLighteneddevelopment.com nicxvan John Picozzi - epam.com johnpicozzi Andy Giles - dripyard.com andyg5000

MOTW Correspondent

Martin Anderson-Clutz - mandclu.com mandclu

19 Jan 2026 7:00pm GMT

Droptica: Site Templates in Drupal – a New Way to Fast-Track Your Website Launch

-

Launching a Drupal site from scratch takes time - you need to select modules, configure content types, prepare a theme, and fill the site with sample content. Site templates are a new concept in the Drupal ecosystem that lets you skip most of this work and start with a nearly finished site in minutes. Read the article below.

19 Jan 2026 11:24am GMT

The Drop Times: Getting Set for More

With 2026 underway, Drupal core has finalised the platform requirements for its next major release, Drupal 12, setting a clear technical direction. The minimum requirements now include PHP 8.5 and recent stable versions of key databases-MySQL 8.0, MariaDB 10.11, PostgreSQL 18, and SQLite 3.45-signalling alignment with upstream standards and long-term ecosystem readiness.

These changes aren't arbitrary: they reflect Drupal's maturing release policy, which increasingly coordinates with upstream lifecycles to minimise friction and technical debt. The shift to development on the main branch of core simplifies contribution and release management, while release planning threads outline multiple windows-mid-June, late July, or December-depending on when beta readiness is achieved.

With active development on Composer 2.9+ and updated deprecation tooling already in place, 2026 offers an opportunity for developers and site owners to plan methodically. By aligning hosting stacks and project roadmaps early, teams can prepare for a smoother transition to Drupal 12 when it arrives. The support window for Drupal 10 remains open through December 2026, offering a stable fallback as the next cycle unfolds.

DISCOVER DRUPAL

EVENTS

DRUPAL COMMUNITY

BLOG

ORGANIZATION NEWS

We acknowledge that there are more stories to share. However, due to selection constraints, we must pause further exploration for now. To get timely updates, follow us on LinkedIn, Twitter, Bluesky, and Facebook. You can also join us on Drupal Slack at #thedroptimes.

Thank you.

Kazima Abbas
Sub-editor
The DropTimes

19 Jan 2026 10:50am GMT

18 Jan 2026

feedDrupal.org aggregator

#! code: Drupal 11: Finding A Better Way To Display Code Examples

I've been running this site for about 18 years now and the code I post has been in much the same format since it was started. The code is rendered onto the page using a <code> element and (mostly) syntax highlighted using a JavaScript plugin.

I make use of sites like Codepen and JSFiddle quite a bit, and often link to those sites to show examples of the code in use. Those sites got me thinking about the static nature of the code examples on this site. I have been writing more front end code recently, but static code examples aren't the best way of showing these features in action. I can (and have) uploaded images and gifs of the feature in action, but those images are many times the size of the code examples in question and serve only to bloat the page.

What I would really like to do is allow active code examples, or a code sandbox, to be injected into the page. This would allow users to interact with code examples rather than them just being static. Clearly a valuable learning tool for any site.

I know that it's possible to embed Codepen examples into a page, but not only does that require a premium subscription, it also creates a disconnect between the code and the content on the site. I wanted a solution that would allow me to write the article and the code examples all within the back end of the Drupal site.

Hosting code examples on a third party site also comes with some risk as if that site went offline then all of the code examples on my site would stop working. By self hosting I can make the editing experience better and also ensure that everything works correctly.

What I needed for the site now was some form of code sandbox that could be used to demonstrate simple JavaScript and CSS code without being tied to a third party supplier. I therefore did some searching around to find a suitable container for the code.

Read more

18 Jan 2026 7:13pm GMT

Web Wash: Basic Tailwind CSS Theme Setup for Drupal Canvas

Building a custom theme for Drupal Canvas requires integrating Tailwind CSS with Drupal's component system. This tutorial demonstrates the process of creating a theme from scratch, setting up the build tooling, and developing components that work with the Canvas page builder.

In the video above, you'll learn how to generate a theme using Drush, configure Tailwind CSS with Vite, create page templates with proper region handling, style elements using preprocessors, and build Single Directory Components for Drupal Canvas.

18 Jan 2026 2:36pm GMT

17 Jan 2026

feedDrupal.org aggregator

mark.ie: AI Single Page Importer: Fast, Flexible Single-page Imports for Drupal

AI Single Page Importer: Fast, Flexible Single-page Imports for Drupal

AI Single Page Importer is a Drupal contributed module designed to help bring content into a Drupal site from a single URL or source page in a streamlined way.

markconroy

17 Jan 2026 5:13pm GMT

16 Jan 2026

feedDrupal.org aggregator

DrupalCon News & Updates: What to Expect from Trivia Night in Chicago

DrupalCon Chicago 2026's Trivia Night promises to be an unforgettable evening filled with fun, laughter, and the perfect opportunity to meet fascinating people. The event is being organized by a dedicated and diverse team eager to showcase the best of Chicago and welcome everyone into the fold.

Trivia is taking a new form this year - three questions per round and six total rounds, each with different point values and levels of difficulty. You and your team will go head-to-head with other groups, tackling a variety of topics, including Drupal, Chicago, and pop culture. Our amazing DJ Kerry will be in charge of the music and the scoreboard. Get ready to "name that tune"-music rounds will count for points too! Oh, and you might want to practice your handwriting, because this year, trivia is going back to analog.

Trivia Night DrupalCon New Orleans

Photo Gobinath Mallaiyan licensed as CC BY-NC-SA 2.0

Between rounds, why not make a new friend? Trivia Night isn't just about answering questions-it's a celebration! We come together to mark the end of another amazing DrupalCon, sharing stories of the week and preparing for the work to come. Take this chance to strengthen old connections and forge new ones.

Chicago might be cold outside, but our gathering will be full of warmth and excitement! Enjoy the night, make plenty of toasts, share lots of laughs, and most importantly, have fun. That's what Trivia Night is all about!

Mark your calendars for Thursday, March 26 from 6pm - 9pm at the Weather Mark Tavern (1503 S Michigan Ave, Chicago, IL 60605). Free food and drinks and awesome prizes for the winners!

16 Jan 2026 1:59pm GMT

15 Jan 2026

feedDrupal.org aggregator

Cameron Eagans: 25 Years of Drupal

Drupal turned 25. A personal thank-you to the project and community that shaped my career, values, and understanding of good software.

15 Jan 2026 8:00pm GMT

DDEV Blog: Planning for another great DDEV year in 2026

DDEV 2026 Plans

2026 Plans and Notes

Every year we try to lay out a bit of a plan for the coming year.

One of DDEV's primary strengths is our connection to a wonderful community, so each year turns out a bit different than expected. As we listen to people's actual experience, we try to adjust. And of course as upstream changes bring new features and bugs, we get lots of fun things to work on that we could never have anticipated. The items listed here are notes about what we think we understand at this point, but the year ahead and user experience and requests will affect what really happens.

We look forward to your input as the year goes forward.

Community

Community is core to our strength and growth. We are committed to maintaining the outstanding support that we offer for free and keeping that communication line open. And we want to continue to grow the amazing corps of contributors who offer improvements to the DDEV ecosystem.

Board of Directors

In 2025 we established Board of Directors, but now we have to learn what that means. The Board will have to establish itself, begin helping to determine priorities, and find its way to a strong oversight role. Here are a few issues to toss to the board early:

Features and Initiatives

Procedures

2026 Planning Additional Notes

Recognized Risks

We are a very small organization, so we try to pay careful attention to the risks as we go forward. In many ways, these are the same as the 2025 noted risks.

Minor Notes

Past Plans and Reviews

Previous plans and reviews have obviously framed this year's plans: 2025 Plans and 2024 review, 2024 plans

In preparing for this, we have been discussing these things in regular advisory group meetings and a specific brainstorming meeting.

We always want to hear from you about your experiences with DDEV as the year goes along!

Want to keep up as the month goes along? Follow us on:

15 Jan 2026 5:49pm GMT

A Drupal Couple: I Wanted to Celebrate Drupal's 25th. So I Built Something for Our Moms.

I Wanted to Celebrate Drupal's 25th. So I Built Something for Our Moms.

Image
Drupal 25th anniversary celebration with code floating over a birthday cake representing modern
Article body

January 15, 2026 marks 25 years since Drupal 1.0.0. Twenty-five years. From a simple message board to powering some of the world's most complex websites. I wanted to do something to celebrate, but not just write a "happy birthday" post. I wanted to test what's actually possible with Drupal today.

Anilu and I had found some recipe PDFs. Two Colombian ones that I had. Five or six Costa Rican ones from her side. We'd also been cooking from the Accademia Italiana della Cucina website for a while. Our moms are both 75+, they love cooking, and these recipes were scattered around... difficult to read, impossible to search.

So we had an idea. What if we built them something? A real site. Multilingual. Searchable. Something they could actually use and we could share with friends. And what if I did it using Claude Code and modern Drupal to see how far things have come in 25 years?

The result is https://laollita.es. It took 3 days.

The Challenge

Let me be honest about what I was facing.

The Spanish PDFs were challenging. Massive amounts of content. The OCR quality was inconsistent. Recipes formatted in ways that made extraction tricky. Getting clean data required multiple passes of reading and confirmation because of the sheer volume of information.

Beyond the content problem, I needed multilingual support with AI-assisted translations. I needed search that actually worked. Facets. Filters by country and region. An interface accessible enough for someone who didn't grow up with computers.

Could Drupal and AI actually handle this without turning into a month-long project?

The AI-Assisted Development Journey

I started with the Umami demo. This is important. Umami gave me a Recipe content type, a structure, a foundation. It functioned exactly like what Drupal Recipes and templates are designed to do... get you started with something real instead of building from zero. The repetitive work was already done, so I could focus on improvements.

From there, Claudito (my Claude AI assistant) became my development partner. Not a magic wand. A helper.

Here's what AI handled well:

  • Analyzing PDFs and extracting recipe information

  • Initial translation passes and export to JSON

  • Creating migrate plugins to import recipes and translations

  • A special migration plugin specifically for translations

  • Building Views and fixing UX and CSS issues

  • Search API integration with autocomplete and facets

  • Creating a View to find recipes missing English translations

  • Bulk operations for translation (this was 100% Claudito, with me directing it to read the VBO module to understand the approach, and re-reading the AI translate module to use the right plugins)

Here's where I had to step in:

  • Redirecting AI to the right module, the right approach

  • Making sure AI read the right code or files before doing anything in Drupal

  • Guiding AI to follow best practices and modern Drupal development

  • Decisions about architecture and information structure

  • Changing fields to use more taxonomies to better standardize the recipes

Let me give you some examples. At one point, Claudito wanted to create a module to add CSS classes to a template. I redirected it to change the CSS to add selectors instead. Another time, Claudito started creating a custom module when the code could simply go in the custom theme. These redirections kept the project clean and maintainable.

Claudito let me focus on the decisions that matter. This is the human-in-the-loop approach I've written about before.

For translations, AI did most of the work in the first round. I imported those via the special migration plugin. But we still needed the View for recipes that we identified were missed in the first round, plus an extra PDF we found later. That View now serves as a way to bulk translate in the future when our moms or us add new recipes in Spanish or any other original language.

The Result

https://laollita.es is live.

Our moms can browse recipes in Spanish. Our friends can read them in English. The Italian originals are preserved. You can search by name, filter by country, filter by region. The interface is clean enough that someone who's 75 can use it without calling me for help.

Three languages. Thousands of recipes. Search, autocomplete, facets, AI translations. Three days. One person.

What This Means for Drupal at 25

Here's what surprised me. Not that it was possible. I knew Drupal could handle this technically. What surprised me was how quickly the pieces came together when you combine modern Drupal with systematic AI assistance.

The Umami demo acting as a Recipe/template meant the repetitive groundwork was already done, making modern Drupal more accessible than ever. The Drupal AI module meant translations weren't a separate nightmare. Claudito let me focus on decisions, guidance, and architecture. The ecosystem worked together.

And here's the forward-looking part. I didn't use Drupal CMS. I didn't use Canvas. I didn't use the newer Recipe installation tools. I decided to test it this way because Umami had already given us a solid foundation.

Imagine what this build would look like with those tools added. Drag-and-drop layout building. Even faster site assembly. More accessible for people who aren't command-line comfortable.

Drupal at 25 is not the Drupal I learned a decade ago. The learning curve is flattening as the ecosystem evolves. The AI integration is real and practical. The Recipe/template approach (demonstrated here with Umami) changes how fast you can get to something functional.

If you've been wondering whether Drupal is still "hard"... try building something. Give yourself a few days and a reason that matters to you. Then tell me what you built.

Happy 25th birthday, Drupal. Thanks for letting us build something for our moms.

About
AI as an Assistant: A Practical Approach to Responsible AI Usage
Rebuilding Drupal's Ecosystem Pyramid: A Path to Sustainable Growth
Author
Carlos Ospina
Abstract
For Drupal's 25th anniversary, I built laollita.es-a multilingual recipe site-in 3 days using AI. Here's what modern Drupal can actually do today.
Tags
Drupal
Drupal Planet
AI
Development
Drupal Future
Open Source
Community
Human In The Loop
Rating
No votes yet

Add new comment

15 Jan 2026 3:27pm GMT

Drupal blog: Drupal Turns 25 Today

Twenty-five years! In the world of technology, hitting a quarter-century milestone while remaining a top-notch powerhouse of the internet is an achievement so rare it's almost unheard of. Today, we're popping the confetti and cutting the cakes around the world to celebrate a colossal journey. This isn't just a birthday for a piece of software; it's a testament to resilience, constant evolution, and the deep-seated belief in doing things the right way. Join us as we look back on 25 years of shared passion, contribution, and the incredible community that has made Drupal so powerful. Happy birthday, Drupal!

Trusted by millions of sites and applications, Drupal has been the secure, flexible backbone for everyone from global governments and prestigious universities to world-renowned NGOs, major media outlets, and countless ambitious startups. Drupal's versatility allowed it to power a wide array of systems far beyond traditional websites, including intranets, booking systems, learning platforms, data hubs, and IoT dashboards.

For a quarter century, Drupal remained true to its technical soul. Its strength remains in structured content, best-in-class workflow features-including moderation, granular permissions, and multilingual support-and delivery to various displays via reusable content and APIs. Under the hood, proven performance, precise caching, and a mature security process ensure scalability. Its core strengths of extendability, customizability, and openness solidify its status as a uniquely flexible and sovereign digital platform.

Not only technically capable itself, Drupal's design and culture inherently promoted sharing and reuse. This encouraged people to build widely capable and powerful general components, and contribute them back, a mindset that fueled the growth of over 50,000 modules.

But beyond the millions of sites, the technical power, and the tens of thousands of modules, Drupal's true magic lies in the people. It's a platform that created careers. For many, Drupal was the first step into the world of content management. For tens of thousands more, it blossomed into a fulfilling career. Developers, architects, designers, editors, trainers, marketers, agency founders-a full spectrum of digital careers have flourished around Drupal.

Drupal's influence stretches far beyond the codebase and business, it is also a world-class social network. It sparked friendships, and yes, even led to a few real life Drupal families. People who would otherwise never have met have become lifelong friends. We have learned together, collaborated on projects, and passionately argued over UIs, policies and APIs, but with the goal of emerging with a stronger connection. This vibrant, global community is the true essence of Drupal: a place where even disagreement comes from a shared passion, and where professional collaboration blossoms into genuine human friendship.

Without the community, Drupal wouldn't be here today. So raise a glass for yourselves! The thinkers, designers, marketers, organizers, testers, developers, maintainers, managers, documenters, trainers, reviewers, bugfixers, funders, accessibility professionals, translators, authors, photographers, videographers and countless others who made Drupal what it is.

Drupal is here today not because it chased trends. But because people cared and they did the right thing. Happy birthday, Drupal!

Thanks to Gábor Hojtsy, Frederick Wouters, Surabhi Gokte, Nick Vanpraet and Joris Vercammen for their contributions to this post.

15 Jan 2026 12:05pm GMT

Drupal Association blog: Drupal Turns 25 Today

Twenty-five years! In the world of technology, hitting a quarter-century milestone while remaining a top-notch powerhouse of the internet is an achievement so rare it's almost unheard of. Today, we're popping the confetti and cutting the cakes around the world to celebrate a colossal journey. This isn't just a birthday for a piece of software; it's a testament to resilience, constant evolution, and the deep-seated belief in doing things the right way. Join us as we look back on 25 years of shared passion, contribution, and the incredible community that has made Drupal so powerful. Happy birthday, Drupal!

Trusted by millions of sites and applications, Drupal has been the secure, flexible backbone for everyone from global governments and prestigious universities to world-renowned NGOs, major media outlets, and countless ambitious startups. Drupal's versatility allowed it to power a wide array of systems far beyond traditional websites, including intranets, booking systems, learning platforms, data hubs, and IoT dashboards.

For a quarter century, Drupal remained true to its technical soul. Its strength remains in structured content, best-in-class workflow features-including moderation, granular permissions, and multilingual support-and delivery to various displays via reusable content and APIs. Under the hood, proven performance, precise caching, and a mature security process ensure scalability. Its core strengths of extendability, customizability, and openness solidify its status as a uniquely flexible and sovereign digital platform.

Not only technically capable itself, Drupal's design and culture inherently promoted sharing and reuse. This encouraged people to build widely capable and powerful general components, and contribute them back, a mindset that fueled the growth of over 50,000 modules.

But beyond the millions of sites, the technical power, and the tens of thousands of modules, Drupal's true magic lies in the people. It's a platform that created careers. For many, Drupal was the first step into the world of content management. For tens of thousands more, it blossomed into a fulfilling career. Developers, architects, designers, editors, trainers, marketers, agency founders-a full spectrum of digital careers have flourished around Drupal.

Drupal's influence stretches far beyond the codebase and business, it is also a world-class social network. It sparked friendships, and yes, even led to a few real life Drupal families. People who would otherwise never have met have become lifelong friends. We have learned together, collaborated on projects, and passionately argued over UIs, policies and APIs, but with the goal of emerging with a stronger connection. This vibrant, global community is the true essence of Drupal: a place where even disagreement comes from a shared passion, and where professional collaboration blossoms into genuine human friendship.

Without the community, Drupal wouldn't be here today. So raise a glass for yourselves! The thinkers, designers, marketers, organizers, testers, developers, maintainers, managers, documenters, trainers, reviewers, bugfixers, funders, accessibility professionals, translators, authors, photographers, videographers and countless others who made Drupal what it is.

Drupal is here today not because it chased trends. But because people cared and they did the right thing. Happy birthday, Drupal!

Thanks to Gábor Hojtsy, Frederick Wouters, Surabhi Gokte, Nick Vanpraet and Joris Vercammen for their contributions to this post.

15 Jan 2026 12:05pm GMT

Drupal Core News: Introducing the main branch for Drupal core

We are excited to announce that the main branch is now the official Drupal core development branch. Using a main branch aligns Drupal core with the best practices of industry and major open-source projects. This move is the final step of infrastructure changes that began in 2023.

Going forward, main is the new, primary development trunk for Drupal core. Most active work and outstanding issues currently filed against 11.x should now be targeted at main. The 11.x branch will remain for Drupal-11-specific issues, while Drupal 12 development will happen in the main branch.

Simplifying issue management

With this update, it will be easier for contributors to identify the primary development branch. Contributors don't need to know what the current development version number is.

This change also eliminates the overhead of mass updates to change the version number on open issues. The use of version-specific development branches required a cumbersome cycle of new branches and mass updating of issues with each major version release. Using a main branch significantly simplifies our release and issue management.

What contributors need to do

Use main for most issues

Most merge requests for Drupal Core should now be submitted to the main branch. In general, only backports or issues that do not affect Drupal 12 should be filed against other branches.

Update local checkouts

If you have any local clones of the repository, you should update them:

git fetch origin
git branch -u origin/main main

Update merge requests

Merge requests will be automatically updated to target the main branch this week, so there should not be a need to do this manually. However this retargeting will not include a rebase or adding the main branch to the issue fork, which may be necessary steps. These could be done when other changes are being made to the MR. To make contributors' work easier, MRs that cleanly apply to main will be committed for now, even if the main branch does not exist in the MR.

Update the issue version number

Issues against 11.x on Drupal.org will have the version number updated to main via an automated process within the next few days. Updating issues to point to main in the meantime is OK but does not need to be done manually in bulk.

We appreciate your patience and flexibility as we have worked to implement this important step in modernizing the Drupal core development workflow.

15 Jan 2026 11:29am GMT

Dries Buytaert: 25 years of Drupal: what I've learned

Drupal turns 25 today. A quarter of a century.

What started as a hobby became a community, and then, somehow, a pillar of the web's infrastructure.

Looking back, the most important things I learned weren't really about software. They were about people, scale, and what it takes to build something that lasts.

Twenty-five years, twenty-five lessons.

A speaker on stage hugs a large blue Drupal mascot while an audience takes photos at DrupalCon Paris 2009.

1. You can do well and do good

I used to think I had to choose: build a sustainable business or build something generous. Drupal taught me that is a false choice. Growth and generosity can reinforce each other. The real challenge is making sure one does not crowd out the other.

2. You can architect for community

Community doesn't just happen. You have to design for it. Drupal's modular system created clear places to contribute, our open logo invited people to make their own variants, and our light governance made it easy for people to step into responsibility. You cannot force a community to exist, but you can create the conditions for one to grow.

3. A few decisions define everything

Most choices don't matter much in hindsight, but a few end up shaping a project's entire trajectory. For Drupal, that included licensing under the GPL, the hook system, the node system, starting the Drupal Association, and even the credit system. You never know which decisions those are when you're making them.

4. Coordination is the product

In the early days, coordination was easy: you knew most people by name and you could fix things in a single late night IRC conversation. Then Drupal grew, slowly at first and then all at once, and I remember release cycles where the hardest part was not the code but aligning hundreds of people across time zones, cultures, companies, and priorities, with far too much energy spent "bike shedding". That is when I learned that at scale, code is not the product. It is what we ship, but coordination is what makes it possible.

5. Everyone's carrying something

I've worked with people navigating challenges I couldn't see at first. Mental health struggles, caregiving burdens, personal crises. It taught me that someone's behavior in a moment rarely tells the whole story. A healthy community makes room for people. Patience and grace are how you keep good people around.

6. Nobody fully understands Drupal anymore, including me

After 25 years and tens of thousands of contributors, Drupal has grown beyond any single person's understanding. I also google Drupal's documentation. I'm strangely proud of that, because it's how I know it has become something bigger than any one of us.

7. Volunteerism alone doesn't scale

In the early years, everything in Drupal was built by volunteers, and for a long time that felt like enough. At some point, it wasn't. The project was growing faster than the time people could give, and some important work needed more hands. Paid contributors brought stability and depth, while volunteers continued to innovate. The best projects make room for both.

8. Your words carry more weight than you realize

As recently as a few weeks ago, I sent a Slack message I thought was harmless and watched it create confusion and frustration. I have been making that same mistake, in different forms, for years. As a project grows, so does the gravity of what you say. A passing comment can redirect weeks of work or demoralize someone who is trying their best. I had to learn to speak more carefully, not because I am important, but because my role is. I am still learning to do this better.

9. Maintenance is leadership with no applause

The bottleneck in Open Source is rarely new ideas or new code. It's people willing to maintain what already exists: reviewing, deciding, onboarding new people, and holding context for years. I have seen projects stall because nobody wanted to do that work, and others survive because a few people quietly stepped up. Maintainers do the work that keeps everything together. If you want a project to last, you have to take care of your maintainers.

10. Culture is forged under stress

The Drupal community was not just built on good vibes. It was built in the weeks before releases and DrupalCons, in late night debugging sessions, and in messy moments of disagreement and drama. I have seen stress bring out the best in us and, sometimes, the worst. Both mattered because they forced us to learn how to disagree, decide, and recover. Those hard moments forged trust you cannot manufacture in calm times, and they are a big reason the community is still here.

11. Leadership has to outgrow its founder

For Drupal to last, leadership had to move beyond me, and for that to happen I had to let go. That meant stepping back from decisions I cared deeply about and trusting others to take the project in directions I might not have chosen. There were moments when I felt sidelined in the project I started, which was nobody's fault, but not easy. Letting go was not always easy, but it is one of the reasons Drupal is still here.

12. Open source is not a meritocracy

I used to say that the only real limitation to contributing was your willingness to learn. I was wrong. Free time is a privilege, not an equal right. Some people have jobs, families, or responsibilities that leave no room for unpaid work. You can only design for equity when you stop pretending that Open Source is a meritocracy.

13. Changing your mind in public builds trust

Over the years, I've had to reverse positions I once argued for. Doing that in public taught me that admitting you were wrong builds more trust than claiming you were right. People remember how you handle being wrong longer than they remember what you were wrong about.

14. Persistence beats being right early

In 2001, Open Source was a curiosity that enterprises avoided. Now it runs the world. I believed in it long before I could prove it, and I kept working anyway. It took many years before the world caught up, and I learned that sticking with something you believe in matters more than being right quickly.

15. The hardest innovation is not breaking things

For years, I insisted that breaking backward compatibility was a core value. Upgrades were painful, but I thought that was the price of progress. The real breakthrough came when we built enough test coverage to keep moving forward without breaking what people had built. Today, Drupal has more than twice as much test code as production code. That discipline was harder than any rewrite, and it earned more trust than any new feature.

16. Most people are here for the right reasons

Every large community has bad actors and trolls, and they can consume all your attention if you let them. If you focus too much on the worst behavior, you start to miss the quiet, steady work of the many people who are here to build something good. Your energy is better spent supporting those people.

17. Talk is silver. Contribution is gold

Words matter. They set direction and invite people in. But the people who shaped Drupal most were the ones who kept showing up to do the work. Culture is shaped by what actually gets done, and by who shows up to do it.

18. Vision doesn't have to come from the top

For a long time, I thought being project lead meant having the vision. Over time, I learned that it meant creating the conditions for good ideas to come from anywhere. The best decisions often came from people I'd never met, solving problems I didn't know we had.

19. The spark is individual but the fire is not

A single person can change a project's direction, but no contribution survives on its own. Every new feature comes with a maintenance cost and eventually depends on people the original author will never meet. Successful projects have to hold both truths at once: the spark is individual, but the fire is not.

20. At scale, even your bugs become features

Once enough people depend on your software, every observable behavior becomes a commitment, whether you intended it or not. Sooner or later, someone will build a workflow around an edge case or quirk. That is why maintaining compatibility is not a lesser form of work. It is core to the product.

21. A good project is measured by what people build next

For a long time, it felt like a loss when top contributors moved on from Drupal. Over time, I started to notice what they built next and realized they were carrying what they learned here into everything they did. Many went on to lead teams, start companies, or build new Open Source projects. I have come to see that as one of Drupal's most meaningful outcomes.

22. Longevity comes from not chasing trends

Drupal is still here because we resisted the urge to chase every new trend and kept building on things that last, like structured content, security, extensibility, and openness. Those things mattered twenty years ago, they still matter today, and they will still matter twenty years from now.

23. If it matters, keep saying it

A community isn't a room. People join at different times, pay attention to different things, and hear through different filters. An idea has to land again and again before it takes hold. If it matters, keep saying it. The ideas that stick are the ones the community picks up and carries forward.

24. It takes a community to see the whole road

Sometimes the path forward seems clear, but it takes the perspective of a community to see the cracks, the forks, and the doubts. Being right alone brings clarity. Bringing others along brings confidence.

25. Start before you feel ready

When I released Drupal 1.0.0, I knew almost nothing. For much of the journey, I felt out of my depth. I was often nervous, sometimes intimidated. I didn't know how to scale software, how to build a community, or how to lead. I kept shipping anyway. You don't become ready by waiting. You become ready by doing.

Areal photo of DrupalCon Seattle 2019 attendees.
A group photo taken at DrupalCon Seattle in 2019.

For those who have been here for years, these lessons will feel familiar. We learned them together, sometimes slowly, sometimes through debate, and often the hard way.

If Drupal has been part of your daily life for a long time, you are not just a user or a contributor. You are part of its history. And for all of you, I am grateful.

I am still here, still learning, and still excited about what we can build together next. Thank you for building it with me.

15 Jan 2026 4:06am GMT

14 Jan 2026

feedDrupal.org aggregator

DDEV Blog: DDEV 2025 Year in Review

DDEV 2025 Year in Review

2025 has been a year of significant growth and accomplishment for DDEV. With 579 commits to the main repository and releases from v1.24.0 through v1.24.10, we've made substantial progress on features, infrastructure, and community building. Here's a look back at what we all achieved together.

Table of Contents

Organizational Milestones

Community Engagement

The DDEV open-source community continues excellent engagement on several fronts.

Major Features and Improvements

Sponsorship Communication

Add-on Ecosystem

Container and Infrastructure

Upcoming v1.25.0:

Developer Experience

Upcoming v1.25.0:

Language and Database Updates

Upcoming v1.25.0:

Windows Improvements

ddev.com Website and Documentation

IDE Integration

DDEV Developer Improvements

AI in DDEV Development

2025 saw significant AI integration in our development workflow:

Removals in v1.25.0

Challenges and things that could have gone better

Comparing Outcomes to 2025 Goals

In 2025 Plans we laid out ambitious plans for 2025. Here are the outcomes:

By the Numbers

Wow, Community Contributions!

As an open-source project we truly value the amazing contributions of the community. There are so many ways these contributions happen, including support requests and issues (we learn so much from those!) but also direct contributions.

By Contributor

I know this is "Too Much Information" but here is a simple and inadequate list of the amazing contributions directly to the main project by contributors other than Randy and Stas. It inspires me so much to see this consolidated list.

Ralf Koller - rpkoller - 36 contributions

Akiba - AkibaAT - 7 contributions

Ariel Barreiro - hanoii - 6 contributions

tyler36 - tyler36 - 4 contributions

Travis Carden - TravisCarden - 3 contributions

Laryn - laryn - 3 contributions

Andrew Berry - deviantintegral - 2 contributions

Raphael Portmann - raphaelportmann - 2 contributions

cyppe - cyppe - 2 contributions

Peter Bowyer - pbowyer - 2 contributions

Shelane French - shelane - 2 contributions

Pierre Paul Lefebvre - PierrePaul - 2 contributions

Sven Reichel - sreichel - 2 contributions

lguigo22 - lguigo22 - 1 contribution

Justin Vogt - JUVOJustin - 1 contribution

grummbeer - grummbeer - 1 contribution

crowjake - crowjake - 1 contribution

Markus Sommer - BreathCodeFlow - 1 contribution

James Sansbury - q0rban - 1 contribution

Moshe Weitzman - weitzman - 1 contribution

Yan Loetzer - yanniboi - 1 contribution

Garvin Hicking - garvinhicking - 1 contribution

Benny Poensgen - vanWittlaer - 1 contribution

Rob Loach - RobLoach - 1 contribution

JshGrn - JshGrn - 1 contribution

E - ara303 - 1 contribution

Alan Doucette - dragonwize - 1 contribution

Brooke Mahoney - brookemahoney - 1 contribution

gitressa - gitressa - 1 contribution

Eduardo Rocha - hockdudu - 1 contribution

Dezső BICZÓ - mxr576 - 1 contribution

Tomas Norre Mikkelsen - tomasnorre - 1 contribution

Danny Pfeiffer - danny2p - 1 contribution

Popus Razvan Adrian - punkrock34 - 1 contribution

Daniel Huf - dhuf - 1 contribution

Ayu Adiati - adiati98 - 1 contribution

Peter Philipp - das-peter - 1 contribution

O'Briat - obriat - 1 contribution

Andreas Hager - andreashager - 1 contribution

Bill Seremetis - bserem - 1 contribution

Olivier Mengué - dolmen - 1 contribution

Rui Chen - chenrui333 - 1 contribution

michaellenahan - michaellenahan - 1 contribution

August Miller - AugustMiller - 1 contribution

Loz Calver - lozcalver - 1 contribution

Tim Kelty - timkelty - 1 contribution

Pedro Antonio Fructuoso Merino - pfructuoso - 1 contribution

Bang Dinh - bangdinhnfq - 1 contribution

nmangold - nmangold - 1 contribution

Jeremy Gonyea - jgonyea - 1 contribution

Colan Schwartz - colans - 1 contribution

Mrtn Schndlr - barbieswimcrew - 1 contribution

Marvin Hinz - marvinhinz - 1 contribution

RubenColpaert - RubenColpaert - 1 contribution

Alexey Murz Korepov - MurzNN - 1 contribution

Adam - phenaproxima - 1 contribution

Nick Hope - Nick-Hope - 1 contribution

Damilola Emmanuel Olowookere - damms005 - 1 contribution

nickchomey - nickchomey - 1 contribution

Andrew Gearhart - AndrewGearhart - 1 contribution

Christopher Kaster - atomicptr - 1 contribution

Hervé Donner - vever001 - 1 contribution

Bernhard Baumrock - BernhardBaumrock - 1 contribution

Erik Peterson - eporama - 1 contribution

Tom Yukhayev - charginghawk - 1 contribution

Summary by Count

Contributor GitHub Count
Ralf Koller rpkoller 36
Akiba AkibaAT 7
Ariel Barreiro hanoii 6
tyler36 tyler36 4
Travis Carden TravisCarden 3
Laryn laryn 3
Andrew Berry deviantintegral 2
Raphael Portmann raphaelportmann 2
cyppe cyppe 2
Peter Bowyer pbowyer 2
Shelane French shelane 2
Pierre Paul Lefebvre PierrePaul 2
Sven Reichel sreichel 2
lguigo22 lguigo22 1
Justin Vogt JUVOJustin 1
grummbeer grummbeer 1
crowjake crowjake 1
Markus Sommer BreathCodeFlow 1
James Sansbury q0rban 1
Moshe Weitzman weitzman 1
Yan Loetzer yanniboi 1
Garvin Hicking garvinhicking 1
Benny Poensgen vanWittlaer 1
Rob Loach RobLoach 1
JshGrn JshGrn 1
E ara303 1
Alan Doucette dragonwize 1
Brooke Mahoney brookemahoney 1
gitressa gitressa 1
...and 36 more contributors

Blog Guest Contributors

Guest contributions to the blog are always welcome and key contributors added significant posts this year:

Ajith Thampi Joseph - atj4me

Bill Seremetis - bserem

Garvin Hicking - garvinhicking

Jeremy Gonyea - jgonyea

ayalon - ayalon

And thanks to all of you who use DDEV, report issues, answer questions in Discord and other venues, and spread the word. Your support makes this project possible.

Amazing Official Add-on Maintainers

There are so many unofficial add-ons being maintained by so many people, but here are the folks that maintained official repositories:

  1. @tyler36 - ddev-browsersync, ddev-cron, ddev-cypress, ddev-qr, plus contributions to 20+ other add-ons
  2. @weitzman (Moshe Weitzman) - ddev-drupal-contrib, ddev-selenium-standalone-chrome
  3. @cmuench (Christian Münch) - ddev-opensearch
  4. @julienloizelet (Julien Loizelet) - ddev-mongo, ddev-redis-insight
  5. @mkalkbrenner - ddev-solr
  6. @robertoperuzzo - ddev-sqlsrv
  7. @b13 (TYPO3 agency) - ddev-typo3-solr, ddev-rabbitmq
  8. @jedubois - ddev-varnish
  9. @hussainweb - ddev-redis
  10. @seebeen - ddev-ioncube, ddev-minio
  11. @bserem (Bill Seremetis) - ddev-adminer
  12. @AkibaAT - ddev-intellij-plugin
  13. @biati-digital - vscode-ddev-manager

Looking Ahead to 2026

Stay tuned for our 2026 plans post where we'll outline what's next for DDEV. As always, we welcome your input through all our support venues.

Claude Code and GitHub Copilot were used as assistants in gathering lists and material, and in reviewing this article.

14 Jan 2026 11:19pm GMT