This was the Buschenschanksprint 2022!

After two years of working from home, sprinting remotely and meeting via video conferences the Buschenschanksprint was for many the first occasion to see each other in person.

The Buschenschanksprint took place from Saturday 14.05.2022 until Thursday 19.05.2022.

And meeting in person was amazing. We had many discussions, demos and stand-ups which seemed just more effective than what we had over video conferences. Not that video conferences are ineffective, but it was high time to meet in person again.

The beautiful landscape of the "Südsteirische Weinstraße", the Buschenschankjause and a glass of wine or two in the evening was also a fine thing to have.

We were at most 18 people directly at the sprint and two remote sprinter.
The weather was fine, we could work outside and inside, on the terrace or in the arbour, depening on preference.
The space was big enough and the internet connection absolutely sufficient.
We had some people in tents, 8 people in the "Ferienhaus List" and the rest at the Apartment "Sonnenberg".

For dinner we went to nearby Buschenschenken, to a Restaurant and did some BBQ ourselves.

This years Buschenschanksprint was a strategic sprint for the second time.
We had a lot of plans of progressing Plone and related projects, and we did achieve a lot.

Barceloneta LTS improvements

Participants: Peter Holzer, Peter Mathis


  • Reworked the toolbar to support break-out menus instead of accordion switching again.

  • Worked on an horizontal version of the toolbar.

  • Fixed flickering due to importing of the toolbar CSS in JavaScript. Now the styles are in Barceloneta which is loaded in style tags before any content.

  • CSS custom properties are supported which allows for basic styling without creating a new theme.

  • Updated to bootstrap 5.2.

  • Updated float-styles for new picture / figure tag.

Webpack Module Federation

Participants: Johannes Raggam, Manuel Reinhardt, Peter Mathis, Peter Holzer


  • Showed the status Patternslib and Mockup with Module Federation support.

  • Finalized the Webpack Module Federation support in Patternslib, merged and released as @patternslib/patternslib 8.0.

  • Began documenting Module Federation in Patternslib.

  • Renamed the Mockup package to @plone/mockup.

  • Released a first alpha version (without Module Federation support) of Mockup under the name @plone/mockup.

  • Finalized the Webpack Module Federation integration in Mockup and released as subsequent alpha versions.

  • Created Bootstrap and jQuery bundles which are Module Federation enabled, including an upgrade step.

  • Built new plone.staticresources bundles.

  • Started with plone.cli / bobtemplates.plone template for Plone addons with some JavaScript code which compiles to a Webpack Module Federation enabled bundle.


JavaScript update and module federation integration of and collective.collectionfilter and collective.collectionfilter were chosen as two community add-ons to test the upgrade path to the new Patternslib code base and Webpack Module Federation integration.

Participants: Manuel Reinhardt, Johannes Raggam, Peter Holzer


  • Updated the JavaScript on basis of the new ES6+ Patternslib codebase.

  • Integrated Webpack Module Federation support.

  • Continued the Plone 6 update with updated Bootstrap styles.

  • Documented the upgrade path in the plone documentation.


Documentation and Trainings

Participants: Katja Süss, Steve Piercy, Fred van Dijk


  • Fix doctests in plone.api after merging a PR in the manuel package.

  • Start documenting how you would install Plone command line by command line without extra tools like buildout or Makefiles, just what you would type yourself manually.

  • Documented migration from Classic UI to Volto.

  • Review on PRs for Module Federation documentation.

  • Cleaned up errors in plone.api documentation.

  • Added meta data for SEO to plone.api documentation.

  • Removed Unicode literals in plone.api documentation.

  • Fixed the simple NGINX configuration and indentation documentation for Volto.

  • Fixed broken links to the Python requests library in plone.api and plone.restapi.

  • We have a global glossary, added common terms like "Classic UI" and "Volto".

  • Updated the chapter about picture variants with new developments from the image handling sprint topic.

  • Worked on getting trainings ready for the Plone Conf 2022. See: Issues · plone/training · GitHub

  • Merged some documentation PRs from previous sprints.

  • Worked on the Sphinx sidebar.


Migrate to Volto

Work was done on a automatic migration path from Classic UI to Volto.

Participants: Philip Bauer


Relations in Volto

Participants: Philip Bauer, Katja Süss



Participants: Peter Mathis


  • TinyMCE integration rework done. Nowe we're using the TinyMCE pattern instead of custom integration code. Some changes in the TinyMCE pattern were necessary, especially when initializing TinyMCE where clones of DOM nodes had event registrations. TinyMCE tiles now work in Mosaic on Plone 6 with multiple tiles. As a side effect, lots of code was removed.

  • Module Federation integration was done using the Patternslib Webpack configuration factory. Mosaic now loads along the Mockup base bundle without loading any - or at least any significant - resources twice.

  • What is left to do: TinyMCE link and image modals are broken and adding / moving tiles is broken.



Participants: Peter Mathis, Maurits van Rees



Participants: Maik Derstappen, Maurits van Rees



mxdev / mxmake should replace buildout in the future and support pip based Plone installs.

Participants: Robert Niederreiter, Jens Klein, Phillip Auersperg


  • Got rid of libvcs dependency. Unfortunately it turned out to be a moving target.

  • Use VCS related code from mr.developer instead (code copied to mxdev).

  • Discussed documentation from a beginners point of view. Hands on trial (thanks Katja).

  • Makefile handling strategy. Makefiles are provided as snippets for specific "domains".

  • Type hints, tests, linting, setup github actions for mxdev and mxmake.



YAFOWIL is yet another form widget library. It's not in core Plone but used in quite a number of community add-on packages. It provides a declarative approach to define forms and an easier API to handle form processing.


  • YAFOWIL is close to a new major release, including all addon widgets.

  • Maintenance of Plone integration (yafowil.plone).

  • Discussed YAFOWIL resource delivery for Plone 6.


Participants: Alessandro Pisa, Maurits van Rees, Katja Süss


  • Removed the need to pass a request to api.content.get_view and api.potral.show_message.

  • plone.api.content create improvements with less moving/renaming when creating an item. PR is green, but more improvements could still be done.

  • Introduced GitHub actions with tox for testing.

  • Documentation improvements.


Control Panel User Group Membership in Volto

Participants: Katja Süss


  • Last task done: UI for managing group memberships for case "many users" and "many groups": search and filter.

  • Ready for review: necessary plone.restapi changes.

  • Control Panel "User and Group Settings" added.




  • Proof of concept of switching to TinyMCE version 6.

  • Products.membrane: Tests pass 5.2 + 6, no Python 2.7 anymore, Archetypes support removed.

  • Quaive library permission discussion.

  • Discussed potential issues with module federation of bloating GIT repositories with hundrets or thousands of JS files.

  • Work on VScode integration, configuration and extensions in remote containers (Docker) running Plone.

  • Plone training template rework.

  • Philip and Kim Paulissen were talking about the Plone training organisation for the Plone conference.

  • Awesome Plone! Updated list of favorite Plone add-ons (again). See GitHub - collective/awesome-plone: Add-ons and resources for the CMS Plone

  • Created script and created the video about how to explain Patternslib, Mockup, ES6, module federation and the "Plone Plugin Promise".

  • Lot's of discussions about projects, software development trends, business, etc.

Future of Classic Plone discussion

Pat ourselves on the back. In Plone 6 we achieved:

  • We removed most skins and replaced by browser views, etc.

  • Removed Archetypes.

  • Removed QuickInstaller.

  • Added textindexer to core.

  • Migrated site root to dexterity, and it actually works.

  • We updated (are updating) image scaling.

  • Buildout moving to pip.

  • Untangled lots of dependencies, at least circular references.

  • Relations API in control panel.

  • New resource registry.

  • Updated complete JavaScript story.

  • Updated complete theme.

  • Solutions for all kinds of migrations.

  • We deferred indexing (in 5.1 already).

  • Migrated code base to Python 3 only with a good and documented upgrade path.

  • Switched to Zope 5.

Yes, we did all this. If one would have presented this impressive list to us some years ago, before all that happened, we would not have believed that this could be done.

This was not one big jump, but happened step by step.

But what are the next big topics in Plone? What are our pain points and what should be improved in Plone 6 Classic and on the backend?

We discussed this topic and came up with the following list.

Please note, this was a brainstorming session. It does really not mean that this will be implemented or done any point.

However, this is it:

  • Make server side rendering optional, by moving all kinds of packages to a different layer.

  • Later we could remove viewlets and portlets.

  • Update structure pattern - make it use plone.restapi instead of custom endpoints. Remove dependency on Backbone. Simplify the code base.

  • Rework related items pattern.

  • Move to folderish types also in Classic UI. We have non-folderish types in Classic UI and folderish types in Volto. It would be better if we could unify that.

  • Support instance behaviors. Instance behaviors allow to add Dexterity behaviors to individual content items instead of all the types of a type. The package collective.instancebehaviors supports that, but currently this is broken in Plone 6 due to some performance optimizations and schema caching in Dexterity. Instance behaviors can be supported again, but this needs to be done.

  • Allow multiple behaviors which have the same attribute names in a way, that they don’t stomp over each other. There are already some pull requests for this.

  • Support conditional fields, like has. In the frontend pat-depends from Patternslib helps here. Easyform has something similar.

  • A better API for dexterity. We have three ways to define schemas (XML, Schema interfaces on classes, Dexterity behaviors) which is a lot and does not help for a clean API but we need to keep them.

  • Rewrite relations machinery to not use intids but UIDs. We have the relations API now, so that pain point has already almost gone.

  • Remove duplicate indexes like Type and getId.

  • Make more core packages optional, like portlets or discussions. was built to be an optional add-on, although it was weaved into the core already more thant intended.

  • Allow more plugability so you do not have to patch several packages: e.g. images or search.

  • Versioning (CMFEditions) is the slowest thing we have in Plone. We should defer versioning like we defer indexing. Document manual versioning better, pointing people to that. Store serialized content with restapi to json, maybe store only a diff.

  • Moving a content tree is slow, especially when you move big PDF files with lots of searchable text. See GitHub - 4teamwork/ftw.copymovepatches - but that package does not support Python 3.

  • Allow additional text editors. Tiptap, with optional collaborative editing. Slate.

  • Render Slate-created content in Classic.

  • Multilingual: if you have 1000 pages in English and ten in German, and you visit as German, it would be useful to have an option to show English as fallback, instead of only seeing pages in German (See: GitHub - plone/ Indexes optimized to query multilingual content made with ).
    We should explore other multilinguar options too:

  • ps.zope.i18nfield · PyPI

  • GitHub - collective/collective.multilingual: This add-on provides support for content in multiple languages (multilingual).

Participants of the Buschenschanksprint

  • Johannes Raggam
  • Alessandro Pisa
  • Manuel Reinhardt
  • Robert Niederreiter
  • Jens Klein
  • Maik Derstappen
  • Philipp Auersperg
  • Guido Stevens
  • Peter Mathis
  • Christine Baumgartner
  • Peter Holzer
  • Markus Hilbert
  • Alexander Pilz
  • Maurits van Rees
  • Philip Bauer
  • Georg Bernhard
  • Leo Auersperg
  • Katja Süss
  • Steve Piercy (Remote)
  • Fred van Dijk (Remote)

That was the Buschenschanksprint. We're already looking forward for the next one!


Photos day 1

Day 2

Day 2/2

Day 3

Day 4

Day 5

Day 6


Thank you Johannes ! It was my first Buschenschank Sprint and definitely not the last one. What a blast ! And so much progress made and work done :+1:t3:

I can report that since this week (June 13th ) the Mosaic Editor got mostly fixed in the es6 branch and is ready for real world testing :wink:

Some glitches are still there but the main functionality is ported to ES6 and Module federation.


PS: last week datagridfield got an update which delivers the JS resources via module federation and you‘re now able to define the widgets in the DictRow Schema with plone.autoform hints.


thanks Hannes for organising the buschenschanken sprint!
as always: big fun, great landscape and awesome atmosphere.

still hacking on my vs-code devcontainer stuff - there will come an update on that soon(ish)


1 Like

Is there some documentation about how to convert an old product with some custom js into the new format? I've seen the work made for imagecropping and collectionfilter, but it's not that clear (to me) how to do it.

@cekk there is yet no documentation other than the examples in:

There is also a PR‌ bobtemplates.plone which should become the best practice example for creating Mockup patterns and that should then go into the docs: Mockup pattern template by reinhardt · Pull Request #507 · plone/bobtemplates.plone · GitHub

Basically you need a package.json with all your dependencies, a webpack config and the es6-fied JavaScript and build a bundle and register that with the resource registry. You probably would use the webpack module federation feature to avoid serving multiple version of the same dependencies.

I just updated, collective.collectionfilter and to reflect the changes in the webpack config for latest Patternslib.

1 Like