During the Sprint at CERN everyone got to take a tour of the Large Hadron Collider, it was a fantastic time and a proud moment for members of the KDE community to see the massive and incredible machines which happened to have KDE software running at the controls.
We had a rare opportunity to actually go 100 meters underground and look at the scope of it – grand and atomic – and look at one of the greatest achievements of society with our own eyes.
Once we got our eyes on the massive structure a couple of the guys pulled out a bag and said “Hey, want to see something cool?”
Over at the injector (where they feed matter into the LHC) some of the other VDG members had snuck in a bag of paintballs. It was ON. Much like a pneumatic tubes of the late 1800s, the LHC consumed the ammo with gusto. I was sure our giggling would give us away, but we made sure people crowded around the controls before anyone knew what we were doing.
The way the LHC was laid out, there was various catwalks surrounding where the beam passes through. We found a pair of convenient walkways ripe for us to jump across which would let us get hit – we didn’t need to worry much about timing, after all, the gauges already indicated the first paintball was going 92.3% the speed of light.
It was a good time. We had some bruises, other peoples heads and arms simply vanished at near relativistic speeds. We lost 3 members of the VDG, 5 WikiToLearn editors, and Sebas was the only Plasma developer to go, though watching him get sucked into a black hole made by a near-light-speed paintball was really, really cool.
As an aside, since he’s beyond the event horizon, I’ve taken over his blog. Any amazing accomplishments he makes from now on were actually all me, and I should get the credit.
And that was our tour of the LHC. We’re confident in our productivity to take over for the now deceased community members, and we firmly believe the sacrifice was totally worth it. After the tour we got into our cars to drive back to the sprint proper – albeit with some more shoulder room in the vehicles – and we got back to work after turning the LHC into the worlds largest paintball cannon.
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.
The Sprint in Geneva has been a bustling experience, there’s huge amounts of throughput from every participant, and seeing the progress is exciting. There will be a great many blog posts from many people with thrilling progress. I can’t spoil everyone’s work, but I can share at least a few things.
The first is weather! It was previously announced that Plasma 5.6 will be seeing the return of the weather widget. Lots of design work and planning has been done for it and while not everything we discussed will make it in for this release I do happily get to show off our new Breeze weather icons;
There’s more which will be added, but this is the base set which reaches parity with the Oxygen weather icons. Things like high wind, smog, and sandstorms are all in the works.
I’m very excited to announce an updated colour palette. The palette that we’ve been was the formal ‘core’ Breeze colours with an few extended colours I threw in for icons. While it got the job done, we’ve very obviously been using colours not in the official palette for icons using pastels and off-white tints on several occasions. The extended colours were also a bit ad-hoc, with some cases where gaps in hues and luminosity would limit what we could do if we rigorously adhered to the scheme – one thing I did in the wallpapers . Here’s the third iteration of our palette;
It’s not yet in the wiki, but we do have it in GPL format for use in Inkscape, Krita, and GIMP (special thanks to the colour dropper widget which greatly speeded up the process). It’s not completely 1:1 with our existing colours, but it’s close enough and we’ve played loosely enough that it’s not obvious which upcoming icons use the new palette and which use the old. Eventually we may look at more formally updating existing icons, but it’s a low priority. I’m very excited for what this palette will let me do with wallpapers, as I can now make brighter wallpapers without them being over-saturated.
There’s so much more happening, but it’s impossible to write about every detail.
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.
I gotta hand it to every KDE contributor; I call this review comprehensive but there’s an incredible amount of information I could not cover in a sane article, and it could have easily been twice that length while still failing to hit every feature.
From me to everyone; you’ve all been knocking it out of the park, great work, and thank you. I’m looking forward to what the KDE community brings in 2016!
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.
I made a promise to myself about a day ago that I would not touch my recently-arrived Steam controller until I finished a few of my projects. After successfully not touching it yesterday, I caved like a wet blanket and set my alarm for two hours of play – maybe I wouldn’t be going into the deep end, but I figured I should at least see how my investment panned out considering the unique aspects of the controller.
I don’t get to play games often, but the odd session once or twice a month is necessary to ensure my head doesn’t pop from overworking myself. The only downside is my increasingly awful wrist which sounds and feels more like a cement grinder from mouse-and-keyboarding all day during work and play; so I use a controller sometimes. This is hard though, since even the “best” controller (Xbox 360 brand) doesn’t do most games I enjoy, and I can’t play first-person games (like Amnesia or SOMA) on a controller – I just hate doing it.
So I ordered a Steam controller, and excitedly unboxed it and plugged it in under Valves promise it was a cure-all for PC games. For the first 20 minutes, I can’t say I was impressed. My first 20 minutes with the Steam controller made me yearn for the Xbox controller again.
The Steam controller did have some immediate and notable aspects; I did not expect the haptic feedback to be so incredible. I was expecting an smartphone-esque situation where you shove your finger onto a flat surface and get no tactile feedback. Somehow they got it to work, how a little rumble could make the matte surface somehow feel tactile and real I can only attribute to black magic. It is also incredibly clicky, with many buttons having a nice mechanical snap. The unit is firm and solid as well, and I feel like I could really wrench at it during an intense moment.
But that wasn’t saving my lackluster ability to play Borderlands with it; I was having a bad time because of awkward controls. At this point I had clocked in about 5 minutes of gameplay and 15 minutes dicking around with the controller – failing because the customisation was nothing short of overwhelming. I decided to move onto the next game: Alien Isolation. I had clocked in a few minutes a couple weeks ago or so, and I decided to see if I could have better luck there. The recommended controls were sluggish, and I found myself getting a bit of a cramp because the controls were insensitive and slow. I was sick, thinking “$60 for this?”.
Then I discovered “Community Profiles”, mentioned as an input tip at the bottom of the screen. If one thing was “make or break” for this device, community controls would make it. Community profiles are complete controller configurations created by other players, listed by popularity. The most popular control scheme described itself as being “ACTUALLY FUCKING USEFUL”. I selected that one. And about 10 seconds later I was completely sold on the Steam controller.
This specific scheme was fast, responsive, accurate, and I can only say it deserved its place as being the control scheme used by nearly 3X the users as the default layout. I stopped thinking about the controller and I’m absolutely impressed to say the least, able to effectively use the trackpad and flick around with mouse-like ease.
Since using a good control scheme, I quickly reversed my previous faltering position on the controller. I had never, ever in my life considered first-person games “playable” on a controller. I’ve never liked it, but on the Steam controller I think I actually *prefer* ditching the mouse.
The main achievement is the speed and accuracy the controller provides compared to a traditional controller. The default game controls set for the Steam controller were unusably slow and almost too conservative… But a more optimal configuration, while not as accurate as using a mouse, in some ways is more responsive as you only move your thumb – not your whole hand as with a mouse – which feels a touch faster and less strenuous. Wonderful for my awful wrist.
Though I haven’t used it yet, you can offset this tradeoff though “Input Modifiers”. You set one input on the controller to be a modifier, and it will change the behaviour of another input. A good use-case is if you are a sniper in a game, and you want your aiming touchpad to be made slower and more precise when using your scope. You make the scope button your modifier, and suddenly you are able to manoeuvre effectively while running and be hyper-accurate while shooting. I’m looking forward to trying Left 4 Dead later with it.
Despite the very positive results with software schemes, I will complain a bit about the feel of the controller. The trackpads are what I worried about the most, and I’m glad to say they delivered – but because of their massive size it forced Valve to move their buttons closer to the centre of the controller. This makes the analog stick and action buttons a bit hard to reach, and I found my left hand had a more awkward grip trying use them. The triggers were well placed, but the shoulder buttons seem specifically designed to be difficult to reach; they stick out compared to the triggers so you have to move your otherwise comfortable index fingers up, over, and out to hit them. Generally speaking the controller doesn’t allow me to have access to all buttons at a given time, and I do need to either stretch my fingers or rotate my hand a but to reach some buttons no matter how I hold the controller. Finally, I feel like portions of the controller should have been rubberised a bit; because your hands are more in-front of the Steam controller compared to contemporary controllers, I do feel like I want a little more grip on the unit.
Overall, I’m now very impressed. Probably the biggest thing is making sure you check the community control schemes if you find yourself bemoaning the generic scheme. From what I understand some games do have specific built-in schemas, but if it doesn’t it’s a safe bet to assume someone has decided to share their ultimate controller layout with the world, and it will probably do the job very well. I have average hands and I’d say the controller makes me consciously reach for some buttons at times, but this isn’t a deal breaker and the controller does what it does so well I can forgive some button-placement fumbles. It’s also the most customisable controller I’ve ever seen and the Steam client allows you to customise everything to a ridiculous degree, which is definitely the secret-sauce to why it can work well with so many different games.
If you play Steam games and have $60 to spare I recommend the Steam Controller, though if you have small hands you may want to find one in the wild and see how it feels first. If you pick one up do try community control layouts as they literally make-or-break your ability to play a game as a poor scheme will make the controller feel useless – but a good scheme will blow other controllers out of the water.