webjoke.de

During the Driesnote at DrupalCon Rotterdam, one of the closing points was that Drupal has evolved light years beyond its reputation. And that's true. But it's also true that there is a whole world of people out there who've never heard of Drupal, and we need to talk about it differently to them than we do when talking amongst the Drupal-aware.

Enter The October "Off the Drupal Island" challenge.

The gist: During this, the spoooookiest month, go out to a local event (meetup, hackathon, etc.) where Drupal isn't, and no one has ever heard of "Drush" or a render array. ;) And ideally, where their local community presence is larger than ours.

For example:

• AI events
• JavaScript events
• WordPress events
• ...

NOT to pitch Drupal! To learn, quickly, and at scale. Be curious. Talk to people. Find out more about what they're building, where they're struggling, and what they wish was better.

Then, post a mini "field report" about your journey to this issue (there's a handy template there if you like).

We'll circle back on these learnings in a November AI Learners Club meeting, and strategize what kind of demo(s) we think would resonate best with these audiences, reflecting back their words and their use cases and pain points.

Then, we get louder about Drupal to them. ;) #DevRel at global scale.

Note: If you need extra incentive, perhaps because the idea of talking to strangers is slightly terrifying to you ;) note that this community research work qualifies you for credits under the new Drupal Advocacy program. \m/

For discussion, see LinkedIn: https://www.linkedin.com/feed/update/urn:li:activity:7513498359781826560/

Tags: advocacydrupal#DrupalOffTheIslanddevrel

DrupalCon brings love in every drop

So, last week was quite a big week, really. Both for me personally, more of that in a moment, and for the Drupal project as a whole, I think. 

Rachel Tue, 10/06/2026 - 21:19 Tags

• Drupal

• Read more about DrupalCon brings love in every drop
• Log in with GitHub or Google to post comments. Or, if you came across this post via Mastodon, just reply there!

Freedom with the form Attribute: More Flexible Drupal Views Exposed Filters Joel Steidl Tue, 10/06/2026 - 13:19 Drupal

Drupal Views exposed filters tend to accumulate controls.

A basic search form may start with a keyword field and a few filters. Add sorting and an items-per-page selector, and Drupal naturally renders everything as part of the same exposed form.

That makes sense structurally. It does not always make sense visually.

Sorting often belongs above the results. Items per page may belong next to pagination. Filters might live in a sidebar or drawer.

The HTML form attribute gives us a simple way to separate those concerns.

Form controls do not have to live inside the form

Most of the time, an input belongs to the <form> that contains it.

But HTML allows controls to explicitly reference a form by ID:

<form id="search-form"> <input name="keywords"> <button type="submit">Search</button> </form>   <select name="sort" form="search-form"> <option value="date">Date</option> <option value="title">Title</option> </select>

The <select> can live anywhere in the document and will still participate in search-form when it is submitted.

That is particularly useful with Drupal Views exposed filters.

Instead of forcing every exposed control into one visual group, Twig can put them where they make sense:

{{ exposed|without('sort_by', 'items_per_page') }}   <div class="results-sort"> {{ exposed.sort_by }} </div>   {{ rows }}   <div class="results-footer"> {{ pager }} {{ exposed.items_per_page }} </div>

Then a form alter can associate those controls with the original exposed form:

/** * Implements hook_form_views_exposed_form_alter(). */ function example_form_views_exposed_form_alter( array &$form, FormStateInterface $form_state, string $form_id, ): void { foreach (['sort_by', 'items_per_page'] as $key) { if (isset($form[$key])) { $form[$key]['#attributes']['form'] = $form['#id']; } } }

Drupal still owns the form. The browser still understands which controls belong to it. The template gets considerably more freedom.

The same technique can help with controls in sticky toolbars, dialog footers, complex search layouts, or other interfaces where form controls need to appear outside their natural DOM container.

There are a few tradeoffs

Moving controls outside the form changes more than layout.

JavaScript that relies on closest('form') will no longer work. CSS such as form select will not match detached controls. Events from those controls also do not bubble through the form element because the form is no longer their DOM ancestor.

The form ID also becomes part of the implementation contract, which matters when multiple Views or exposed forms appear on the same page.

These are manageable constraints, but they are worth documenting.

The form attribute gives us form ownership, not DOM nesting.

Maybe this should be contrib

There is also a small but interesting Drupal contrib opportunity here.

A module could allow site builders to configure which exposed Views elements should receive a form attribute and which should autosubmit.

The theme would remain responsible for placement. The module would simply provide the form association and optional behavior.

That could eliminate a recurring bit of project-specific PHP and JavaScript while relying primarily on native browser behavior.

For a relatively obscure HTML attribute, form opens up a useful amount of flexibility in Drupal Views. It lets the markup follow the interface instead of forcing the interface to follow the form.

For additional information on the form attribute, checkout the docs.

Joel Steidl

A first look at Gutenberg AI, the AI writing tools Ramsalt is building for Drupal Sohail Lajevardi Senior Drupal Engineer, Head of AI Engineering 06.10.2026

Most AI writing tools live in another browser tab. You copy text out, write a prompt, copy the answer back and fix the formatting. We wanted to get rid of that loop for people who write online. Gutenberg AI is the product we are building to fix that. It brings AI into the Gutenberg block editor, right next to the content it works on.

Video file Introducing Drupal Gutenberg AI by Ramsalt Lab

It is built on the Drupal AI framework, so it works with the chat provider you already use, whether that is OpenAI, Anthropic or a model running locally through Ollama. Everything it produces is standard Gutenberg blocks, so there is no lock-in.

A quick note before the tour: this is not a finished service yet. Gutenberg AI is under heavy development, features change from week to week and some of what you see here is still being tuned. We are sharing it now because we want to shape it together with the people who will use it. Here is a first look at what already works in our development builds.

In this post

• Better writing, right where you write
• An assistant that edits the page
• Use AI block or the sidebar assistant and build a section
• A proofreader that works while you type
• Editorial Desk
• Images and alt text
• Built for organizations that need control
• Help us shape it

Better writing, right where you write

Select a text block and the AI menu covers the everyday jobs: improve writing, summarize, expand, fix spelling and grammar, change the tone or translate. Highlight a single sentence and a small bar appears under it, so you can rewrite just that passage and keep or discard the result on the spot. Links and emphasis survive the round trip.

A few details we are especially happy with:

record_voice_overTones that fit your audience

It comes with tones like Formal, Friendly and Plain language, and admins can swap them for the readers your site actually writes for, such as prospective students or the press.

keyboardContinue writing

Press Ctrl/Cmd+J and the next sentences appear as grey ghost text at your cursor. Tab accepts, Esc dismisses.

content_pastePaste cleanup

Paste from Word or Google Docs and Gutenberg AI offers to rebuild it as real headings, paragraphs and lists, keeping every sentence.

bookmark_addYour own actions

Found an instruction that works? Save it under your own name and reuse it from your AI menu.

translateTranslation that respects all languages

Real time one paragraph or all the page translation, with image alt text as well.

edit_noteYour edits win

Keep typing while the AI works and it will not overwrite you. The result is offered for review instead.

An assistant that edits the page, not just the chat

The AI Assistant sidebar is where Gutenberg AI goes beyond a single block. Ask it to “add a pricing section with three columns” or “remove the last paragraph” and it changes the page for you, using the blocks your site already has, including custom and third-party ones.

It can also do the heavy lifting on a blank page:

edit_documentDraft from a brief

Paste your notes, approve an outline and the page is written section by section. Stop whenever you like.

picture_as_pdfTurn a PDF or Word file into a page

Drop in a document and get a structured page back, with the images from the PDF placed on the page.

view_quiltImprove layout

Regroup existing content into sections, rows and columns using your theme's own colors and spacing, without touching the text or images.

travel_exploreUse your own site as a source

With the AI Agents module, ask it to “summarize our About page into this intro” and it looks up the real page and suggests internal links, limited to what you are allowed to see.

Every change is accountable. Applied changes are highlighted on the page, and each one has a before and after view and its own Revert button. Prefer to approve first? Turn on review mode and proposed edits show up as tracked changes, with added words in green and removed words in red, ready to accept or reject block by block.

Use AI block or the sidebar assistant and build a section

Sometimes you just need a chunk of content with a specific layout. Use the AI block within the editor or the right sidebar AI assistant, describe what you want and watch it stream in as standard Gutenberg blocks: columns, groups, buttons and tables. Maybe use some of your custom blocks too? One-click presets cover pricing tables, FAQs, calls to action and a lot more.

A proofreader that works while you type

Content clarity checks run live in the browser, with no AI call and no cost. Colored underlines flag long sentences, repeated words, your site's banned terms, vague link text like “click here” (Norwegian phrases included), images without alt text and skipped heading levels. Hedging words, complex words and passive voice are checked in both English and Norwegian, and adverbs in English. Most issues come with a one-click fix.

A live LIX readability score works well for Norwegian, and each content type can have its own target. The score turns red when a draft goes over it. When you want a deeper review, one click checks the whole draft against your own style guide and terminology and underlines the exact phrases that break a rule.

Editorial Desk: a second pair of eyes before you publish

For newsrooms and communication teams, the Editorial Desk adds a review layer powered by TypeSafe. It reviews the draft as you write and checks claims against your reference notes, marking each one as supported, contradicted or unverified. It also flags headlines that overpromise or miss the story, checks the text against up to five editorial policies and scores how well it serves different types of readers.

Any finding can be shown in the draft or handed to the assistant for a proposed fix. Full transparency is built in: you see which model ran each check, how confident it was and what it cost. The Editorial Desk requires a TypeSafe subscription.

Images and alt text

Generate an image straight from an empty Image block and keep writing while it works in the background. It is saved to the media library with the prompt as starting alt text. For existing images, a vision model writes the missing alt text, one image at a time or in bulk from a dedicated screen, and a Drush command handles large sites.

Built for organizations that need control

AI in a CMS has to answer to more than the editor, so we are building the controls in from the start:

shield_lockPrivacy limits

Decide the most the assistant may send: the full document, the structure only, the selection, or nothing at all. Editors can narrow it further, and an optional preview shows exactly what leaves the site.

monitoringBudgets and usage

A dashboard shows requests, tokens, latency and cost by provider and model. Monthly budgets per role and per operation stop requests before they reach the provider.

paletteYour style everywhere

The site's style guide and terminology apply to every action, the assistant and every review.

verified_userSafe output

Broken or unsafe AI output, including unsafe markup and links, is rejected before it touches the page.

tuneFine-grained settings

Each action can be switched on or off and given its own model and prompt, with separate permissions for text actions, the assistant, images and the Editorial Desk.

Help us shape it: we are looking for testers

The best way to make Gutenberg AI good is to put it in front of real editors early. We are looking for a small group of organizations that want to test it on their own content and in their own workflows.

What you get

As a tester you get early access and a direct line to the people building it, and your feedback goes straight into what we build next.

What we ask

In return we ask for honest feedback on what works, what does not and what is missing.

It is a good fit if you run Drupal with the Gutenberg editor, or are open to trying it, and your editors publish regularly. Universities, the public sector and newsrooms are especially welcome.

Contact us at Ramsalt and mention “Gutenberg AI testing” in your message. Tell us a little about your site and your editors, and we will set up a meeting to walk you through it and see if it is a good match.

Let's talk

A buyer asks an AI assistant about your product, but the answer sits behind a click or an outdated page. A Drupal AI-readability audit checks whether intended services can reach your content, whether HTML delivers useful answers, and whether facts stay consistent across outputs.

Maciej Lukianski walks through five layers beyond classic SEO: access, delivered HTML, buyer questions, JSON-LD alignment, and multilingual consistency, plus what actionable findings should look like.

Choosing a CMS for catalogues, multilingual pages, and integrations means comparing how each platform handles relationships, editorial work, and delivery—not just content types on a slide.

Drupal vs Contentful, Sanity, and Storyblok take different paths: integrated application vs managed headless services, core translation and moderation vs SaaS localization, and visual editing vs configurable Drupal workflows. Maciej Lukianski walks through content models, permissions, JSON:API options, AI boundaries, and what growth costs look like on each stack.

Meet Dashi, the 'new' multilingual demo for Drupal CMS

On September 29, Dries Buytaert showed a multilingual food magazine demo in his DrupalCon Rotterdam Driesnote. That was Dashi, the culmination of our work to give Drupal CMS 2.2 standout multilingual features. Here is what it is, how you can try it and how it came to be.

Gábor Hojtsy Tue, 10/06/2026 - 17:17

Introduction

Adopting AI can feel overwhelming, so I am sharing a few tales from my experience creating, maintaining, and assisting with contributed Drupal modules. AI can do a decent job building a "greenfield" Drupal module from scratch, so my first tale is about using AI to build and contribute a module. For my next tale, I want to talk about using AI to maintain an existing "brownfield" Drupal module.

Growing up in NYC, I found brownfields often intimidating, with some so toxic that it can take years for backhoes and dump trucks to remove the contaminated topsoil before construction can begin. With code, a brownfield can contain technical debt, orphaned code, missing tests, etc. Simply put, a brownfield contains unknowns, which means more things can go wrong while working on it. Sometimes a brownfield is so big you need heavy machinery to maintain it, and that is exactly how I felt about using AI on the Schema.org Blueprints module.

Maintaining a large module using AI

Gradually, I have been experimenting with AI to help maintain the Schema.org Blueprints. At first, I would just throw a one-shot prompt at the AI to address a single issue, and it would do a decent job diagnosing and resolving the problem. As I became more confident steering the AI, I started asking it to create issue forks, commits, pushes, and even MRs. As I previously stated in my AGENTS.md I always have "Require me to review all changes before committing and pushing code." and most models respect this rule.

My comfort level reached a point where I am creating {module}-issue-maintenance agent skills that extend my drupalorg-issue-maintenance skills. These maintenance skills have agents to track remote issues in...Read More

Drupal 12 and the End of Legacy Debt: A Forced Modernization for Enterprise Engineering bhavinhjoshi Tue, 10/06/2026 - 14:02

Just last month, a prospective client came to Joshi Consultancy Services asking for a cheap cron script to fix a runaway disk usage issue. The reality? They were bleeding money on a deep architectural flaw in their Drupal ingestion pipeline. We see this constantly. For years, the enterprise software industry tolerated a quietly expensive habit: carrying technical debt forward.

Historically, major CMS upgrades were treated as little more than UI refreshes. Agencies seamlessly dragged deprecated code, outdated PHP environments, and fragile database structures from one major version to the next. The result? Senior engineers stuck acting as caretakers for legacy code, while CXOs bled budget on endless maintenance retainers just to keep the lights on.

With the December rollout of Drupal 12, that loophole permanently closes.

The platform is fundamentally altering the rules of engagement. Instead of merely suggesting best practices, Drupal 12 enforces strict architectural modernization right at the server level. Here is why this shift is a massive win for both engineering teams and business leadership.

The Eradication of Deprecated APIs

Spaghetti code. We all hate it. But until now, deprecated code could linger in a system for years, propped up by complex workarounds.

Drupal 12 changes this by aggressively stripping out all deprecated core APIs. The system physically rejects structural laziness. If an agency attempts to stack new logic on top of a legacy foundation, the application simply will not run. You build within clean, modern boundaries from day one. Period.

Enforcing Modern Infrastructure Floors

Previously, organizations delayed server upgrades to save short-term costs, forcing modern applications to run on aging environments.

No longer. Drupal 12 introduces non-negotiable infrastructure floors: a PHP 8.5 minimum runtime alongside raised database requirements (MySQL 8.0 / PostgreSQL 18). This isn't just backend housekeeping. By enforcing these modern tiers, the core framework guarantees a baseline of performance that cannot be compromised by budget-saving shortcuts.

Security as a Structural Guarantee

Enterprise security is too often treated as an expensive, opt-in audit layer applied long after development is complete.

By making Argon2id the default for password hashing, Drupal 12 integrates military-grade resistance against GPU-driven brute-force attacks directly into the core blueprint. For the C-suite, this is an immediate reduction in liability. Security transitions from an ongoing maintenance headache to a baseline structural guarantee.

The Business Outcome: Eliminating the Maintenance Drain

The most profound impact lands directly on the balance sheet.

For CXOs, these forced architectural boundaries solve the most expensive problem in enterprise software: unpredictability. When the core framework refuses to execute legacy PHP and automatically enforces top-tier security standards, the financial drain of technical debt is cut off at the source. Organizations can finally stop paying agency retainers to manage bloated, unmaintainable code.

Drupal 12 is not just a feature upgrade. It is a forced modernization of your engineering culture.

If your organization treats this version bump as a standard IT afterthought, you are actively funding your own future liability. Stop paying for temporary bug fixes. Engineer the blueprint first.

Are your servers, and your budgets, ready for the rollout?

Drupal Drupal 12 Security Drupal Planet Drupal migration Share this Copied to clipboard Add new comment

The National Center for Family Philanthropy worked with DevCollaborative to reimagine their website, CRM, and other communications channels to effectively manage and scale their network of over 500 philanthropic families representing more than 3,000 individuals.

The tools around Drupal have become simpler, complementing Drupal.  Read our take on how Canvas, components, Drupal CMS, and AI are changing Drupal work.

AI is becoming part of almost every software platform, and content management systems are no exception. Drupal is no different. But there is an important question that often gets lost in the excitement around AI: if Drupal already manages content so well, what exactly does AI add?

TL;DR

macOS Docker provider performance has improved significantly over the years, and now all the providers seem to be performing about equivalently. So OrbStack, Docker Desktop, Lima, Colima, and Rancher Desktop are fast and working well.

Introduction

Back in November 2023 we published a hand-run comparison of macOS Docker providers. It was a snapshot: one laptop, one afternoon, one set of versions, and a Google Sheet. It answered the question people were asking, and then it started going stale the moment it was published.

That post is gone now, and this one replaces it, because the way we answer the question has changed. DDEV now runs the same benchmark battery every night, unattended, on every platform and Docker provider we support, and publishes the accumulated history.

Table of Contents Where to see the numbers

The nightly results live at the DDEV performance history dashboard.

The easiest way to find it (and everything else the DDEV GitHub organization publishes) is to start at github.com/ddev/ddev.github.io and follow the "Performance History" link. That repo's README is the index of DDEV's GitHub Pages sites — bookmark it and you don't have to remember any of the other URLs.

The dashboard has two views. Trend over time plots one line per leg so you can see regressions and improvements as they land. Compare environments (latest) gives you a sorted bar chart of each environment's recent median, which is the view that most directly replaces the 2023 post's charts.

Which metric to compare

The harness collects six metrics per run. The one that lines up with the 2023 post is drupal_install_s: Puppeteer drives the Drupal web install wizard end-to-end, in a real browser, through the DDEV router, the web server, and PHP-FPM.

I think it's important that it uses a web-intensive install process for studying web server performance. The interactive installer deliberately breaks each batch step into its own HTTP request and page reload, so every one of those round trips exercises exactly the layer where Docker provider differences show up — bind mount vs. Mutagen, gRPC-FUSE vs. virtiofs, and so on. It's the closest thing in the suite to "what does it feel like to actually use this."

The companion metric drush_install_s runs the same install non-interactively via ddev drush si, which never touches the router or web server at all. If the two track together, filesystem I/O dominates; if they diverge, the gap isolates router/web server overhead. The perf/README.md describes all six metrics and why each one is there.

macOS results

Medians of the nightly runs from 2026-08-31 through 2026-09-30, drupal_install_s in seconds, fastest first. All legs are Apple Silicon (ARM64), all with Mutagen enabled except where noted.

Docker provider drupal_install_s drush_install_s ddev_start_cold_s Rancher Desktop 12.0 9.8 16.5 Lima 12.1 9.9 15.8 Podman (rootless) 12.3 9.9 46.0 Colima (vz) 12.6 10.0 14.4 OrbStack 13.4 10.4 12.2 Docker Desktop 16.7 13.4 21.0 OrbStack, no Mutagen 16.8 11.2 9.2

The headline is how boring this table is. Five of the six Mutagen-enabled macOS providers land within 1.4 seconds of each other on the flagship metric, and their drush_install_s numbers are within 0.6 seconds. On macOS with Mutagen, your choice of Docker provider is mostly not a performance decision anymore. Pick based on licensing, maintenance, and how the tool fits your workflow.

That is a significant change from 2023, when OrbStack was clearly ahead and Colima and Rancher Desktop looked sluggish. Those gaps have largely closed (all are now using VZ/VirtioFS).

Compared with the 2023 numbers

The 2023 test did a Drupal 10 web install with Mutagen and got OrbStack 20s, Docker Desktop 22s, Rancher Desktop 22s, Colima QEMU 33s, and Colima VZ 35s. The fastest then (OrbStack, 20s) compares with 12.0s for the fastest now (Rancher Desktop), and with 13.4s for OrbStack. The slowest providers gained the most: Rancher Desktop went from 22s to 12.0s and Colima VZ from 35s to 12.6s. The spread between providers went from 15 seconds to about 1.4 (excluding Docker Desktop).

Treat these as a rough comparison, not a like-for-like benchmark. The 2023 numbers came from one MacBook Air M1 (2020) on a single afternoon, with DDEV v1.22.5, Drupal 10.1.6, and PHP 8.1. The nightly runs use CI runner machines, and newer DDEV, Drupal, and PHP versions. Both tests drive the demo_umami install through Puppeteer. Each Docker provider has also shipped many releases since 2023, and the Colima leg now uses VZ where one of the 2023 legs used QEMU with sshfs. Some of the improvement comes from the hardware, and some from the software.

When DDEV was young, a web install with Docker Desktop took SEVEN MINUTES. You'd just watch it poke along at each section. Now you don't even see those as they flash by. Now it takes 12-17 seconds. That's progress!

Mutagen is still doing the work

The most interesting row is the last one. OrbStack with Mutagen finishes the browser install in 13.4s; the same provider without Mutagen takes 16.8s — about 25% slower. Note that the no-Mutagen leg is faster on ddev_start_cold_s (9.2s vs. 12.2s), because there's no sync session to establish, and closer on drush_install_s (11.2s vs. 10.4s), because Drush never goes through the web server. The penalty concentrates in exactly the browser-driven path, which is what you use all day.

Mutagen is on by default on macOS for this reason, and these numbers say to leave it on.

However, plenty of people are perfectly happy with turning off Mutagen. Some folks don't like the additional complexity and don't want the speed trade-off. ddev config global --performance-mode=none turns it off. (Mutagen has more benefits than just performance though; with Mutagen, the web server in the container is dealing with a Linux filesystem, more like the real deployment environment, instead of a Docker bind-mount, which is more like a network filesystem.)

:::warning[Read the hardware caveat before comparing rows] The Docker Desktop leg runs on older M1 test runner machines that have dedicated hardware. OrbStack, Rancher Desktop, Colima, Lima, and Podman share a pool of newer machines. Some of the Docker Desktop gap in the table above is that hardware difference, not the provider. We didn't normalize it — the dashboard deliberately doesn't either — so treat Docker Desktop's row as "somewhat pessimistic" rather than as a clean like-for-like comparison. :::

The other platforms, and why you shouldn't rank them against macOS

The dashboard also carries Linux, WSL2, and traditional Windows legs. They're useful for spotting regressions within a leg over time, but the cross-platform bar chart is misleading if you read it as a platform ranking:

• The Linux leg runs on ephemeral GitHub-hosted runner VMs. It provisions the Drupal codebase from scratch every night and starts with cold image, Composer, and OS page caches. Every macOS and Windows leg reuses a persistent codebase and warm caches.
• The Windows and WSL2 legs run on entirely different physical hardware from the macOS test runners.

Trends within a leg: meaningful. Bar-chart comparisons across legs: only meaningful when the machines are comparable, which across platforms they aren't.

Getting the raw data

Every chart on the dashboard has a Download CSV button that exports exactly the rows behind whatever is currently displayed — after your leg and metric selections, not the whole dataset. That's the quickest path to your own analysis.

If you want everything, the underlying dataset is one JSON object per line at history.ndjson, with one line per (commit, leg) benchmark run:

curl -sL https://ddev.github.io/ddev/perf/history.ndjson | jq -r 'select(.os=="darwin") | [.timestamp, .docker_provider, .metrics.drupal_install_s] | @tsv' Running it on your own machine

The harness that replaced the old ddev-puppeteer script lives in the DDEV repository and runs locally against a standard DDEV Drupal project:

./perf/run-benchmark.sh \ --project-dir ~/workspace/d11 \ --site-url https://d11.ddev.site/ \ > result.json

It needs jq and Node.js on your PATH in addition to the usual DDEV prerequisites. If your numbers look very different from the nightly legs, we'd like to hear about it.

Summary

Three years ago the answer to "which Docker provider is fastest on macOS?" was worth a blog post with charts. Today the simple answer is that, with Mutagen on, they're close enough that the question is mostly settled, and any lingering differences are small next to the hardware you're running on.

What's better than a fresh answer is a standing one. The nightly harness means the next time performance shifts — a provider regression, a Mutagen improvement, a DDEV build-layer mistake — it shows up on the dashboard within a day, instead of waiting for somebody to run the numbers by hand and write another post.

Have questions, or numbers that look different from the dashboard? Join the conversation in our Discord, open an issue, or reach out via email.

Follow our blog, Bluesky, LinkedIn, Mastodon, and join us on Discord. Sign up for the monthly newsletter.

This article was edited and refined with assistance from Claude Code.

Beyond Bigger Servers: Keeping Websites Online Under Bot Attacks John Locke Mon, 10/05/2026 - 15:00 How layered caching, verified crawlers, and adaptive Anubis protection kept a WordPress publishing site available for readers and editors. Dev Corner

• Read more about Beyond Bigger Servers: Keeping Websites Online Under Bot Attacks
• Add new comment

WordPal: Theme Drupal with WordPress block themes

One of the difficulty with starting a Drupal website is the lack of diversity in available themes. There has always been more choice in the WordPress world for themes. Maybe, just maybe, Drupal could use WordPress themes and get the best of both worlds? 

theodore October 5, 2026

After Rotterdam, one part of Drupal's AI story is no longer theoretical. The Northmoor University demo brought AI search, content review, translation, editing and externally connected assistants together on the same Drupal site. That made a collection of modules feel closer to a product experience, but it also exposed the next question: whether organisations can depend on the path between those pieces in production.

The stack does not yet sit at one level of maturity. Drupal AI 1.5 and Canvas are stable and covered by Drupal's security advisory policy. Context Control Center is a release candidate, while Tool API and MCP Server remain in beta. Rotterdam showed that these parts can work together. Production teams now have to decide which combinations are mature enough to trust, govern and support.

Permissions, human review and traceability are central to that decision. The demo drafts changes rather than publishing them, leaving a person to review what the AI proposes. Tool API brings access checking into executable capabilities, while MCP can expose Drupal tools to assistants outside the site. Context Control Center moves instructions and organisational knowledge toward managed, reviewed material. Taken together, those pieces point toward a production requirement that goes beyond capability: teams need to know what an agent may read, what it may change, which tools it may invoke, what context it received and who remains accountable for the result.

Provider choice and the connection between Tool API, MCP and Canvas make the remaining maturity gap visible. Drupal's provider abstraction supports different commercial and locally operated models, but workflows still need to remain testable as model behaviour, tool calling and context limits change. The Drupal AI Initiative's follow-up also draws a clear line between what Rotterdam demonstrated and what is available today: the simplified MCP approach shown on stage remains a prototype. Canvas Tools, which lets agents manipulate Canvas through Tool API, is likewise still beta and is not covered by the security advisory policy.

That does not make Drupal AI simply ready or not ready for production. Different parts of the stack already support different kinds of real use, with different levels of risk. Rotterdam instead changes what Drupal AI now has to prove: that permissions remain enforceable, context can be governed, costs and activity can be traced, providers can change without losing control, and interfaces can survive upgrades. Productisation does not mean closing the ecosystem or putting everything inside one package. It means reaching the point where an organisation can understand what an AI system will be allowed to do before deployment, and explain what it actually did afterwards.

Follow The DropTimes on LinkedIn, X, Bluesky, and Facebook, or join #thedroptimes on Drupal Slack.

Allen Jason wrote and curated this issue of Editor’s Pick.

A handwritten board at DrupalCon Rotterdam carried more than vacancy notices. Attendees could also recommend community members actively looking for their next Drupal role.

Drupal AI Context first release candidate The first release candidate (RC 1) of Drupal AI Context , also known as Context Control Center (CCC), is now available. This is a major milestone for the project. After five beta releases and months of community testing, refinement and expansion, RC 1 marks the final stage before the first stable 1.0 release. We’re currently planning to release CCC 1.0 in about a month, subject to what we learn from testing the release candidate. There may also be an RC 2 release prior to 1.0. CCC helps Drupal sites provide governed, reusable context to AI-powered features, from brand voice and editorial standards to organisational knowledge, governance rules and other information that AI systems need to work effectively.

FlashFloodBreaker partner meeting in Metz: 1xINTERNET shares digital and regional resilience insights to help improve Europe’s response to extreme flash floods.

Prevent the AI skills gap from becoming an expanse The rapid pace of updates, new versions and new Drupal core and contrib module functionality of the past 5 years almost feels like a crawl compared to the “high-velocity production model” guiding The Drupal AI initiative . It has screamed past beta versions and into an enterprise ecosystem boasting more than 15,000 installs, funding totaling in the $millions (USD,) as well as dedicated product streams like Inside AI and Outside AI; all in just over a year of its official launch. In addition, the community has about made it beyond the debate of if , and are now comfortably addressing the reality of how to best, (and importantly,) responsibly employ Drupal AI so that it contributes to not just efficiencies, but to improved workflows, outcomes and ultimately the bottom line; both Inside and Out . That, after all, is the measurement used in the viability of any new product or process. Astutely, the effort is grounded in the mission: “ …to