Showing results 851 to 875 of 1561

Epic
New Orphaned DataHandler aka TCEmain

#108986 Improve MM handling in TYPO3 Core related to language + workspace concepts

I went through a lot of MM issues in TYPO3, and analyzed this – also talking to Olly Hader and Lolli to find a solution to bi-directional editing when reading and persisting relations. Here is my TLDR:

The problem

TYPO3’s MM tables store bare uid_local/uid_foreign pairs with no concept of language or workspace. When a record is translated, it gets a new uid. When versioned in a workspace, yet another uid. Every part of the system — DataHandler, RelationHandler, Extbase, FormEngine — must independently guess which uid to store in MM, and they guess differently. The result: 25+ interconnected bugs spanning 12 years, affecting bidirectional MM relations, l10n_mode=exclude, allowLanguageSynchronization, and workspaces.

The new principle

Add sys_language_uid and t3ver_wsid columns to all MM tables by default. MM rows always store the default-language live uid for both sides — never translated or workspace-versioned uids. The new columns provide context: sys_language_uid says which language version of the local-side record “owns” this relation set, and t3ver_wsid isolates workspace changes without the fragile UID-swap mechanism used today.

Rules for tables

Tables are either language-aware (LA — they have sys_language_uid, e.g. tt_content, pages, sys_category) or non-language-aware (NLA — no translation concept, e.g. be_groups, fe_groups). The local-side table’s capabilities determine MM behavior: if LA, each translation can have its own relations (unless l10n_mode=exclude shares them at sys_language_uid=0); if NLA, sys_language_uid is always 0 regardless of the foreign side. This covers all four combinations (LA->LA, LA->NLA, NLA->LA, NLA->NLA) with one simple rule: the foreign table’s language-awareness is irrelevant for MM storage — the overlay/display layer handles translating the foreign side. The same principle applies to workspace-awareness and t3ver_wsid.

Core write + read (DataHandler / general path)

On the write side, all item uids are normalized to default-language live uids before writing. sys_language_uid is set from the local record’s language (or 0 for NLA/l10n_mode=exclude), t3ver_wsid from the current workspace. Workspace publishing becomes a simple DELETE live rows + UPDATE ws→live on the column — no more UID-swapping via convertItemArray(). On the read side, RelationHandler::readMM() adds WHERE sys_language_uid = X AND t3ver_wsid IN (0, ws) filtering. For l10n_mode=exclude, the caller passes languageUid=0, so shared rows are read regardless of frontend language. Workspace overlay prefers workspace rows over live rows for the same uid pair.

Extbase (still separate for the time being)

Extbase has its own persistence layer that bypasses DataHandler — fixes to DataHandler alone don’t help Extbase. On the write side, Extbase’s persistence must also normalize uids and set the context columns, using the same rules. On the read side, Extbase has two MM paths: the SQL JOIN path in Typo3DbQueryParser (adds sys_language_uid and t3ver_wsid conditions to the JOIN, with a NOT EXISTS subquery for workspace overlay) and the DataMapper::fetchRelated() path (delegates to the same read logic). The current complexity in resolveParentId() — which branches on PROPERTY_VERSIONED_UID and PROPERTY_LOCALIZED_UID to guess the right uid — collapses to simply using getUid(), because MM now always stores default-language uids with context columns for disambiguation.

How it all plays out

  • First add the new fields to the MM tables
  • Adapt the RelationHandler (or use two classes now for reading and writing) to support handing in the languageId / workspaceId and use it everywhere in DataHandler, FormEngine and Frontend
  • Adapt Extbase as well, build more tests to it
  • Build a migration path or consider building an upgrade wizard
Author Benni Mack
Assigned to Benni Mack
Created 02/15/26, 17:16
Updated 04/21/26, 11:30
Epic
In Progress Orphaned Backend JavaScript

#109064 JavaScript Label API

Author Benjamin Franzke
Created 02/23/26, 07:52
Updated 04/21/26, 11:29
Epic
In Progress Orphaned Backend User Interface

#108176 Rework Look & Feel of the TYPO3 Backend

Previous work from the Product Strategy Group and various interviews with end-users showed that it is important to give a facelift to the TYPO3 Backend.

The perception is that the TYPO3 Backend hasn’t adapted to new and modern tools people work with these days.

This can be
- Messaging apps (Slack, Microsoft Teams)
- Cloud-based Editing software (Google Docs)
- Developers Web Applications (such as GitHub/GitLab)
- Apps and even full Operating Systems (MacOS, Windows 11, iOS 26 etc)
- Other CMSes and DXPs

This is more than just changing colors, but also introduce new ways to make TYPO3 Backend more like a modern Web Application than keeping the same principles as 20 years ago.

Editors want to see that TYPO3 adapts how other systems look like nowadays.

This epic should summarize (maybe with sub-epics) essential changes for v14.

Author Benni Mack
Assigned to Benni Mack
Created 11/18/25, 16:22
Updated 04/21/26, 11:26
Epic
New Orphaned Backend User Interface

#108183 Modern simplified layering and fewer borders in TYPO3 v14/v15 backend

This epic refines the TYPO3 v14 backend by reducing unnecessary borders and visual layers in order to improve clarity, reduce visual noise and make complex screens easier to scan.

Over the years, the backend interface has gained many helpful structural elements: panels, cards, section headers, separators, etc. These were all added with the intention of clarifying structure and improving orientation. In very dense views, however, the accumulation of nested boxes, multiple borders and stacked layers can make it harder for editors to immediately see what is important and where the main working area begins and ends.

Research on visual perception and cognitive load shows that every additional frame, line and layer is one more element the eye has to parse before reaching the content. Clear hierarchy, consistent grouping and a limited number of strong structural containers help users understand complex layouts faster and with less effort. Spacing, alignment and background differences often provide enough grouping without needing extra borders.

The goal of this initiative is not to radically change the layout, but to simplify it: keep the borders and layers that genuinely support understanding, and remove or soften those that are redundant. This should make the backend feel calmer and more focused, while preserving the character of the existing design.

This epic will:

  • Review key backend views (dashboard, module overview, record lists, forms, sidebars) to identify redundant borders, nested panels and overlapping layers.
  • Reduce the number of stacked containers (panel inside panel inside card) by merging or simplifying them into a smaller set of clear structural regions.
  • Ensure that interactive elements (inputs, buttons, alerts) remain clearly identifiable and accessible, with affordances that do not rely solely on heavy borders.
  • Initiate simple guidelines for when to use borders and containers (e.g. top-level structure, interactive fields, critical messages) and when spacing, alignment or background changes are sufficient.
Author Rachel Foucard
Assigned to Benni Mack
Created 11/18/25, 21:59
Updated 04/21/26, 11:26
Epic
New Orphaned Backend User Interface

#108181 Modern Typography System for TYPO3 v14/v15 Backend

This epic introduces a modern typography system for the TYPO3 v14 backend to support the new look & feel and improve the overall reading experience for editors.

The goals are to make backend text more accessible and internationalizable, give the interface a contemporary and neutral visual character, enable clearer visual hierarchy and faster scanning of information, and improve information density on modern high-resolution screens. This involves not only selecting a new primary UI font, but also defining consistent text styles and typographic tokens across the backend.

While Verdana has historically been an excellent screen font, it was designed in the mid-1990s for low-resolution monitors, with very wide letterforms, a large x-height and generous spacing to avoid pixel collisions. On today’s high-DPI displays and dense backend views, these same characteristics make the interface feel visually heavy and dated, reduce the amount of information that fits into tables and lists, and limit our ability to create nuanced hierarchy due to the relatively small weight family. Moving away from Verdana is therefore not about discarding its past strengths, but about aligning TYPO3’s default typography with current devices, usage patterns and UX expectations.

Concretely, this epic will:

  • Define a backend typography system (font stacks, font sizes, line heights, letter spacing, weight scale, usage rules for headings, labels, helper text, code, etc.).
  • Evaluate and select a primary UI font (replacing legacy defaults such as Verdana) that remains highly legible at typical backend sizes, offers good information density, feels neutral and contemporary, and supports broad language coverage.
  • Ensure that typography changes meet accessibility guidelines (minimum sizes, contrast, readability for low-vision users) and work well with existing and planned UI components.
  • Improve hierarchy and scanning through consistent use of weights, sizes and styles instead of relying solely on colour or ad-hoc formatting.
  • Verify that typography remains robust across platforms, browsers, and rendering engines (including fallbacks and system font stacks).

Initial list of eligible fonts to evaluate (backend UI):

  • Open Sans – primary candidate: humanist sans-serif, large x-height, multiple weights, broad script support, neutral and well-known in UI contexts.
  • Noto Sans – strong internationalisation and script coverage, suitable for TYPO3 instances with many languages.
  • Inter – UI-focused sans-serif optimised for screens, good for dense interfaces and dashboards.
  • System UI stacks (e.g. system-ui, -apple-system, BlinkMacSystemFont, “Segoe UI”, sans-serif) – as potential performance-friendly or platform-native fallback strategy.
Author Rachel Foucard
Created 11/18/25, 21:11
Updated 04/21/26, 11:26
Task
Under Review Orphaned Dashboard TYPO3 CMS 14

#107918 New Widget: Activity Stream for Admins

Overview

Create a new dashboard widget that displays system activity logs specifically designed for administrator monitoring and oversight.

Purpose

This widget provides administrators with real-time visibility into system activities by displaying the latest entries from the `sys_log` table. It enables admins to monitor what’s happening in their TYPO3 installation, track user actions, identify errors, and maintain system oversight.

Access Control

**Admin-Only Widget**
- The widget must be visible ONLY to administrator users (`admin = 1`)
- Non-admin users should NOT see this widget in the widget selector at all

Configuration Options

The widget must provide the following configurable settings accessible through the configuration cog icon:

Setting 1: Number of Entries to Display
- **Type:
Dropdown/Select
- Options: 5, 10, 20, 50, 100
- Default: 10
- Label: “Number of entries to display“
- Behavior: Dynamically adjusts how many sys_log entries are fetched and displayed

Setting 2: Show Only Admin Users
- **Type:
Checkbox
- Default: Unchecked (show all users)
- Label: “Show only admin users“
- Behavior: When enabled, filters the activity stream to show only actions performed by administrator users

Setting 3: Show Only Errors and Warnings
- **Type:
Checkbox
- Default: Unchecked (show all statuses)
- Label: “Show only errors and warnings“
- Behavior: When enabled, filters to show only entries with error levels 1, 2, or 3 (warnings, errors, system errors), hiding successful operations

Setting 4: Compact View
- **Type:
Checkbox
- Default: Unchecked (normal view)
- Label: “Compact view (hide avatars, smaller text)“
- Behavior:
– When enabled: Hides user avatars, uses smaller table styling (`table-sm`), reduces padding
– When disabled: Shows full avatars, normal font sizes and spacing

Author Regis TEDONE
Created 10/29/25, 18:14
Updated 04/21/26, 11:25
Task
Under Review Orphaned TYPO3 CMS 14

#107483 Remove @internal from RedirectResponse

Author Torben Hansen
Assigned to Torben Hansen
Created 09/18/25, 12:34
Updated 04/21/26, 11:25
Task
New Orphaned Performance TYPO3 CMS 14

#107922 Refactor use of mergeRecursiveWithOverrule to define the features of the function explicitly + extend the function to use array_replace_recursive if applicable

Compared to mergeRecursiveWithOverrule, array_replace_recursive is roughly 10x faster. This comparison becomes more favorable, the larger the arrays are, that are joined. The function mergeRecursiveWithOverrule has some settings, that are defined to default values making it “incompatible” with the specific mechanism of array_replace_recursive. Scanning through the core I found that almost all calls to mergeRecursiveWithOverrule are done without specific definition of the signature, using defaults. I think in most places the __UNSET feature is neither used, nor supported and therefore the function could be called to behave exactly like array_replace_recursive.

I am not knowledgeable enough in all these sections in their complete intent, but I would suggest that especially the newer sections of YAML processing, Site Config etc. can be quickly reviewed by their maintainers – given the fact their intent and memory is fresh enough – and at the very least change the function call of mergeRecursiveWithOverrule to behave specifically like they NEED it to. For example: If it is called in an area that doesn’t even make use of __UNSET, specify the parameter as false.

Then it would be possible to add this to the head of the function call of mergeRecursiveWithOverrule:

    if ($addKeys && $includeEmptyValues && !$enableUnsetFeature) {
        $original = array_replace_recursive($original, $overrule);
        return;
    }

Once the intent of the function call is really defined this condition would switch to the MUCH faster PHP core function. Either that or maybe if the maintainer is sure he/she could just switch to array_replace_recursive directly.

Since array merging happens A LOT in the core and with quite large and deep arrays, this change could speed up the core processing A LOT. A reasonably complex and deep array takes 2ms to merge with mergeRecursiveWithOverrule on an average server and 0.3ms with array_replace_recursive. Now multiply that by dozens of TCA merges, YAML merges, config merges, extension merges etc. etc. and you suddenly gain 50ms in a single execute.

I know micro optimization is a curse and all that jazz… but in this case… with a little bit of thought, this would even make the code more robust and so much faster with such little effort, I think it’s worth the time.

Author Johannes Rebhan
Created 10/29/25, 19:55
Updated 04/21/26, 11:25
Task
New Orphaned Backend User Interface TYPO3 CMS 13

#107055 Improve state icons for editlock

In the LIST module the icons look almost identical. I found myself lost while searching for the reason an editor could not create records on a page and did not recognized the icon state.

Author Tobias Gaertner
Created 07/08/25, 11:46
Updated 04/21/26, 11:24
Bug
New Orphaned Backend User Interface TYPO3 CMS 14

#108993 context menu: lost focus after ESC

In the TYPO3 backend, when opening the context menu from a tree structure (e.g. page tree) and closing it via the ESC key, the keyboard focus jumps to the top of the page (or another item before) instead of returning to the triggering tree item.
This breaks efficient keyboard usage and is problematic from an accessibility perspective.

Steps to Reproduce

  1. Log into the TYPO3 backend.
  2. Navigate to the page tree (or any tree structure that provides a context menu).
  3. Focus a tree item
  4. Open the context menu for this item
  5. Press ESC to close the context menu.
  6. Check where the keyboard focus is now located (press TAB once).

Current Behavior

After pressing ESC, the context menu closes, but the focus moves to the top of the page or is no longer on the previously focused tree item.

Expected Behavior

After pressing ESC, the context menu is closed and the keyboard focus returns to the triggering tree item (or, more generally, to the triggering UI element).

Impact

  • Keyboard and screen reader users lose their position in the backend tree and have to re-navigate to the desired node.
  • Increased navigation time and frustration for heavy keyboard users.
  • Violates common accessibility and focus management patterns (incl. WCAG 2.1 focus order recommendations).
Author Christian Jung
Created 02/17/26, 07:41
Updated 04/21/26, 11:23
Bug
New Orphaned TYPO3 CMS 14

#89916 Shortcut to a disabled page with redirect fails

When disabling a page and setting a redirect for that old url to a new/other page, the redirect works.
When setting a page shortcut to the old url, this error shows up:

Page not found: Reason: ID was not an accessible page

Which is obvious because the shortcut functionality checks the availability of the target page.
But maybe it’s wanted/expected behaviour to get redirected if there is a redirect for the page available.

To reproduce:
- Create old-page and set hidden
- Create new-page and set visible
- Create redirect from /old-page to /new-page => this works
- Create shortcut to old-page -> shortcut fails

Author Riny van Tiggelen
Created 12/11/19, 11:09
Updated 04/21/26, 11:23
Feature
New Orphaned Site Handling, Site Sets & Routing

#109613 Add explicit ordering mechanism for Site Settings categories

  1. Feature Request: Add explicit ordering for Site Settings categories

Tracker: Feature
**Subject:** Add explicit ordering mechanism for Site Settings categories
**Category:** Site Handling, Site Sets & Routing
**TYPO3 Version:** 13.4 / main (v14)

—-

## Problem

The order of categories in the Site Settings Editor (introduced in #104794) is determined implicitly by the topological loading order of Site Sets. There is no way to explicitly control the display order.

This creates a poor editorial experience:

- Loading order != editorial priority. Extensions like `typo3/fluid-styled-content` load early (because others depend on them) and appear at the top — even though admins rarely touch those settings. Project-specific settings (branding, colors) that are edited frequently end up buried below.
- Fragile ordering. Adding or removing an extension can shift category positions without any deliberate change, making the UI feel unpredictable.
- No clean workaround. The only lever is to add artificial Set dependencies solely to influence display order. This misrepresents actual dependencies and can cause unintended TypoScript loading side effects.

## Proposed solution

Add an optional `order` (integer) property to `CategoryDefinition`:

```yaml
categories:
myextension:
label: ‘My Extension’
order: 20
```

**Sorting rules:**
- Categories with an explicit `order` are sorted ascending.
- Categories without `order` retain current insertion order (full backward compatibility).
- Subcategories inherit sorting within their parent scope.

## Implementation scope

Minimal and fully backward-compatible:

1. Add `public ?int $order = null` to `CategoryDefinition` and `Category`.
2. In `CategoryAccumulator::getCategories()`, apply `usort()` on the final array: ordered categories first (ascending), then unordered ones in current insertion order.
3. Support `order:` key in `settings.definitions.yaml` parsing in `YamlSetDefinitionProvider`.

Estimated: ~30 lines of code, no database changes, no breaking changes.

## Example

A typical project wants this display order:

Position Category Reason
—- —- —-
10 Brand & Colors Edited most frequently
20 Powermail Project-critical form settings
30 Powermail Enhancer Related to Powermail
40 MailChimp Rarely changed after setup
50 SEO Occasional adjustments
99 Fluid Styled Content Almost never touched

Today this requires artificial Set dependencies. With `order`, each extension declares its preferred position — deterministic and transparent.

Author Daniel Kleiner
Created 04/17/26, 05:25
Updated 04/21/26, 11:23
Feature
New Orphaned Site Handling, Site Sets & Routing

#109305 Support different values for different languages in the site settings

The Site Settings lack any support for translation handling. Some features, where a setting needs to be different depending on the language (date format, editable labels, etc), can only be configured in the site config or with some relation to the page tree (database, typoscript).

Settings could be flagged as language-specific. When they are, you would be able to overrule the “master” value per language. This would also need UI Integration.

https://talk.typo3.org/t/it-has-gotten-out-of-control-configuration-languages

Author Philipp Wrann
Created 03/20/26, 12:37
Updated 04/21/26, 11:23
Feature
New Orphaned Backend User Interface

#108976 Pagetree resizeable via keyboard only

Steps to reproduce

Log in to the TYPO3 backend.
Open a module that shows the document/page tree (e.g. Page or List module).
Move keyboard focus into the area containing the document tree.
Try to adjust the width of the document tree section using only the keyboard (e.g. with Tab, arrow keys or other common resize commands).

Current result

The document tree section has a resizable splitter/handle that allows changing its width with the mouse.
There is no visible or programmatically accessible control for keyboard users to adjust the width.
Keyboard-only and many screen reader users cannot resize the document tree area and are forced to use the default width.
This can lead to usability issues, for example when long page titles are truncated or when the tree takes up too much or too little space on smaller screens.

Expected result

The width of the document tree section can be adjusted using both mouse and keyboard.
There is a focusable control (e.g. a splitter/handle) that is reachable via Tab and provides clear instructions or affordances for resizing.
Keyboard users can modify the width using standard keys (e.g. arrow keys, possibly with modifiers like Shift or Ctrl).
The resizing behaviour is perceivable and operable for keyboard-only users in a way equivalent to mouse users.

Impact

Affects keyboard-only users, including many users with motor impairments and some screen reader users.
Limits their ability to adapt the interface to their needs (e.g. making the tree wider to read long labels).
This is an accessibility issue with respect to BITV / WCAG 2.1 criterion 2.1.1 (Keyboard), as functionality (resizing the document tree) is only available via mouse and not operable via keyboard.
Can negatively impact efficiency and comfort when working with large or complex page trees.

Author Aphisit Chanathale
Created 02/13/26, 12:50
Updated 04/21/26, 11:23
Feature
Under Review Orphaned Dashboard

#108577 Add WidgetContext of EXT:dashboard also to getEventData

Hello,

thanks to configurable dashboard widgets and the WidgetContext to access the widget settings.

Would be cool to have access to widget settings in getEventData (EventDataInterface), too.

Stefan

Author Stefan Froemken
Created 12/26/25, 17:17
Updated 04/21/26, 11:23
Feature
Under Review Orphaned Dashboard

#108869 Make dashboard widgets resizable

Author Andreas Nedbal
Assigned to Andreas Nedbal
Created 02/05/26, 09:39
Updated 04/21/26, 11:23
Feature
Under Review Orphaned File Abstraction Layer (FAL)

#107120 Why should we keep real files for online media?

TYPO3 could actually just remove the need to store physical stub files for youtube or vimeo files?

Author Benni Mack
Assigned to Benni Mack
Created 07/21/25, 16:44
Updated 04/21/26, 11:23
Feature
Under Review Orphaned Site Handling, Site Sets & Routing

#107069 Enhance slug generation for non-browsable doctypes (Folders and Spacers)

*Current Behavior:*
Folders and Spacers can block slugs that would be useful for regular pages.
For example: When you create a Folder called “Blog” to organize your blog entries, the system generates the slug /blog for this folder. This means you cannot have a regular page with the /blog slug without manual adjustments, even though the Folder itself is not directly accessible in the frontend.

*Expected Behavior:*
Non-browsable doctypes like Folders (SysFolder) and Spacers should have a modified slug pattern that doesn’t conflict with regular pages.

*Proposed Solution:*
Add a suffix to the slugs of non-browsable doctypes:
- For Folders: append (e.g., /blog-storage ) “storage“
For Spacers: append (e.g., /section-spacer ) “-spacer”

This would:
1. Make the slug immediately identifiable by its purpose
2. Free up the “clean” slug for use by regular pages
3. Eliminate the need for manual slug adjustments when both a folder and a regular page need similar names

I will create a patch for this

Author Anonymous
Created 07/10/25, 14:29
Updated 04/21/26, 11:23
Feature
Under Review Orphaned Extbase

#107002 Allow to restrict HTTP methods for extbase actions

It should be possible to restrict extbase actions to one or multiple HTTP methods.

Author Torben Hansen
Assigned to Torben Hansen
Created 06/29/25, 17:22
Updated 04/21/26, 11:23
Feature
Under Review Orphaned File Abstraction Layer (FAL)

#107951 Feature : Introduce a Digital Asset Provider API in TYPO3 Core

Problem

Currently, TYPO3 does not provide a standard mechanism to integrate external media or asset libraries such as Shutterstock, iStock, Unsplash, or internal DAM/PIM systems.
Editors can only browse files that are already available through the File Abstraction Layer (FAL) — either stored locally or in connected storages.

Several third-party extensions (for example, https://github.com/ideativedigital/stock-pictures) attempt to fill this gap by providing integrations with stock photo services.
However, these solutions have to re-implement Core logic (File Browser, metadata handling, authentication, etc.) and cannot provide a fully consistent user experience.

As a result:

  • Developers duplicate similar logic across extensions.
  • Editors experience inconsistent interfaces when selecting external assets.
  • Integrations are fragile and hard to maintain with each Core update.

Proposed Solution

Introduce a new Digital Asset Provider API in TYPO3 Core.

This API would define a generic and extensible interface that allows TYPO3 to connect to external digital asset libraries while keeping a consistent Core-level user experience.

Concept

  • Define a DigitalAssetProviderInterface describing methods for:
    • searching assets (with pagination and filters)
    • retrieving metadata (title, description, license, preview URL, etc.)
    • retrieving or importing asset files
  • Introduce a registry mechanism for providers, so extensions can register their services declaratively (e.g., via Symfony service tags).
  • Extend the File Selector / Element Browser to display digital asset providers alongside existing FAL storages.
  • Ensure unified UX and metadata mapping between local and external assets.
  • Allow two usage modes:
    • Import mode : download the asset and store it in FAL.
    • Reference mode : store only the remote reference and metadata.

Developer Perspective

Third-party extensions would only need to:
  • Implement the provider interface.
  • Handle authentication and API communication with the external service.
  • Return standardized asset data to the Core.

Everything else — UI integration, preview rendering, metadata mapping — would be handled by the Core.

Affected Parts

  • Backend File Selector / Element Browser (UI layer).

Example Use Cases

  • Editors can search for images in Shutterstock or iStock directly from the File Selector, preview them, and import or reference them.
  • Integrators can connect TYPO3 to an internal Digital Asset Management (DAM) system using the same API.
  • Organizations can connect cloud asset repositories (e.g., S3-based or proprietary) with minimal custom code.

Benefits

  • Unified experience for all digital asset sources.
  • Reduced code duplication across integrations.
  • Easier development and long-term maintenance of external asset connectors.
  • Future deprecation of stock-pictures and similar extensions in favor of the Core API.

References

Existing extensions
Author Presedo Roberto
Assigned to Presedo Roberto
Created 10/31/25, 10:43
Updated 04/21/26, 11:23
Feature
New Orphaned Localization

#107657 Allow mass-editing (batch processing) of alternative texts / metadata of files

It is possible to batch process the alternative texts of image files in the File List module. A similar workflow does not exists for translating the alternative texts / meta data of files.

*Usecase*
You have a page in your primary language with a lot of media files. Now another language is created and all metadata need to be translated.
At the moment this needs to be one for every single file, involving many clicks per file.

*Feature Request*
It should be possible to collectively create and create the translations of metadata of media files.

Author Gerald Rintisch
Created 10/10/25, 12:38
Updated 04/21/26, 11:23
Feature
New Orphaned Fluid

#108237 Make Make f:form.select options localizable

If I am working with an enum for select options I currently have to do something like the following to localize the label:

public function getLabel(): string
    {
        return $GLOBALS['LANG']->sL('LLL:EXT:my_extension/Resources/Private/Language/locallang.xlf:gender.'.$this->name);
    }

It would be great if the f:form.select could detect the LLL prefix and localize the strings so I can simply do

public function getLabel(): string
    {
        return LLL:EXT:my_extension/Resources/Private/Language/locallang.xlf:gender.'.$this->name;
    }

And not use the global in the enum.

With the new language domain we could even pass a domain for the localizations to the select viewHelper:


<f:form.select
        class="form-control select"
        id="gender"
        options="{genderOptions}"
        property="user.gender"
        prependOptionLabel="choose"
        prependOptionValue=""
        domain="my_extension.labels.gender"
/>
Author Lina Wolf
Created 11/21/25, 07:09
Updated 04/21/26, 11:23
Feature
New Orphaned Localization

#107844 Add new API over $GLOBALS[LANG]

We can finally add a new TranslationService that can handle arguments, custom locales, and deals with “id” + “domain” – which can then replace all the previous areas (Extbase LocalizationUtility + $GLOBALS[LANG]) which then directly utilizes Translator but does not expose it.

Author Benni Mack
Created 10/26/25, 13:32
Updated 04/21/26, 11:23
Feature
Under Review Orphaned Backend API

#108248 TCA: Migrate “config” array for each type

For each column in TCA are two configuration sections:
The first is for labels, some language handling, access rights etc.
The second section set the type of the TCA column and it’s related configuration.

// Example column “mycolumn” in $GLOBALS[‘TCA’][‘mytable’][‘columns’]
‘mycolumn’ => [
// First section
‘exclude’ => true,
‘label’ => ‘mylabel’
‘config’ => [
// Second section
‘type’ => ‘number’,
‘format’ => ‘integer’
]
]

To simplify and streamline the configuration options, the second configuration section should be migrated to the first configuration section like:

‘mycolumn’ => [
‘exclude’ => true,
‘label’ => ‘mylabel’
‘type’ => ‘number’,
‘format’ => ‘integer’
]

To provide a migration path, the first step whould be to copy entries vom the one section to the other, where these configs are missing like

‘mycolumn’ => [
// First section
‘exclude’ => true,
‘label’ => ‘mylabel’
‘config’ => [
// Second section
‘type’ => ‘number’,
‘format’ => ‘integer’
],
‘type’ => ‘number’,
‘format’ => ‘integer’
]
Author Daniel Windloff
Assigned to Daniel Windloff
Created 11/22/25, 07:52
Updated 04/21/26, 11:23
Feature
Under Review Orphaned Image Generation / GIFBUILDER

#107926 Add support for HEIC imagemagick processing

Author Benni Mack
Assigned to Benni Mack
Created 10/29/25, 23:11
Updated 04/21/26, 11:23

Showing results 851 to 875 of 1561