fuddlesworth/PlasmaZones v3.4.0 on GitHub

PlasmaZones v3.4.0

Added

Scrolling mode: a third placement mode alongside Snapping and Tiling, modeled on the niri compositor. Windows form columns on an endless strip and the screen is a window onto it, so opening a new window never resizes the ones you have. The strip slides them aside and scrolls the view instead. Columns cycle through width presets or take any width. Windows in a column share it between them or show one at a time as tabs with a compact indicator alongside the column, and a window can be consumed into a neighboring column or expelled into its own. A column can be centered on demand or follow one of niri's focus centering policies. Scrolling is assigned per screen, desktop, and activity from the Monitors page, and the mode toggle shortcut cycles through all three modes. It has its own settings section beside Snapping and Tiling, with an enable switch and a shortcut family on Meta+Alt. Rule actions cover per-app and per-context behavior. Windows too large for the strip float instead, using the existing floating support, and a minimized window returns to the slot it left (#852).
Scrolling templates: scrolling screens get their own template objects, the peer of snapping's layouts and tiling's algorithms. A template describes how a scrolling screen behaves: the starting columns the first windows form (width and stacked or tabbed display for each), the width the columns after them open at, and the width and height presets the cycling shortcuts step through. Templates are managed on the Scrolling → Templates page and edited in the layout editor, and three starters ship bundled (Thirds, Sixty forty, Tabbed halves). Editing a bundled template stores your own copy, and deleting the copy brings the built-in one back. Templates carry the full management surface the other families have: import and export as JSON, duplicate, a context menu with set-as-default and open-in-text-editor, source and name filters, and a Scrolling → Quick Shortcuts page binding templates to the quick digits. Assign a template per screen with the layout picker, the Monitors page dropdown, the quick layout digits, or the layout cycle shortcuts, following the same per-screen, per-desktop, and per-activity assignment the other modes use, or make a template the default from its card's context menu, which covers screens without their own. A screen can also be set to use no template at all, in which case it walks the width and height steps on Settings → Scrolling → Columns. A rule action, Set scrolling template, applies one per context. Applying a template mainly shapes the columns that open afterwards. The columns you already have keep the widths you gave them, apart from a column sized from a width preset, which reflows to the nearest width the new template offers (#887, #929).
The scrolling strip can run top to bottom: a strip is no longer always side to side. On a screen running top to bottom the columns become full-width rows stacked down the screen, and every verb, shortcut and animation keeps its meaning along the new axis. Parking, tabs, the drop indicator, the drag popup's row of cards and the strip shaders all turn with it, and the layout editor draws a template the way the target screen will lay it out. A new Strip direction card under Settings → Scrolling → Window chooses the axis, and its monitor scope chip sets a different direction per monitor, so a portrait side monitor can run top to bottom while the main screen stays side to side. A Set strip direction rule action layers over both, per screen, desktop, or activity. Match the screen shape is the default and runs the strip top to bottom on a monitor taller than it is wide, so a portrait screen switches over without being asked, while Side to side and Top to bottom pin it. A square work area resolves to side to side, and so does a work area the gaps have collapsed to nothing. The directional scrolling shortcuts keep their ids and their chords, so nothing you have bound moves, but their names now say what they do on either axis: the Focus Column Left and Focus Column Right pairs (each with a Stopping at the Edge and a Wrapping variant) became Focus Previous Column and Focus Next Column with the same variants, Focus Top Window in Column and Focus Bottom Window in Column became Focus First Window in Column and Focus Last Window in Column, and the consume-or-expel pair now reads toward the start and toward the end of the strip. The daemon and the KWin effect exchange the axis, so both must be rebuilt and installed from the same source (#923).
Crop columns at the screen edge: a scrolling column that is only partly on screen is resized to fit the space it has, so nothing overhangs onto a neighbouring monitor and a column with too little room slides away instead of leaving a sliver. A new Crop columns at the screen edge switch under Settings → Scrolling → Window keeps the full-size look instead by cutting the drawing at the edge, at the price of some efficiency in fullscreen video and games while any screen uses scrolling (#885).
Meta+wheel scrolls through columns: on a screen in Scrolling mode, holding Meta and scrolling the mouse wheel focuses the next column and slides the strip, matching niri's Mod+wheel navigation. Horizontal wheel ticks and two-finger horizontal touchpad scrolls work too. The gesture has its own switch under Settings → Scrolling → Window, on by default, with an option to invert the direction. The wheel binding is claimed only while the switch is on and at least one screen uses Scrolling mode, and it is released back to the compositor otherwise (#852).
Scroll the strip without moving focus: the strip only ever moved as a side effect of something else, so looking at a column further along meant focusing it first. Hold Meta+Shift and scroll the wheel to move the view along the strip one step per notch while focus stays on the window you were working in. It mirrors Meta+wheel, which moves focus one column per notch, and it shares that gesture's on/off switch and its invert option. Both chords are yours to set. A new View scroll step slider under Scrolling → Window sets how far a notch goes as a share of the work area. For the keyboard, Meta+Alt+Y and Meta+Alt+Shift+Y scroll a whole work area at a time. The view stays where you scrolled it until you move the focus or use one of the centering shortcuts, so on a screen set to always center the focused column the strip no longer springs back the moment you let go. The tab indicators and the strip's own animation follow the scroll the same way they follow everything else.
The scroll strip slides as one piece: focusing another column used to move every window on screen separately, so a fast scroll could visibly shear as the columns drifted apart, and a column leaving the view blinked out instead of travelling off the edge. The strip is now a single object with one animation per screen, and the columns hold their spacing for the whole slide. Windows still animate on their own for real changes, so a column that also changed width keeps its own motion on top of the slide. The motion has its own entry under Settings → Animations → Motion → Scrolling, shown when the advanced settings are on, where the curve, the duration and a shader can be set like any other (#890, #891).
More scrolling verbs from niri: Center Visible Columns (Meta+Alt+Shift+C) centers the group of fully visible columns as a block, the whole-span companion of Center Column. Focus First Window in Column and Focus Last Window in Column (Meta+Alt+V and Meta+Alt+Shift+V) jump to the ends of the focused column. Switch Focus Between Floating and Placed Windows (Meta+Alt+X) moves focus between the floating windows and the tiled columns, and it now covers every mode, described in its own entry below. Move Window to Floating and Move Window to Tiled ship unbound, the same configuration-file binding as the focus variants above, and give the float toggle a deterministic one-way form (#897).
Equalize Column Widths and Minimize Column Width: two more ways to re-flow the strip from the keyboard. Equalize Column Widths on Meta+Ctrl+Shift+T gives every column fully on screen an equal share of the screen and leaves any column clipped at an edge alone. A column that cannot shrink to its share keeps its smallest size and the others share what is left, and the group lines up with the edge of the screen afterwards and stays there until you move the focus or use one of the centering shortcuts. Minimize Column Width on Meta+Alt+Shift+E shrinks the focused column to the smallest size preset. Both sit on the Shift twin of the verb they pair with, Retile Windows and Grow Column into Empty Space.
Retile Windows works on scrolling screens: the Retile Windows shortcut did nothing on a screen in scrolling mode. It now puts every column back to the screen's default width and display and every window back to an even share of its column, so one key re-applies the layout whichever engine the screen is on. On a screen where windows keep their own width, the shortcut leaves the widths as they are and only resets the column display and the window heights, unless a rule sets a width for that screen. Its cheatsheet row moves from Autotile to General and describes what it does on the screen you opened the sheet from.
Windowed fullscreen for the scroll strip: Meta+Alt+Shift+F tells the focused window it is fullscreen while it keeps its place in its column, matching niri's toggle-windowed-fullscreen. The application switches to its fullscreen presentation, so a video player hides its controls and a game picks its fullscreen mode, but the window stays its column's size and the strip keeps scrolling around it. Pressing the shortcut again, or leaving fullscreen from inside the application, returns the window to its normal presentation in the same slot. Floating the window ends it too, and so does minimizing it, because a window that leaves the strip is no longer a column tile. The window comes back at its normal size. The state survives a daemon restart with the rest of the strip. After a full logout the window returns to its column without the fullscreen presentation. While a window is in windowed fullscreen it cannot be dragged or resized with the mouse, because the compositor treats a fullscreen window as pinned. The keyboard verbs for width, height, and movement all keep working (#895).
Open rules from niri for scrolling windows: three new window rule actions cover how a matched window arrives on a scrolling screen. Open maximized starts its column at the full work-area width. Focus when opened decides per window whether it takes focus as it opens, layering over the global focus-new-windows setting in both directions, so a background tool can open quietly while the global setting stays on, or a terminal can take focus while it is off. Open in fullscreen puts the window into real fullscreen as it appears, and its off position blocks an application's own fullscreen request at open, which tames apps that insist on starting fullscreen. The existing open rules for width, height, tabbed display, and column placement gain these as siblings in the same Window / Scrolling picker group (#901).
Focus crosses monitors on a scrolling screen: moving focus past the last column used to stop dead at the strip edge, even though moving a window there crossed onto the next monitor and the tiling mode's focus already crossed as well. The plain focus shortcuts now continue onto the neighboring monitor, entering its strip at the window facing the edge you crossed, and the crossing also works when the neighbor runs Snapping or Tiling mode. The reverse direction works too, so a focus press on a Tiling screen crosses into a Scrolling or Snapping neighbor the same way. Crossing works vertically too, for stacked monitor arrangements: a focus or move past the top or bottom of a column continues onto the monitor above or below, and a directional focus press on an empty scrolling monitor walks straight onto the neighbor instead of doing nothing. For users who prefer niri's exact stop-at-the-edge behavior, edge-stop variants of the column focus shortcuts (Focus Previous Column and Focus Next Column, Stopping at the Edge) ship unbound, alongside wrap variants (Focus Previous Column and Focus Next Column, Wrapping) that jump to the far end of the strip instead. An unbound action stays out of the system Shortcuts app until it has a chord, so give one a chord by setting its Shortcuts.Scrolling key in the PlasmaZones configuration file, and the daemon binds it live (#897).
Floating and placed focus switch in every mode: Switch Focus Between Floating and Placed Windows (Meta+Alt+X) now works on Snapping and Tiling screens as well as Scrolling. One press jumps from the layout to the floating window you last used, and the next press jumps back to the window the layout had focused, so a floating terminal or player is always one key away from the tiled work behind it. Each mode remembers its own most recent window on each side, a minimized window is never chosen, and when the remembered window is gone another window on that side answers instead. The shortcut now sits in the General group of the cheatsheet. A chord you set yourself keeps working because the system stores it under the shortcut's unchanged name. The old Shortcuts.Scrolling configuration key is no longer read, so if you keep the chord in the configuration file, write it under Shortcuts.Global from now on (#910).
Drag a window back into the scroll strip: dragging a window while a screen is in Scrolling mode now re-inserts it where you drop it, the same way dragging works in Snapping and Tiling. The window leaves the strip when the drag starts, so the columns behind it stay still while you aim, and the new position is applied on drop. Dropping between two columns opens a column of its own, dropping onto a column joins it at the row you are over, and pressing Escape puts the window back exactly where it came from. It uses the same trigger settings as the other modes, so you can require a modifier or a mouse button, or leave it always on (#873).
The scroll strip scrolls while you drag: dragging a window towards either edge of the working area on a scrolling screen now scrolls the strip, so you can drop it on a column that was off screen when the drag started. Previously the only columns you could reach were the ones already visible. The strip starts moving after the pointer has been near the edge for a moment, and it moves faster the closer to the edge you hold it. While it scrolls, the drop target stays put at the edge as a new column, so the columns slide past a target that does not move around under your pointer. Pull back towards the middle and the usual per-column targeting takes over again, now aimed at the columns the scroll brought into view. It has its own section under Settings → Scrolling → Window with a switch, the width of the band at the edge that starts it, how long the pointer has to sit there first, and the top speed (#922).
Drop indicator for the scroll strip: while a drag re-insert is in progress, the exact space the window will land in is highlighted, so the drop is no longer a guess. It has its own section under Settings → Scrolling → Window with a switch, a fill color, a fill opacity, a border color, a border width, and a corner radius. The two colors follow your color scheme until you pick one, the color picker offers the alpha channel, and the border honors a translucent pick the way the snapping overlay's border does while the fill keeps the Fill opacity slider as its one transparency control. The defaults match the snapping zone overlay so the two highlights look like the same thing (#873, #899).
Drop indicator rule actions: the drop indicator is now configurable per context and per app, the way the tab indicator already was. Six actions cover the whole card, so a rule can turn the indicator off, recolor its fill and border, or change its opacity, border width and corner radius for one screen, desktop or activity. Two more act on the window you are dragging, recoloring the indicator's fill and border while that app is in hand, which is useful when you want a particular application's drops to stand out. A per-window color wins over a per-context one, which wins over the setting, which follows your color scheme (#873).
The drag popup shows the scroll strip: dragging a window to a screen edge on a scrolling screen now opens a strip-mode popup, the scrolling counterpart of the snapping zone selector. Instead of zone layouts it renders the strip itself, one card per column with the tiles stacked inside (or a tab strip for a tabbed column). Dropping on the leading half of a card prepends the window to that column and the trailing half appends it, which reads as the top and bottom halves on a side-to-side strip and as the left and right halves on a top-to-bottom one. A gap between cards, or a band just past either end of the strip, opens a new column there, and a tabbed card takes the window as a new tab. An empty strip offers a single drop target that starts the first column. The popup is an aim surface layered over the existing in-strip drop targets, so dropping directly on the strip keeps working as before, and while the popup holds a pick the in-strip indicator paints the slot the popup is offering. The popup has its own Strip Selector page under Settings → Scrolling with an enable switch, a picker for where the popup appears, a trigger distance, and the preview size. The position and trigger distance share a per-monitor scope chip and the preview size has its own, so both cards can be overridden per monitor from the page. On D-Bus, org.plasmazones.Settings gains a scrollingZoneSelector per-screen category for the same overrides. A new Show the drag selector rule action layers over whichever selector switch a screen uses, in both directions, so a rule can keep either popup off a recording monitor or offer it there while its global switch is off. A window matched by an Exclude or Exclude from placement rule is no longer offered either drag popup, because its drop would be refused on release (#915).
Scrolling shortcuts follow one resize convention, and the cheatsheet explains them: the adjust pairs sit on mnemonic letters with the opposed action on Shift plus the same letter, and the preset cycles page on the paging keys. Consume Window into Column is Meta+Alt+I with Expel Window from Column on Meta+Alt+Shift+I, Increase Column Width is Meta+Alt+W with Decrease Column Width on Meta+Alt+Shift+W, and Increase Window Height is Meta+Alt+H with Decrease Window Height on Meta+Alt+Shift+H. Cycle Column Width Preset is Meta+Alt+PgUp with Cycle Column Width Preset Back on Meta+Alt+PgDown, and Cycle Window Height Preset is Meta+Alt+Shift+PgUp with Cycle Window Height Preset Back on Meta+Alt+Shift+PgDown. Reset Window Heights is Meta+Ctrl+Alt+T, joining Retile Windows' Meta+Ctrl+T and Equalize Column Widths' Meta+Ctrl+Shift+T on the one letter for re-flowing the strip, instead of sitting on Meta+Alt+0 where it read as a tenth layout digit. Every default sits on a key that exists unshifted on any keyboard layout, so no chord is dead on non-US layouts. The action once called "Expand Column to Available Width" is named "Grow Column into Empty Space" to tell it apart from Maximize Column, because it claims the empty space visible on screen for the focused column and leaves every other column alone. Hovering a row in the shortcut cheatsheet's Scrolling group shows a plain-language description of what the action does, so consume, expel, and the column sizing verbs no longer require guessing (#874).
The width and height preset steps are editable: the cycling shortcuts walk a list of width steps and a list of height steps, and on a screen with no layout template those lists come from Settings → Scrolling → Columns. A Width and height presets card below the New columns card edits them. It matters more now that a screen can be set to use no template at all, because that screen walks these steps and nothing else. A screen using a template still walks the template's own lists, and each list is replaced whole, so a template carrying widths but no heights leaves the heights here in play. The card opens on the first percentage the list does not already hold, so it never opens on a value that collides with a step you already have. After that the box keeps whatever you set it to, and Add greys out while it sits on a percentage a card already carries, which one arrow press clears (#887, #929, #976).
The two wheel scroll keys are yours to set: holding Meta to move column focus and Meta+Shift to pan the view were fixed bindings with no way to change them. Both are now trigger lists under Settings → Scrolling → Window, in the Focus and view card, so you can move them off Meta if it clashes with something else you use. They stay the defaults, and turning the feature off still hands both chords back to the compositor. A chord over a screen that is not running the strip now scrolls the application underneath instead of being swallowed.
Focus follows mouse can stop short of a long scroll: on a scrolling screen, moving the pointer onto a column that is partly off screen scrolls the whole strip to bring it in, so brushing past the edge of the screen can carry the view somewhere you never meant to go. A new Limit how far the strip scrolls slider sits under the Focus follows mouse switch, on Settings → Scrolling → Window. At or below the limit the pointer focuses the column as before, and past it the pointer is ignored and focus stays where it is. The limit is a share of the work area along the strip, so it reads the same on any monitor and in either strip direction, and it starts at 100%, which never ignores anything. A Limit how far the strip scrolls rule action sets it per screen, desktop, or activity (#977).
Per-window scroll speed: a Set scroll speed rule multiplies mouse wheel and touchpad scrolling inside matching windows, niri's scroll-factor. Values below 1 slow a window whose own scrolling feels too fast and values above 1 speed up a sluggish one. Everything else on screen keeps its normal speed (#901).
Every scrolling behavior is a rule now: the seven scrolling toggles that were app-wide settings gain per-context rule actions, so each can differ per monitor, desktop, or activity. Center a lone column, Respect minimum window sizes, Crop columns at the screen edge, Focus new windows, Smart gaps, and Focus follows the mouse are switches. Set sticky window handling picks how windows shown on all desktops are treated. A wide monitor can center its lone column while a portrait one does not, or focus-follows-mouse can be on for the scrolling screen and off everywhere else. Each falls back to its global setting where no rule matches, and a per-window Focus when opened rule still wins over the per-context one (#901).
Absolute column width and window height over D-Bus: four typed methods on org.plasmazones.Scrolling set the focused column's width or the focused window's height by value, the counterpart of niri's set-column-width and set-window-height for scripting. The width takes an exact fraction or pixel value. The height fraction is stored as a preset anchor that snaps to the nearest entry of the screen's height presets, and setWindowHeightPixels is the exact height form. Shortcuts carry no value argument, so this surface is where the absolute forms live (#897).
Tab indicator settings: the indicator over a tabbed scrolling column is now fully configurable, matching niri's tab-indicator options. You can pick its position on any of the column's four edges, its thickness, how much of the edge it spans, the gap between it and the window, the gap between individual tabs, and the corner radius. A negative gap draws the indicator over the window rather than beside it. It can hide itself when a tabbed column holds only one window, and it can reserve space inside the column so it never overlaps a neighbor or runs off screen. Every default matches niri's, so out of the box you get a thin bar of colored segments down the column's left edge. A second style draws titled chips instead, naming each window, which suits a top or bottom edge. The active, inactive, and urgent tab colors follow your color scheme unless you set them. Clicking a tab switches to its window, and clicks anywhere else reach the windows beneath. Every option is available as a per-context rule action, and a window rule can recolor one application's own tab (#871).
Tab switches cross-fade: switching tabs in a scrolling column now blends the tab you left into the one you picked, in place, over the same rectangle. Both tabs are ordinary windows at the same size and position, so the column reads as one surface changing its contents. The transition has its own entry, Tab Switched, under Settings → Animations → Motion → Scrolling, where the curve, the duration, and the shader can be set like any other. There is no default, so a tab switch stays an instant cut until you pick a pack. Only tab shaders fit the event, because a tab shader reads the outgoing tab as well as the arriving one. Six generic packs ship, and the Phosphor pair below makes eight. Tab Fade blends the two in place. Tab Slide pushes one out of the column as the other follows it in. Tab Wipe sweeps the new tab across the old with an edge you can soften or sharpen. Tab Dissolve grains one into the other. Tab Flip turns the column over like a card. Tab Zoom pulls the old tab toward you as the new one rises from behind it. In earlier 3.4 development builds the arriving tab also flew up from below the screen, because the hidden tabs are parked there and nothing said the activation was a swap rather than a journey. The two now trade places without moving, which is what the switch actually is (#908).
Tab labels can use a font of your own: the labels on tab chips had no font of their own and followed the zone label font from Snapping → Overlay → Appearance, so changing one changed the other. Scrolling → Tabs, shown when the advanced settings are on, now has a Font row on the Tab indicator card where you pick the typeface, weight, italic, underline and strikeout for tab labels alone, with a reset button that puts it back to the system font in bold (#938).
The strip preview shows which columns are tabbed: a scrolling screen's live preview drew a column holding five tabbed windows exactly like one holding a single window, because the strip lists only the tab on show. Tabbed columns now carry a row of pills along the edge their real tab indicator uses, one pill per tab, with the tab on show lit. The pills follow the indicator's position and how far it reaches, while their thickness is set for legibility instead of scaled down, which at thumbnail size would put it under a single pixel. The preview on the Monitors page and the one in the mode-change OSD both draw them (#948).
Urgent windows are tracked: PlasmaZones now follows the compositor's attention-demanding state for every window, so a tab whose window is asking for attention stands out in the tab indicator even while another tab is showing (#871).
Scrolling templates open in the layout editor: editing a template now happens in the layout editor as its own mode, replacing the form dialog the settings app carried. The editor shows the starting columns as a strip of bands, the way the first windows will actually lay out, and the canvas turns with the strip direction of the screen being edited, so a top-to-bottom screen's template is authored as rows stacked down the canvas. Drag the edge after a column to resize it, click a column to select it, and use its buttons to reorder it, switch it between stacked and tabbed, or remove it. A red line marks where the screen ends, so you can see which starting columns open off screen. The panel beside the strip holds the description, the width the later columns open at, and the width and height presets, and every change is undoable with the usual shortcuts. New Template and every Edit action on the Templates page open the editor this way, and the editor gains matching command-line flags along with an openEditorForScrollingTemplate method on the public org.plasmazones.LayoutRegistry interface for scripts. The launch methods on that interface now answer whether the editor process actually started, and the settings app shows a notice when it did not (#918).
Scrolling templates take a priority order: a new Priority page under Scrolling → Configuration sets the order templates appear in when cycling with the keyboard shortcuts and in the layout picker, the same drag-to-reorder page that snapping layouts and tiling algorithms already have. The scrolling pages gain a Configuration section holding it beside the Quick Shortcuts page, the template library can sort by the priority order, and the priority rows and dropdown previews now render their zones highlighted so each row is readable without hovering it (#926).
The layout picker offers "no template": on a scrolling screen the picker popup listed only real templates, so once you picked one there was no way to take it back from the popup. It now carries a None card alongside them, which sets the screen to use no template at all. The card appears wherever the picker offers templates, including on a screen that has none to choose between, because a screen inheriting a default still has to be able to opt out of it. A screen already set that way opens the picker with the None card highlighted, and the popup opens scrolled to whichever card is highlighted. The cards scroll when there are more of them than fit on the screen, so a long list no longer runs off the top and bottom with no way to reach what was cut (#887, #929).
Pick a scrolling screen's template on the Monitors page, including none at all: a scrolling screen showed a strip preview and an explanation where the other two modes each offer a selector, so the template governing it could only be changed from the layout picker popup. It now has its own dropdown beside them, listing every template plus a None entry the other families do not need. Default follows the default template from Scrolling → Templates, as it does for the other two families, and None means this screen uses no template at all, so its columns keep the built-in width and height steps even while a default is set. None is a new state. Before it, a screen with no template of its own always inherited whatever default was set, with no way to opt out. The pick is applied with the rest of the page, so Discard reverts it (#887, #929).
A scrolling screen says which template it uses: the Monitors page used to label a scrolling screen's preview with the bare mode name and tell you it uses no zone layout, which left the template that actually shapes the strip invisible. The preview now carries the template's name, and the note below it says what that template governs. A screen with no template of its own says so and points at the default template setting. When the template defines starting columns, the note also tracks how many are in use, so it is visible that a starting column is spent once a column has taken it and that later columns open at the template's ordinary width and display. The count is live and follows the strip. The two settings under Settings → Scrolling → Columns that a template overrides, Default width and Open new columns as, now say so on the row, because a screen with a template takes both from the template and the setting looked broken (#887).
Rules can target a specific template: on a scrolling screen the Active layout rule field carries the template in use, the same way it carries the algorithm on a tiling screen, so a rule can set gaps, the overlay, or the lock for the screen showing a given template. The rule editor's Active layout picker offers a Template entry per template. A rule matching the bare scrolling value means a scrolling screen with no template. Match the Mode field to address every scrolling screen (#887).
Shaders for the scrolling strip: the Strip Scrolled entry now takes a shader, so the strip's motion can be decorated as it happens. A strip shader runs once per screen over the scrolling scene while the slide is in flight, driven by how far and how fast the strip is moving, and it stops on its own the moment the strip settles. Anything sitting above the strip, like a notification or an on-screen display, is drawn sharp on top and is never touched by it. Five packs ship: Strip Motion Blur smears along the direction of travel, Strip Chromatic pulls the color channels apart, Strip Jelly bows the rows like a soft body, Strip Carousel tilts the strip like a spinning drum, and Phosphor Gate lights the two screen edges as columns enter and leave, in the Phosphor style. There is no default, so scrolling stays a plain slide until you pick one (#891).
Snapping and Tiling screens can use no layout at all: the None state scrolling screens gained for templates now exists for the other two modes. The layout picker popup carries a None card on every screen, and picking it opts that screen out of layouts entirely. On a Snapping screen that means no zones, so windows float freely and dragging to the edges snaps to nothing. On a Tiling screen the mode stays selected but nothing tiles, so windows open where they please. The Monitors page selectors gain a matching None entry beside Default, where Default keeps inheriting the configured default layout or algorithm and None refuses it, which is the new part. Before this, a screen with no pick of its own always inherited the default, with no way to opt out. The Set snapping layout and Set tiling algorithm rule actions offer None too, so a rule can hold a projector or recording monitor layout-free. Deleting a layout a Snapping screen was using now leaves that screen with no layout instead of silently handing it the default, matching what deleting a scrolling screen's template already did. A screen set to None opens the picker with the None card highlighted, and picking any real layout or algorithm takes it back off the opt-out. The default itself can be cleared the same way. Right-clicking the current default layout or algorithm in the library now offers Clear Default, matching what templates already had. With the default cleared, a snapping screen with no pick of its own shows no zones and a tiling screen tiles nothing, instead of falling back to the first layout or the stock algorithm, and Set as Default on any card brings a default back (#934).
Snap to zone rules can name the zone: the Snap to zone rule action used to take zone numbers only, so a rule that sent an app to zone 1 held only for the layout where that app's zone happened to be first. The action now carries a Zone names field beside the numbers. A name is looked up in whichever layout is active on the screen the window is placed on (the monitor a Route to screen action in the same rule sends it to, otherwise the one it opens on), matched without regard to case, so naming the zones Editor, Browser and Terminal across your layouts lets one rule place an app correctly in all of them. Names and numbers can be mixed, and the window spans their combined area. A name the active layout does not have is skipped, and when two zones share a name the lowest-numbered one wins. The field offers the names your layouts already use from a picker next to it, and the rule list shows names in quotes so a numeric-looking name is not mistaken for a number (#924, #932).
Unfloat fallback as a per-window rule: the snapping setting that places an unfloated window into a zone when it has no remembered one can now be overridden per window with a Fall back to a zone on unfloat rule. A fresh rule opts the matched window in over the global default, and its off position keeps a window floating even with the global setting on (#901).
Keep floating windows above the placed ones, per mode: a floated window used to stack wherever KWin put it, so clicking a tile could bury the window you had just floated over it. Each mode's Window handling card gains a Keep floating windows above switch, under Snapping, Tiling and Scrolling, that keeps the windows you float in that mode stacked above the windows it places. Unfloating the window, or turning the switch off, puts its own keep-above state back the way it was. Switching a screen between Snapping and Tiling applies the new mode's switch to that screen's floating windows straight away, so a window kept above under one mode does not stay there once the other mode takes over. A rule that sets a window layer wins over the switch for the windows it matches, so the existing per-context way of doing this keeps working unchanged (#962).
Scoped exclusion rule actions: two new rule actions split the blanket Exclude. "Exclude from placement" keeps an application's windows out of tiling, snapping, and scrolling while its borders, decoration packs, and animations still apply, which suits tools like deskflow that should stay floating but keep their styling. "Exclude from decorations" turns off only PlasmaZones' own window styling and leaves placement and animations alone. The existing Exclude action keeps its full meaning, and the "Exclude an app from placement" quick-start template now uses the placement-only action. Rules already created from the old template keep their stored blanket behavior (#880).
On-screen displays can be ruled off per monitor: a new Show on-screen displays context action suppresses the layout and navigation popups for a matched screen, desktop, or activity, which keeps them off a projector or a recording monitor while the other screens keep theirs. Its on position works the other way, showing the popups for that context even while the global OSD toggles are off. The None display style still hides everything (#901).
Every rule action explains itself: the rule editor's action rows now carry the same hover info icon the condition fields have, with a one-line description of what the selected action does. The descriptions spell out the couplings that used to be invisible, most importantly that Set opacity, Set tint strength, and Set tint color only take effect while the opacity and tint layer is on for the window (#901).
Rules can match the system color scheme: a new Color scheme rule field matches whether the desktop is using a light or dark theme, so a rule can pick different gaps, overlay colors, or a different layout for day and night themes. The daemon watches the application palette, so when the scheme flips it re-resolves the per-screen assignments and refreshes the overlay and lock surfaces with no restart. Daemon resolved window actions pick the new verdict up on the window's next event. The field pairs with the context actions and the daemon resolved window actions. The compositor consumed actions (borders, opacity, animations) do not see it (#901).
Appearance and animation rules see the active layout too: window rules that set borders, opacity, decorations, window layer, animations, or the snap and animation exclusions can now match the Active layout field, including a scrolling screen's template. Before this, only the per-context rules (gaps, overlay, lock, layout selection) could tell layouts apart, and a window rule on the field silently never matched (#887).
A release grace period for drag triggers: when the activation trigger is a mouse button held while dragging with the other one, the two buttons rarely let go on the same frame. If the trigger button lifted first, the zone overlay cleared before the drop arrived and the window floated where it was released instead of snapping. Each placement mode's Triggers card now has a Release grace period, 150 ms by default, during which the overlay or the re-insert preview stays active after the trigger is released, so a drop just after letting go still lands where it was aimed. The same applies to the stack preview on tiling screens, the strip preview on scrolling screens, and the zone span modifier, which has its own grace on the Zone span card. It only applies while holding to activate, since toggle mode has no release to extend, and setting it to 0 turns it off. Snap assist has one too, on the Snapping → Window page, and it matters most there. The picker is decided at the instant you let go of the window, which is exactly when a trigger held by the same hand has usually lifted already. Simple mode carries the snapping one so you do not have to open the advanced page to reach it. This is how FancyZones feels with its right mouse button activation (#963).
Rendering device selector: a new picker under Settings → General → Rendering chooses which GPU draws the zone overlays, popups, and on-screen displays on machines with more than one graphics device. Automatic keeps the driver's own choice. The selection applies to the PlasmaZones daemon and the layout editor after a daemon restart, and window contents are unaffected because KWin composites those (#883).
A global blur quality setting for decoration packs: a new Blur card on Settings → Appearance → Decorations → General picks Low, Balanced, or High quality for the base blur every glass-family decoration pack builds on. The setting scales the resolution each pack computes its blur at, relative to what the pack chooses for itself, so Low is cheaper on the graphics card and a little softer in motion while High is sharper and costs more. On integrated graphics this is the main per-frame cost lever for glass packs, where the existing Performance card only bounds when the packs animate (#927).
Decoration packs can style the Plasma shell: the decoration pass used to reject every surface belonging to the Plasma shell, so a pack could never reach the panel or the launcher. Panels and applet popups are now decoration surfaces of their own, each with its own pack chain, under a new Shell page beside Windows, OSDs and Popups. Applet popups cover the application launcher, the system tray flyouts, and any widget's expanded view. Engaging a chain for these surfaces is the whole opt-in, whether you build it on the Shell page or apply a decoration set that carries one. These surfaces never take the global default decoration, so they stay untouched until you build a chain for them, and there is no separate enable switch to remember. They also take neither the plain border and opacity settings nor the decoration exclusion rules, because those are written about application windows, so a pack chain is the whole decoration. Shell surfaces always render a pack's focused appearance and keep animating with the Animate only the active window switch on, because a panel is never the active window. All panels on a screen share one setting, because the compositor reports them identically and there is nothing to tell one from the other. A panel is on screen all the time, so expect it to cost more than an applet popup, which is only drawn while it is open (#925).
The Plasma shell's popups can animate: the animation pass rejected every surface the Plasma shell owns, so the application launcher and the system tray flyouts appeared and vanished with whatever KWin does for them and nothing more. A new Shell page under Animations → Transitions gives applet popups their own Shown and Hidden events, which cover the launcher, the tray flyouts and any widget's expanded view. Pick a shader on All Shell Surfaces and the popup plays it as it opens and replays it in reverse as it closes, the same way a window's own open and close events work, or set Shown and Hidden apart if you want the two to differ. No shader from outside the page reaches these events, neither the global row nor the tree default, so they read as no shader until you pick one, and picking one is the whole opt-in. Their timing still follows the global duration and curve unless you set it here. Window rules do not reach them either. A rule can name the Plasma applet popup window type, but these events resolve without consulting rules at all, so a broad rule cannot retarget a shader you picked here. Panels have no events of their own here, since a panel stays on screen for the whole session and hides by sliding under the screen edge, so it never opens or closes for an animation to play on. Decoration packs already reached both, and that is unchanged (#950).
Plasma applet popups report their own window type: the application launcher and the system tray flyouts are a window type of their own, and PlasmaZones did not recognize it, so every one of them showed up as Unknown in the window picker on the Rules page. They now report as Plasma applet popup there, and the type appears in the window type list so a rule can name it. Toolbar windows had the same gap and now report as Toolbar, which that list already offered. A rule that matched either kind through the Unknown type before no longer does. PlasmaZones still does not place, tile or resize these surfaces, so naming the type lets a rule pick them out without changing what happens to them (#925).
Animations say when an event is holding settings from a shader it no longer uses: settings you adjust on an event apply on top of the shader it inherits, and they are named for that shader, so changing the shader on the group above leaves them naming nothing. The event fell back to the new shader's own settings with no sign that anything of yours was still stored, and it stayed detached from any further settings the group made. The event's shader row now says it is following the inherited shader with saved settings that no longer apply, and the group's card says how many events below it are in that state and offers to discard those settings so they follow the group again. Discarding is offered rather than done for you, because pointing the group back at the earlier shader brings the settings back into use. Settings that still name something the new shader offers are left alone, and so is an event that has a shader of its own (#951).
Two tab switches in the Phosphor style: the branded set gains the one animation class it did not cover. Phosphor Transfer breaks the old tab into luminous dust along a climbing frontier and re-forms the new one out of it, so the same material reads as reshaped rather than replaced. Phosphor Iris opens a turbulent ring of plasma from the center of the column, already carrying the tab you picked inside it. Both take the brand gradient from cyan through to rose and expose it as color settings like the rest of the set (#908).
Three geometry-leg helpers for animation pack authors: the shared animation header gains legTranslation, legTravelShare and legDirection, which describe a move in terms a pack can use directly. legTranslation gives the part of the move the whole window shares, legTravelShare says how much of the leg is travel rather than a change of size, and legDirection gives the axis the window went along. The bundled geometry packs use them, and a pack you write yourself can too. The shader validator checks more of metadata.json alongside them: texture paths must sit inside the pack and name a file that exists, wrap and filter modes must use the vocabulary the runtime accepts, and the buffer pass list must fit the four pass budget with no empty entries. Every bundled pack already passes, so this only affects packs you author yourself.
Overlay shader packs can declare 8-bit buffers: a multipass overlay pack whose intermediate buffers hold plain color can set "halfFloatBuffers": false in its metadata to halve the memory bandwidth its buffer passes consume. The bundled Nexus Cascade pack does so. Packs that never set the key keep full half-float precision, so nothing changes visually unless a pack opts in (#872).
Brazilian Portuguese translation: PlasmaZones is now fully translated into Brazilian Portuguese, covering the daemon, the layout editor, the settings app and the KCM. All 3981 strings are filled, including the plural forms and the settings search keywords, so the interface reads in Portuguese as soon as your locale is set to pt_BR (#975).
Settings pages show a loading indicator: opening a heavy settings page for the first time used to leave the viewport empty while the page built in the background, which read as a hang. The settings window now shows a centered spinner with a short caption over that area while the page is still building, and it disappears the moment the page is ready. It only appears after a brief moment of continuous loading, so pages that build quickly never flash it (#930).
The shortcut cheatsheet fills its columns evenly: a long group used to tower over its neighbours, because each group had to fit in one column. Groups now flow across columns like a newspaper, and a group that runs past a column boundary continues in the next one under a repeated heading (#864).

Changed

The daemon and the KWin effect must be installed together: the protocol between them widened over this release, and a signal hook built against an old shape breaks rather than degrading. The protocol version floor moved to 5, and the two now refuse a mismatched pairing at startup rather than acting on a message they have misread. Packagers must rebuild and ship both binaries from the same source (#890, #892, #895, #908, #922, #923, #933).
Breaking D-Bus interface split: the shared engine transport moved from org.plasmazones.Autotile to the engine-neutral org.plasmazones.Tiling interface, which serves every tiling-family engine. The moved surface covers the window lifecycle calls (windowOpened, windowsOpenedBatch, windowClosed, windowMinSizeUpdated, notifyWindowFocused), the tile-request and float signals (windowsTileRequested, focusWindowRequested, windowFloatingChanged, tilingChanged, windowsReleasedFromTiling), the retile methods, the enabled property with its change signal, and the screen set, now published as the union property managedScreens. The org.plasmazones.Autotile name still exists but is narrower now, carrying algorithm selection, master operations, focus cycling, and autotile configuration beside the new org.plasmazones.Scrolling interface. Check any external script against the new interface files before relying on it (#852).
Breaking D-Bus getter shape: the three flat batch assignment getters on org.plasmazones.LayoutRegistry (getAllDesktopAssignments, getAllActivityAssignments, getAllCombinedAssignments) now return a map per key, carrying layoutId beside scrollingTemplate, instead of a bare layout-id string. The matching batch setters still accept plain layout-id strings, and templates are written through setScrollingTemplateLayout. No in-tree consumer read the old shape. External scripts reading these getters need the one-line adjustment (#887).
Saved settings no longer freeze the defaults: the configuration file now stores only values that differ from their default, and saving prunes previously stamped defaults. Before this, any save wrote every setting to disk, so a later release that retuned a default never reached a configuration saved under the old one. Any setting whose value differs from its default is kept exactly as before (#874).
The Layouts page became three per-mode library pages: the tabbed Layouts page under Display is gone, and so is the Display category itself. Each placement mode now carries its own library page where its artifacts are created, imported and managed: Snapping → Layouts for zone layouts, Tiling → Library for algorithms, and Scrolling → Templates for templates. The pages are visible in both settings tiers, and in the simple rail each mode shows as an expandable header with its pages beneath it. Virtual Screens, the Display category's only other child, moved to the top level of the sidebar. A saved --page layouts deep link no longer resolves. The new page names are snapping-layouts, tiling-library and scrolling-templates (#914).
Turning tiling off now stops tiling everywhere: the Tiling master switch already stopped tiling being offered and defaulted, but a screen carrying an explicit tiling algorithm could still tile with the feature switched off. Such a screen now falls back to snapping while the switch is off, so its zones, drag overlay and layout picker are all the snapping ones, and its algorithm is kept, so turning tiling back on puts the screen back the way it was (#934).
Restore to zone on login is now Restore to previous zone: the rule action opts one application out of the Restore windows to their previous zone behavior while every other window keeps restoring, which suits a browser that hops between a work zone and a media zone. The old label undersold it, because the gate fires on every reopen during the session as well as after a logout, so it is named after the setting it overrides and its description spells that out (#889, #901).
The rule action picker is organized by what an action affects: the picker's Window entry used to be a long flat list with three small submenus tacked on the end, while Animation and Appearance sat beside it as separate top-level entries even though everything in them also applies to one window. Everything that acts on a window is now grouped under Window, in named submenus for Placement, Scrolling, Appearance, Animation, Behavior, and the two indicator color families, so the second level means the same thing everywhere in it. The border, title-bar, opacity and tint actions sit together under Window as Appearance, where they used to be a top-level entry of their own beside Window. Behavior is new and holds the window layer and the per-window scroll speed, which are neither placement nor looks. Because everything window-scoped now lives in one bucket, the divider between the entries that apply to a screen or desktop and the ones that apply to a window has a single entry below it rather than three (#947).
Fewer, more useful quick starts in the New Rule dialog: the quick-start grid ran to five rows, and a good part of it was showcase examples the action picker now surfaces directly. It is down to eight tiles, each of which either sets up a context assignment or is one of the rules people actually open the dialog to write. Gone are the layout lock, the portrait-monitor example, the per-app zone-restore override, per-app decoration removal, and the small-window animation skip. The layout lock was the rule form of a shortcut you already have. Every action behind those tiles is still in the action picker, and the portrait-monitor and small-window ones also need a Screen orientation or Width condition, which the condition picker offers. Exclude an app from placement also gets a new icon, because a generic red X read as "delete" for a rule that deletes nothing, and unpinning reads as the deliberate opposite of the Open an app in a zone tile above it (#947).
Every color setting follows your color scheme until you pick one: the zone overlay colors under Snapping → Overlay → Appearance and the border and tint colors under Appearance → Decorations → General now follow one per-color pattern. Each color shows the scheme color it currently follows, and picking one pins it while a Reset button on the row puts it back to following the scheme. The all-or-nothing "system accent color" switch on the overlay page is gone, so you can pin one color and leave the rest tracking your theme. The rule editor's color values present the same control, and the three border and tint color actions gain a Reset that puts a rule back to following the system accent. Zone overlay colors saved by an earlier version carry over when they were your own picks and resume following the scheme when the system colors switch was on, and a stored window border or tint "accent" value becomes the new follow-the-scheme state. Saved settings profiles from an earlier version are converted the same way when they load, where they used to be refused outright. On D-Bus, each color key gains a companion Raw key exposing the follow-or-pinned state directly, the schema type for the theme-following keys is the new themeColor token, and the color keys accept the empty value or the old "accent" spelling to put a color back on the scheme (#899).
Retile Windows moved off Spectacle's chord: the default moved from Meta+Ctrl+R to Meta+Ctrl+T. Spectacle registers every Meta-modified R chord for its screenshot and recording shortcuts, and the system hands a contested chord to whichever application registered first, so on a stock Plasma install the old default either never fired or blocked Spectacle. The new default applies to fresh installs and to anyone who resets the shortcut. A custom binding saved in the system shortcuts store keeps whatever it holds (#897).
The shortcut cheatsheet reads in order and spells out every action: rows inside each group used to appear in whatever order the shortcuts were registered over time, so related actions sat far apart. Each group now reads in a deliberate order, and the digit rows always close their group. The rows that folded two opposed actions into one line, such as Rotate and Cycle Focus, are unfolded, so every action shows its own line with its own chord. The arrow quads and the numbered 1-9 families still collapse, because those read as one gesture over one set of keys (#960).
Snap Assist thumbnails now travel over the graphics card by default: the zero-copy transport that hands each thumbnail to the daemon as a GPU buffer, instead of copying its pixels through the session bus, used to be off unless you set PLASMAZONES_DMABUF_THUMBNAILS. It is now the normal path, and setting that variable to 0 turns it back off. The pixel transport stays in place as the automatic fallback, so a driver, graphics backend or buffer format that cannot carry the shared buffer still shows thumbnails rather than program icons, and nothing about the pickers looks different either way (#968).
Snap Assist thumbnails arrive faster and are captured at the size the card draws them: every window picker used to capture each candidate at a fixed 256 pixel size, one settle delay at a time, so a picker with a dozen candidates spent a fifth of a second just waiting. The captures now run as one batch and are sized to the card that will draw them, so a crowded picker ships small buffers and a lone candidate in a large zone on a HiDPI screen is no longer upscaled. The zero-copy path gives each thumbnail its own buffer, which fixes blank thumbnails when more than three candidates arrived at once. Setting PLASMAZONES_THUMBNAIL_TRACE=1 logs one timing line per thumbnail on both sides for diagnosis (#954).
Decoration corner radius reaches 64 pixels: every decoration pack that offers a Corner radius parameter used to stop at 32 pixels. The ceiling is now 64, so a pack can round a thick panel or a large popup all the way. Existing values are unchanged (#925).
Decoration animations now play on the focused window only by default: continuously animated decoration packs used to redraw every decorated window on every frame. The new default animates just the window you are working in, and unfocused windows hold their last frame. The "Animate only the active window" switch under Settings → Appearance → Decorations → General, shown when the advanced settings are on, turns the old behavior back on (#872).
The zone overlay frees its graphics memory when idle: after a drag ends and the short grace period passes, the zone overlay's shader now releases its render targets and textures instead of holding them for the daemon's whole lifetime. On integrated graphics that memory comes out of system RAM, so an idle PlasmaZones now gives it back (#872).

Removed

Importing colors from pywal or a JSON file: the Snapping overlay appearance page had a From pywal button and a From file button that read a color file and pushed its palette into the zone colors. The import ran once and kept no link to the file, so changing your wallpaper left the zone colors on the old palette. Every color it could set has its own picker on the same page, and those pickers now follow your color scheme until you pin one (#904).

Fixed

Closed windows reopen the way they left: reopening a window brought back the oldest remembered placement for an application rather than the newest, so a long-gone arrangement could outrank the state the window actually closed in. Every fresh window also writes a bookkeeping note into the placement memory before the restore runs, and the restore treated that note as the window's final answer instead of looking for the state the window closed in, which made a floated window re-tile on reopen. A reopen now restores the newest remembered state that does not belong to a still-open window, and closes record their placement while the engine still knows the window. This applies in Tiling mode and in Scrolling mode (#886).
Escape cancels a re-insert without cancelling the drag: with "always re-insert" turned on for scrolling or tiling, pressing Escape mid-drag used to cancel the whole window move, because the placement machinery never saw the key. It now dismisses just the re-insert, the same as Escape does for the zone overlay when snapping, and the window stays in your hand as a plain move. Holding a trigger instead of using always-on already worked this way, since releasing the trigger cancels the re-insert (#873).
Much less GPU work during window animations, especially on integrated graphics: while any window animation played, PlasmaZones forced a full repaint of every monitor on every frame, and a decorated window was fully re-rendered and re-composited each frame even when its content had not changed. Animations now repaint only the screens they actually touch, and a decorated window's cached content survives the animation. This matters most on laptops and other machines with integrated graphics (#872).
Static decorated windows stay pixel-sharp while an undecorated window animates: playing any window animation used to switch vertex snapping off for every decorated window, so on a fractionally scaled display the ones sitting still were softly resampled for the animation's duration. Only an animation on a decorated window relaxes snapping now, so moving an undecorated window leaves the rest of the desktop crisp and saves the full-screen resampling work on integrated graphics (#872).
Surface packs can declare that they leave the window's interior alone: every decorated window told KWin it was translucent, so windows fully hidden behind it kept being composited, such as a video playing behind a maximized window. A surface pack whose drawing stays in the transparent margin around the window can now declare "interiorOpaque": true in its metadata, and a window whose whole chain declares it is no longer marked translucent. A pack that draws outside the window's own rectangle is still presented as an enlarged quad, which the compositor also excludes from occlusion culling, so a pack has to keep its drawing inside the window's rectangle to get the culling back. Border packs genuinely thin the window's own corner and edge pixels, so they correctly keep the translucent marking (#872).
Snap Assist keeps showing window thumbnails: after a snap or two the window picker fell back to program icons and stayed on them until the daemon was restarted. The daemon clears its thumbnail cache half a minute after the picker closes, and the KWin effect went on skipping the windows it believed were still cached, so nothing ever re-captured them. The two sides now agree and the picker shows thumbnails every time. Several capture faults are fixed alongside it. A window with no drawable frame yet no longer posts an invisible thumbnail, a small window is no longer enlarged to thumbnail size and blurred, an offscreen render no longer leaks a texture per capture, and a thumbnail that fails to load now falls back to the program icon instead of leaving an empty square. Clicking and hovering a card also stays reliable while thumbnails are still arriving, because an arriving thumbnail no longer rebuilds the whole picker. The zero-copy transport had its own form of the same fault from the second picker onward, and its thumbnails arrived upside down. Both are fixed (#902).
The built-in Steam rule kept every Steam game out of tiling: the rule shipped to stop Steam's own popups being tiled matched any window whose class mentioned steam. A game launched from Steam carries a class like steam_app_2342813033, which mentions steam, so every game matched, and the rule then took it out of tiling, snapping and scrolling and stripped its borders and decoration packs as well. The rule now names the windows it guards, Steam's own notification popups, and leaves the rest alone, so the Friends List, chat windows, Big Picture, Settings and every game place like any other window. It matches the popup name on either the window title or the window class, because which of the two Steam puts it in is not settled, and it also only takes the matched popups out of placement now, leaving their decorations and their animation overrides alone. A config that still carries the old rule untouched is corrected on the next start and the rule is renamed to Steam notifications, so it says in the list what it now guards. A copy you have edited yourself is left exactly as you left it, and one you had turned off stays off (#947).
A monocle window unmaximized by hand no longer leaves the two sides disagreeing: unmaximizing a monocle window while the daemon connection was down dropped the compositor side's record of it straight away, even though the float could not be announced, so the compositor had forgotten the window while the daemon still counted it as tiled. The window now leaves the layout only once the daemon can be told, the same way leaving windowed fullscreen already worked (#906).
A window moved quickly between monitors keeps the right size: restoring a window's pre-tile size after a cross-screen hop was carried out in a deferred step with no generation marker, so two hops in quick succession left both steps live and the older one applied the first hop's size. The window ended up sized for the monitor it had already left. Each hop now marks its own restore and a superseded one is discarded (#906).
Negated window rules no longer fire on every window: an appearance or animation rule built as "none of" over the Active layout or Tiled window count fields matched every window on screen, because the compositor side never filled those fields in and an empty value made the inner test fail everywhere. Active layout is now filled in properly, and rules over Tiled window count are kept to the surfaces that can answer it (#887).
A rule started from a quick start or a subject can take more conditions: those starting points hand you a rule with a single condition and no way to add a second, because the Add condition and Add group buttons only appeared once a rule already had a group of conditions. Only the Animation and Custom starting points escaped it. A rule with one condition now offers both buttons, and using either puts the condition you have and the new one into a group together. Rules you already created this way get the buttons too (#947).
A rule no longer offers animation events it cannot change: the Override animation actions offered around sixty events to pick from, and only ten of them are ones a rule can affect. A rule matches windows, so it can only change an animation that belongs to a window. Picking a virtual desktop switch, a scrolling strip movement, an OSD, a zone selector or snap assist popup, a side panel, a cursor or widget effect, an editor action or a Plasma shell popup gave you an action that saved without complaint and then never ran, with nothing anywhere to say why. Those events are no longer offered. A rule you already made that names one keeps it, still shown by name, now marked with a warning you can hover or tab to for the reason (#952).
Adjusting a shader setting no longer detaches the event from the group above it: on any Animations page, if you set a shader on a parent row like All Windows and then changed one of its settings on a single event underneath, that event quietly stopped following the parent. Changing the parent's shader afterwards left that one event on the old one. The parent's card also started warning that a child was overriding it, and offered a button that would have deleted the adjustment you had just made. Settings you change on an event now apply on top of the shader it inherits instead of pinning a copy of it, so the event keeps following the parent's shader, and the warning appears only when an event really has a shader choice of its own. Picking that same shader again from the list, to make it the event's own, no longer discards the settings you had already adjusted (#951).
An event's shader row now says what it has, and its buttons do what they say: the row looked the same whether the shader was the event's own or inherited from the group above, while the curve and duration rows either side of it both said which they were. It now says one of three things, because an event can also keep the inherited shader while having its own settings for it, which nothing used to show. The delete button read Remove alongside the shader's name even when the event had nothing of its own to remove, and on an event that did have its own shader it did not remove it either. It left the event with no shader at all. Removing now removes, so the event goes back to following the group above, and where there is nothing of its own to remove the button says instead that it will leave the event with no shader. Picking None from the shader list is still how you choose that deliberately. An event left with no shader now says so, and offers a way back to following the group (#951).
An animation setting that cannot be saved now says so, once: if the folder your animation settings live in was read-only or the disk was full, moving the duration slider or picking a curve did nothing at all, with no message and nothing in the log. Worse, the controls went dead for the rest of the session, so there was no way to try again after fixing the problem. A failed save now tells you once, however many events the edit covered, and the controls keep working so you can retry as soon as the disk is writable again. It tells you again if a later save fails after one has succeeded (#951).
A decoration stays on a window while it closes: a decoration pack rode a closing window out of view only when PlasmaZones was playing the close animation itself. When anything else animated the window away, such as the slide a Plasma applet popup plays as you dismiss it, the pack stopped drawing the instant the window closed and the last of the animation played bare. The decoration now stays for as long as the compositor keeps drawing the window, so a decorated launcher or system tray popup wears its pack all the way out, and so does an ordinary window closing with the PlasmaZones animations turned off (#950).
Resizing a window no longer tears the animation apart: the geometry animation packs that carry a sense of travel read how far a window went from the movement of its centre. A window held at one edge and made wider or taller moves its centre by half the size change while the window itself stays where it is, so those packs treated a resize as a long journey and applied the full effect to it. Phosphor Stream cut the window into lanes that reached their new size at different moments and bowed apart sideways, and Flow and Stretch let one side arrive ahead of the other, which read as the window jumping and settling rather than resizing. This showed up most on a scrolling screen, where cycling the column width or the window height resizes against a held edge every time. The three packs now measure the part of the move the whole window shares, so a window that only changes size grows and shrinks evenly while a window that genuinely travels keeps the full effect, and a move that does both eases between the two. Fold and Ripple Snap never came apart this way, but they took their fold and ripple direction from the same reading and now follow the axis that actually changed.
The shader validator checks the animation packs it used to wave through: plasmazones-shader-validate picks each pack's authoring model from the pack itself now, so pointing it at an animation or surface pack without remembering the matching flag no longer runs the zone checks over it and reports two errors that were only ever artifacts of the wrong checker. The flags still force a model, and all three kinds of pack can be validated in one run. Separately, 35 of the 94 bundled animation packs were only ever having their metadata checked, because they run in the compositor and their shader source is a dialect the offline compiler refuses. Those packs are now compiled through glslang for real, both stages, which covers every desktop transition and the whole geometry set. The run fails if glslang is missing rather than passing quietly, since nothing else checks those packs when there is no graphics card to test on.

Installation

Arch Linux (AUR):

yay -S plasmazones  # or plasmazones-bin

Arch Linux (manual):

sudo pacman -U plasmazones-3.4.0-*-x86_64.pkg.tar.zst

KDE Neon / Debian-based:

sudo dpkg -i plasmazones_3.4.0-*_amd64.deb
sudo apt-get install -f  # Install dependencies if needed

Fedora (COPR):

sudo dnf copr enable fuddlesworth/PlasmaZones
sudo dnf install plasmazones

Fedora (manual RPM):

# Fedora 44
sudo dnf install plasmazones-3.4.0-*.fc44.x86_64.rpm

openSUSE Tumbleweed (OBS):

sudo zypper addrepo https://download.opensuse.org/repositories/home:fuddlesworth/openSUSE_Tumbleweed/home:fuddlesworth.repo
sudo zypper refresh
sudo zypper install plasmazones

Universal Linux (AppDir):
For Fedora Atomic, Steam Deck, or non-root user installation:

tar xzf plasmazones-3.4.0-linux-x86_64.tar.gz
cd plasmazones-linux-x86_64
./install.sh

NixOS (flake):

# flake.nix inputs
plasmazones.url = "github:fuddlesworth/PlasmaZones";

# configuration.nix
programs.plasmazones.enable = true;

NixOS (without flakes):
Build this tag's source against your host's pkgs (no release asset needed):

# configuration.nix
environment.systemPackages = [
  (pkgs.callPackage
    "${builtins.fetchTarball "https://github.com/fuddlesworth/PlasmaZones/archive/v3.4.0.tar.gz"}/packaging/nix/package.nix"
    { version = "3.4.0"; })
];

Post-Installation

systemctl --user enable --now plasmazones.service
systemsettings kcm_plasmazones

fuddlesworth/PlasmaZones v3.4.0 PlasmaZones v3.4.0 on GitHub