Our stalwart KDE homepage, which has been with us for several years, has, after serving us well, finally been retired.
The new KDE.org homepage, using the new theme “Aether”, is only the first step of a much longer journey to unify the disparate KDE websites. KDE.org and its surrounding network is made of many parts: forums, wikis, feed aggregates, custom solutions, etc; beyond the homepage each of these will need to be updated. It will be a long road, but the modernization is due.
This new design is still using direct and simple PHP, but the redesign effort will see us land this into a Drupal theme which will eventually be deployed for the wider KDE.org pages. We will still be using the other systems for our other non-static content, but Drupal will be used to replace any page using our current template engine “Capacity”.
I’d also like to give a special thanks to Harald Sitter for making this very quick and smooth transition possible.
Starting off the Plasma Sprint today has been a good start with a little bit of real-world trolling, some quick sight-seeing, and of course, starting to get todos scratched off the list.
Nobody noticed when this was stuck outside the window, and we are happy to report there’s a vast array of KDE software available for Windows. 😉
I’m excited to say it’s that time of the release cycle, meaning we show off a new wallpaper coming to Plasma 5.10!
The new wallpaper is named “Cascade”, English for many interesting things in technology, and French for Waterfall, or many waterfalls. Interestingly, this wallpaper has more layers than the 5.02 wallpaper had triangles.
If wanted, I can again show the process of how this wallpaper was put together, leave a comment and I’ll write it up.
Which brings me to my second todo which I finally got around to – wallpaper downloads! We’ve already had 9 wallpapers for the Plasma 5 series, and you can now visit https://store.kde.org/ to download each of them. For Nuno’s original “Next” wallpaper, I’ve provided a “remastered” version for 4k monitors named “Prev”. It’s not perfectly accurate, but for those who liked the original it is available;
Additionally, there’s a new wallpaper named “History” for those who want to celebrate 10 iterations of Plasma 5 and the upcoming 11th iteration;
(Clicking on any of the images will take you to the relevant page on the KDE Store)
Lastly, much work as been done on the KDE website redesign. I’ll be blogging about it later, but here’s a screenshot showing the general design for the new homepage:
(sorry if the image is a bit fuzzy)
The 2017 Plasma Sprint is sponsored by Meat Water.
In my off time I’ve been closely examining the Legend of Zelda Link to the Past tilesets and sprites, and I’ve been learning a huge amount about how that game is assembled visually. it’s amazing how much they managed to do with the limited resources of the SNES.
For a game I’ve played religiously as a child, it’s interesting to see the imperfections which I completely glossed over even after several complete playthoroughs. There’s also some neat workarounds Nintendo did while preparing their graphics.
So here’s some “trivia” I found while closely examining the various maps and shots of the game;
Bricks lining the floors of diagonal walls are always rounded. This is not decorative, but a limit of their sprite-sheets 8×8 tile resolution. There are 5 unique 8×8 tiles used to create a diagonal wall, it would have required 6 tiles to add the 3 pixels needed to straighten the edge, and another 16×16 composite tile. Same, apparently, with the bottom of diagonal cliff edges. If they fixed this, several tight diagonal corridors would have been impossible.
In the overworld you will never find a flower that is NOT above a sprig of grass. You will always find flowers tiled with grass, or above and to the left of two sprigs. If you see three flowers, it’s just a combination of the other two patterns.
Live grass and dead grass never touch. I’m guessing because dead grass is a palette swap, so they would have had to include a tile-set for those edges. Instead, there’s always a dirt buffer or a cliff.
Bobbing flowers in the overworld have more frames of animation than any single enemy walk cycle. As a matter of fact, some enemies only appear to have one frame in their walk cycles – it’s just flipped to create the illusion of movement.
The animation used for guards falling off an edge contains more frames of animation than several enemies have for all their animations, total.
There is one tree in the game with a root placed on dirt/cliff edge. The tiles that make up that root are recoloured grass; because of that, one of the colours is slightly mismatched.
Cliffs are by far the most complex tiles in the game, but also tend to show the most seams between tiles. To say it must have been painstaking I think would be an understatement.
Most dungeons and houses share the same brick walls, only palette swapped with different tops. Instead, dungeons distinguish themselves with unique entrances, pillars, and decorations. There’s also a unique entrance for the monastery which was unused, possibly to avoid it being confused with dungeons.
Walls in houses and dungeons also don’t obey perspective, various tricks are used to maintain the illusion. The southmost walls are sometimes outright covered, and very seldomly will you see half-walls or “tall” objects touching the south walls.
Braziers, tall lampposts, half-walls, and various other doodads to not contain transparency keys. While not surprising on its own, it’s shocking to realise how many things don’t actually have “shapes” or “blend in” to their environments when closely examined, simply having grey backgrounds which most people must never notice. Those moving spike traps? Those are square, you just thought they were pointy.
Anyway, those were some fun facts.
Zelda: A Link to the Past is simply an amazing piece of work, and the tilesets are remarkably compressed for what they were able to create; PNG images containing the complete light world are larger than the entire game itself, not including the alternate dark world, insides of houses, or dungeons.
I’m very excited to let everyone know that as of tomorrow I’ll officially be joining Blue Systems, working full time on KDE and related projects! The chance to really immerse oneself completely into something you love and also work alongside people you absolutely respect is mind-blowing.
I would like to deeply thank Blue Systems for this opportunity, I hope my contributions will match the awesome generosity that everyone in the community has given allowing me do this. Thank you!
After a seeming eternity the unthinkable has finally happened; DWD has been discussed formally on an implementation level and it’s exciting to say that some parts are now under development. Thanks to the CERN Sprint we’ve had Martin Gräßlin, Sebastian Kügler, a couple others, and myself in one room able to make final decisions on how it will all come together.
Dare I say DWD is officially real, entering development, and coming? Yes!
Previously I’ve made two posts about DWD concepts, this post will summarize the basics of DWD as it has been finalized. Some parts of both designs previously posted have been used and I’ll make another post later including mockups with more detailed information, but for new here’s an overview of DWD basics;
At its core DWD will work with ‘Semantic Objects’ and ‘Priority Groups’. Semantic objects refer to things like ‘media player controls’, ‘navigation’, and ‘actions’. Applications bundle Semantic Objects into Priority Groups, then push those groups to the window manager.
The window manager will tell the app whether a group was accepted or rejected; a group is rejected if any single semantic object in that group is denied for any reason. Higher priority groups get first swing at embedding their controls, and it may affect widget placement in certain situations, such as phone controls.
From there applications just hide their own elements in response to what groups were accepted. There will be some events and flags as well, but we won’t get into that yet.
One aspect to note is that DWD will offer no customisation on the client-side. I had gone down that rabbit-hole in an early draft and we all deemed it overcomplicated. Ultimately what applications need to know is that the controls are being served – not how or where they’ve been served.
One thing we did was look at is Gnome CSDs which offered all the craziness applications could possibly want, and we noticed they weren’t actually being all that crazy with it. Generally the same controls made repeat appearances and when it really comes down to it in practice there’s not much of a value in extreme customisation. As we said previously if you need extreme customisation and weirdness this may not be the method for you – which is fine. At the same time we would recommend application authors examine why they would need exotic controls, and why they specifically need them in the windeco.
Stewarding the Protocol
One thing that was discussed was who and how to steward the protocol. When I first posted about DWD there was backlash about KDE being a ‘protocol gatekeeper’. Afterwards I proposed an extension-based design which also had backlash because it could make the protocol technologically ‘complex and messy’.
Ultimately we decided to steward the protocol and simply work with anyone who wants to be included in the design process directly. We will accept input into where the protocol will go and provide any resources we can.
One thing that was made clear was that some groups are uninterested in considering the DWD approach after being asked. We all agreed it’s not worth making a convoluted extension system just to cater to groups which probably won’t participate, instead focusing on making the best protocol we can for those who want DWD. For those environments that will not support DWD I’m glad to say that it’s still 100% compatible and applications using it will continue to work as normal, they just won’t have content in the decoration. We will not be breaking other environments.
Again, we’ll be open and welcoming to anyone who wants to join us in working on and implementing DWD.
The Implementation Plan
Right now early work is being done on our existing frameworks to move them into position to implement DWDs. Once that is done we’ll implement the protocol with a minimal number of Semantic Objects, and using the low-level API port a small number of simple applications as a beta. Applications being considered for initial DWD tests include Konsole, Kate, KCalc, and similarly small apps with basic requirements.
After the API has proven itself on smaller-scale applications we would move up to heavier applications. KDevelop was mentioned specifically as a candidate as its relatively heavy UI could benefit from space-saving DWDs while developers could very quickly give us high-quality feedback. This may be where we move to higher-level classes which will hide away the group/object system as well.
Designs & Reference Material Incoming
I’ll be making another post later with designs which should be mostly accurate to what the final protocol will produce; accurate enough to place in the Wiki as design references for how applications should look when using the final DWDs.
While Martin will continue focusing down Wayland and making excellent progress, he also had a rough timeline for when we can expect basic DWDs make an appearance. I won’t quote him as it was an off-the-cuff estimate, but it’s exciting to know there’s light at the end of the tunnel, and that we’re out of the conceptual phase.
On a complete aside it was a complete pleasure meeting everyone. Great to see some of the friends I met last year again, fantastic to make many more new ones, and I wanted to thank everyone in the Sprint as well as those who supported it for making such a great event happen.
Yesterday I landed in Geneva, ready to participate in the 2016 multipurpose Sprint at CERN.
After a successful touchdown, I somehow dragged myself onto the CERN campus after over 20 hours of riding trains, flying, waiting, and running. Half dead and ready to drop I got my bearings around the campus while keeping an eye out for other Sprint Participants, and I have to say my first impressions of the facility were shock and awe; more amazing than I could have anticipated.
Of course I was too tired to appreciate it, and I kept pestering the hotel staff to see if a crashpad was ready.
All at once everything seemed to come together and I ran into Alex, Riccardo, Kai, Martin G, and Sebas in short order. Today was just my arrival day, so I wasn’t breaking out the laptop and starting intense development or planning sessions with anyone, but even in our casual conversations we all excitedly at one point or another started planning to plan exciting things.
Right now? I’m waking up, looking at the view (pictures later, probably will update this post) and ready to get started.
Since Martin posted his Wayland progress I’ve noticed an uptick in questions about CSD, so I figure now is a good time to upload this post I’ve had sitting around, as for the past month I’ve been closely examining the concept of “Dynamic Window Decorations”, or “DWDs” and how to better implement them.
When Last We Saw Our Heroes
For those who need a primer or reminder, DWD is the sister of “Client Side Decorations”, or “CSD”s. Both CSD and DWD are methods for placing widgets in the frame area of windows to save vertical space, look cleaner, and either make applications feel unique or more integrated.
CSD charges the application with drawing the whole window including the frame, instructing the window manager to discard the provided frame. This is the method used on Windows, OSX, and GTK. DWD is aiming for the opposite approach; the window manager continues to draw the window frame, but the application can request certain widgets to replace the window title. Martin Gräßlin plans to keep as much as possible on the server-side as there are many important advantages including customisation, stability, trust, and integration.
DWD “1.0” Was Getting Complicated
One thing CSD will always have over DWD is customisation; when an application has free reign over the whole window it can literally do anything; it can make windows round if it wants to, it can invent crazy widgets and put em’ in the title area, and more. DWD isn’t suited to this, and while designing the first iteration of the protocol I tried to bang a square peg into the round hole by providing those many possibilities.
In my infinite wisdom I re-invented X, with a sprawling protocol that covered dozens of edge-cases which would likely never be used. Even with that, people still complained about the fact that many customisations would still impossible. People also didn’t like the KDE crew being the stewards of this protocol, as different environments want to do different things.
DWD, as originally envisioned, had to change – it was just too complicated and inflexible. Listening to the feedback it was clear the protocol had to be simple, flexible, and tractable. A large requirement was also making it able to grow outside of KDE with or without our ‘approval’.
DWDs New Approach
DWD, as I have drafted it, has been boiled down to a discovery service whose sole purpose is getting apps and window managers to figure out compatible protocols, and specify some standard UI controls which will use those protocols.
Here’s the quick overview on the current core “DWD Protocol”, again, as of my current draft (which could totally be rejected):
DWD will be organised into “extensions”. Extensions are just blueprints listing required D-Bus specifications, widgets/controls, and options.
Applications and the Window Manager handshake for compatible extensions.
Applications tell the Window Manager what controls from those extensions it should display, and how it wants them laid out.
Applications hide their native controls.
DWD is done and gets out of the way at this point. Control is handed to specifications like MPRIS2, and Window Managers (or Plasma) control the app through those protocols using the requested controls.
That’s it, DWD “2.0” in a nutshell.
KDE will need to create some reference extensions (plus some D-Bus specs) and hopefully everyone will be happy enough to standardise on the basics. From there any environment can create specialised extensions for DWD, we can work with extensions we like, and maybe standardise on the really useful ones (much like libinput has been folded into many environments). If someone makes an awesome extension that handles admin access requests, we could use it. If we make an extension that handles progress charts, someone else could adopt it. I’d like us to develop two reference extensions: a basic toolbar extension, and an MPRIS2 extension.
Advantages over “1.0”
Security is the biggest upside to offloading work on other protocols. DWD doesn’t care how the standards are implemented, so they can be as secure (or insecure) as they choose to be. Security issues or weaknesses in the protocol itself will be mitigated, as the protocol is much smaller. Patches for applications or changes to functional protocols can be made without breaking DWD.
Integration is also another bonus. Parts of the desktop can integrate the protocols extensions use, without DWD needing to explicitly support it. The best example is MPRIS2, which already exists and has amazing support everywhere. The idea behind DWD is that we create more MPRIS-type extensions as we need them.
Finally, core DWD is out of the hotpath for data passing. Window Managers don’t need to be “like X” and conform to complex drawing and customisation tasks. Hopefully as a de-stresser to Martin, this method of offering DWD will be much more easily implemented in a plugin architecture which can be gradually expanded upon. We won’t need to have the full protocol out-of gate, and environments can start with the bare basics and evolve as useful extensions are finalised. I don’t know how he might want to do it, but DWD extension plugins could be potentially be maintained entirely outside of Kwin (or other Window managers) if we play our cards right.
Nothing is perfect, so of course there are downsides;
The big elephant in the room. Going over more standard protocols (and not bloating the new specification) means applications will have no say over how content is styled in the window. I considered this for a while and ultimately decided that it’s O.K.
We could still offer a few more standardised ways of doing common things we do today, such as passing a colour palette to sync with the window, but outside of the handshake I’ll push for an extension-over-integration policy.
The application doesn’t need to know how things are done, only that they’re getting done. The WM knows more about the environment it’s in than the application; functionality is what matters. The volume button on a computer might be shown as a slider, but on a touch-device it may be a larger button with a popout slider. Maybe a phone will simply use the hardware controls. It’s up to whatever is managing the control.
For people already seething with rage ready to point at me and say “Linux is about choice! Applications should choose what their UIs look like!” I will point out; applications can chose not to use DWD. They can choose to implement a CSD-based application. But lets be real here: when we find a need for speciality widgets, if they are really something useful, their host toolkits/environments can always add the extension.
Generally though, if an application is doing something really unique it’s probably doing it’s own thing anyway – like Chrome/Chromium – or breaking the local HIGs. If you absolutely need to save that 18px while also showing a one-of-a-kind rainbow-powered rocket-widget which must be in the frame… CSD is the price of needing to be that special.
With anyone able to create extensions, there’s a change we might have a situation where two environments create two similar offerings. For this, I believe it’s a chance for everyone to experiment, and then work together to standardise. The one thing this means is that applications created for another environment might take longer to get CSD-like functionality, though they should present their interfaces in their traditional application UI.
I think this is still better than CSD, as often a broken CSD is unusable vs a DWD which will simply not conserve space.
So, in the end, this is the direction DWD has gone. Keep it simple, let anyone decide how it should be used, and piggyback off of proven protocols.
MPRIS2 shows what a purpose-driven protocol can do, and already has lots of examples of “remote control” interfaces. Outside of MPRIS2 we would create missing D-Bus specifications which would hopefully make the wider applications library accessible in a similar manner. Specifications for things like progress management, search, sharing, and many others could be created which will benefit applications, and allow deeper desktop integration for everybody.
For those who saw the previous designs in my original DWD blog post, not much has actually changed visually. Everything I posted is still possible, but now we have a much more practical way to do it which I am much more confident we could reliably implement and share.