Session Restore Finally Exists On Wayland

Wayland absolutely never ceases to amaze me.

Finally, finally, after so long,

the XDG session management protocol has finally been merged into Wayland.

This was opened by Jonas Adahl and Mike Blumenkrantz back in 2020,

and then finally merged by Vlad Zahorodnii about a week ago.

It has taken a while to get here,

but unlike some of the protocols I've talked about,

not for the reason you might think.

Firstly, though, what is the protocol?

Why did anybody care?

For a variety of cases,

it's desirable to have a method for negotiating the restoration

of previously used states for a client's windows.

This helps for e.g. a compositor slash client crashing,

definitely not due to bugs,

or a background client deciding to temporarily destroy its surfaces

in order to conserve resources.

This protocol adds a method for managing such negotiations

and is loosely based on the Enlightenment session recovery protocol,

which has been implemented and functional for roughly two years.

So roughly two years as of 2020.

All be it confusingly named,

what does session management mean?

This is the session restoration protocol.

So if your compositor crashes,

you can then reopen the compositor

and the applications are back like they were.

Now, in some contexts,

this is a little bit more complicated than just bring the window back.

They also have window state.

That does require functionality on the side of the applications.

And as we'll see,

there is a major application involved in supporting this.

Whilst this is exciting and whilst this is cool,

it may not be as exciting to see the merger as you might think,

because this has been around for a while

and this has been supported for a while.

So you've actually seen a merger of this support

into mainline desktops.

And it's entirely possible you were already using this

and didn't even realize.

One thing I want to say is it's technically a lie

to say this was opened in 2020.

Technically, it was actually opened back in 2018,

again, by the same people,

Jonas Adahl and Mike Blumenkrantz.

But this was over on the mailing list

and the mailing list isn't really used at this point.

And the GitLab is the main place to do things.

One thing I want to say is it's technically a lie

to say this was opened in 2020.

Technically, it was actually opened back in 2018,

again, by the same people,

Jonas Adahl and Mike Blumenkrantz.

But this was over on the mailing list

and the mailing list isn't really used at this point.

And the GitLab is the main place to do things.

So this is really a continuation of that older work.

This means we're about eight years of discussion

into this protocol.

But not eight years of really, really intensive discussion.

And here we get into why it's kind of taken eight years

to get here.

Most protocols I talk about that I think are really interesting

have some level of major infighting,

some big arguments happening,

some big blockers that come up that say,

hey, I don't want to support this.

Hey, we shouldn't have this in Wayland.

That's not what happened here.

In fact, it's actually the complete opposite.

For the first year on the GitLab,

there were some threads opened up regarding like spelling mistakes

and some minor implementation details.

Like, hey, how should we phrase this thing?

How should we phrase that thing?

But for the most part,

it's all pretty basic stuff

where nobody had like a major disagreement.

Frankly, not many people were even involved

in working on the project at that point.

It was pretty much just the two of them.

For the most part,

and I know this is rare in Wayland,

basically smooth sailing.

Like, no blockers,

not really much work from people outside of the two of them,

but nothing crazy going on,

which for Wayland, especially at this time,

that's weird.

Probably because people were distracted

with other projects and other protocols

that were a lot more mentally intensive, we'll say.

As of September 2021,

someone posted a ping.

There was a minor question

which wasn't really relevant to the protocol.

Then we have Xaver from the KDE project

who actually had some,

maybe not questions,

but some clarifications about the protocol.

I think this protocol could use a restoration reason flag.

There are multiple situations

in which it makes sense to restore some specific properties,

but not all of them.

Examples would be

application was started normally,

size the window,

key above state,

optionally position on the screen.

Actual session restoration and compositor crashes,

position, size,

key above,

virtual desktop,

position in the stacking order.

And system tree activation,

position, size,

key above,

but not VD,

or position in the stacking order.

And the consensus here is pretty much that

this is implementation details,

this is something that is relevant on KDE,

but doesn't necessarily need to be defined

within the protocol itself.

Granted,

there was some interest in maybe going down that route

and exploring that idea.

And that's sort of the point of these early protocol discussions.

You have the core idea of what you want to do,

and then you flesh things out.

Maybe there's cases you missed.

Maybe there's additional functionality you want.

You have to decide,

what is the scope of the protocol,

what makes sense to be in the protocol,

and then in the desktops implementing the protocol.

This happened in October of 2021,

and then, well,

nothing happened for another two months.

From Simon Sir of the WL Roots Project,

any chances MR can be revived?

From Jonas,

I'll try to allocate some time,

again,

an entire month later,

to address the raised issues.

Should be a bit more up-to-date now,

but needs more work,

I think,

August of 2022.

So,

there's like,

a seven,

eight month gap

between,

hey,

you know,

what's going on here?

And then,

something actually happening.

And from then on,

we finally start to see some sort of

interest in working on the project.

We have David Edmondson from KDE.

We have Sebastian Wick from GNOME.

And in the replies here,

you're also going to see a bunch of other people

from various other projects as well.

Finally,

it seems like people actually realized

that this protocol exists,

or,

if not the protocol exists,

that maybe they just weren't

fully busy with the other things

they were working on.

So,

about two and a half years

into the protocol,

existing,

in the repo,

open,

being kinda discussed,

then people finally jump in.

Truly,

Wayland broken down

to its absolute core.

But again,

still no major disagreements

on the protocol.

More like just,

general concerns,

and technical implementation details.

How should things be done?

Should it be this way?

Should it be that way?

We need to like,

iron these things out

so everybody has an implementation