Thank you for providing further informations about Mir. I wasn't aware that Canonical dropped the libhybris integration. And thanks for taking care of that!

Snaps
Point by point:

• It's probably easier for me to explain with an example. The LibreOffice snap in the U.Store uses the "Home" interface, which was meant to be transitional. Now that Canonical has no plan for Ubuntu Personal, could we expect similar interfaces to be "standard"? Could they break (in terms of UX and security) the current UT/UP security model, which relies on ContentHub for content sharing?

• Huh, when I used "content" I was referring to files, document, or more generically data. I wasn't aware of such interface.

• Yeah, that was my fear. The only example I found for adding new interfaces is this one. My impression is that Snaps have been designed with a strong centralization, afaiu.

Besides that I do think that integrating wayland xdg-shell clients is worth trying - but there are some interesting problems to solve around the trusted prompts and the drag & drop support through content hub.

Snap support and/or Snap based system

• Content Hub and content interfaces are orthogonal concepts - applications communicating via content hub just need access to its dbus interface afaikt
• content interfaces would be used when you want to share libraries between snaps - i.e. qt gtk and other big chunks.
• For an all snaps image I expect that we would still require more interfaces than those that are already inside snapd - for an all snaps image we would have to ship the android user space libraries loaded via hybris either in a separate or inside the gadget snap and then expose access to libhybris out to those snaps that would access it.

Btw there is now android boot loader support: https://github.com/snapcore/snapd/pull/3324

For the confinement, the problem is not to run Snap, but running Snap with all the security enhancements. AppArmor itself is not a problem, but adding the module in the Android kernel might be (for what I understand of all that magic @mariogrip & co. usually do behind the scenes).

Click and Snaps are a bit different but, overall, yes, they are meant to solve the same problem.
Any opinion is welcomed here. Don't think I'm an expert here, I just know how to write some code -
mostly by mistake

UITK
I just built an application using QQC2 Templates, it was just for giving it a look, so it's not a real QQC2 theme extension yet. It's "mostly" based on official specs, including the new style for buttons, except for a few things that can't be done because I'd break compatibility with other QQC2 styles.

Packaging
Flatpak is almost agnostic, the current limitation is that has been built just for applications. A few features perhaps are not there yet, but I don't think it's necessary anything more than runtimes, applications and portals. The only potential problem is that aims to be compliant with other FreeDesktop.org standards (i.e. Ubuntu Touch uses a ton of custom stuff in order to limit apps capabilities).
About security, I guess it's everything handled by Flatpak itself, since each app needs to be launched through the Flatpak binary. Apps run in a "fake" file system, apparently.

• The flatpak security model – part 1: The basics
• The flatpak security model – part 2: Who needs sandboxing anyway?
• The flatpak security model, part 3 – The long game

About Snaps, it was firstly meant for IoT, then they added support on desktops. Phones and tablets were the last to be supported (paradox since it's an evolution from Click).

Shell
Well, don't get me wrong. I said that the shell is probably the only thing we should develop and design by our own. Mine was meant to be just a provocation: the vision of Canonical about convergence has been proven by facts to be a failure. After five years of development, the whole project has been thrown away. If it ever landed in time for 18.04 LTS, it would have scored 3 years of delay (out of 6 years of development).

What we all say we actually want is probably a standard .deb Ubuntu distribution running on a phone. I start to think this article was right. What Canonical was trying to achieve is much different from what we want. Ubuntu GNOME would be a perfect match on tablets.

About Google and Chromebooks: as long as Android apps run on a different OS which provides the same user experience, that's software convergence.

About Microsoft: I've heard they want to develop a single codebase. Anyway, Continuum is a reality since two years now, so seems reasonable they want to do something further.

If a 10" tablet could be used as a PC replacement in specific scenarios, I still think it's pretty hard to think of a phone running as a full desktop replacement: I would likely saturate all the RAM of a Samsung Galaxy S8 just with my normal activities.

EDIT: Ok, this is shorter

Still i think (if non-developers are allowed their opinion here ;-)) that maybe snaps might be easier for transitioning from clicks as the hooks/interfaces for snappy are derived from what was used with clicks (pls correct me if i'm wrong)

Toolkit

Oh, I have had understood things wrongly. I was sure that UITK 2.0 was going to be based on QQC.

I am aware that the toolkit was to be revamped and totally agree that there is no point to develop it in a current shape - closely tied to Ubuntu and isolated from upstream and other distros.

Therefore my vision is not to follow the isolation path, but - as I mentioned - transform the UITK into a style and set of extensions for Qt Quick Controls that would be distribution agnostic. To put it simply, UITK would become a library to create convergent apps using Qt Quick Controls (and some new controls based on them). The goal would be to rewrite all the Ubuntu specific controls (swipable list items, adaptive page layout, bottom edge etc.) to be based on the Qt Quick Controls and replace all duplicating ones (labels, buttons, etc.) with those from QQC. Apart from that create a QQC style being an incarnation the current Suru design.

When we are there, try to implement the styling and components that are present on mockups that did not manage to come true - new buttons, context menu etc.

I believe toolkit made in this way could gain some traction both inside and outside the Ubuntu community.

With "Let's use this" I meant mostly the concepts, mockups and design since the code of UITK 2.0 isn't there. And as you pointed that moving to QQC was not a goal, let's change this one point of Canonical's vision.

According to your experiments: wow, interesting. Have you used some QQC's header or tried to reimplement Ubuntu's one and base it on QQC? To be honest it could make it as a starting point for the... hmm... let's call it Suru QQC Extensions

Packaging applications

I believe that one of the most benefits of snaps are confinement, interfaces and of course snap images. How does FlatPak cover this? Does no AppArmor mean no confinement? It may be simpler to implement, gain traction and be used with legacy devices, but how does it address the security?

Snaps (as Clicks before) have been created with phones/tablets/other devices in mind. Flatpak is probably more desktop oriented. Will it address the issues Snap already does or require another solutions to be implemented anyway? I don't know Flatpak that well to answer those questions.

QtWebEngine

Well, Oxide is now abandoned. Moving to QtWebEngine would probably have excactly the same effect, but without need to develop the engine. I fully agree we should move.

Shell

Well, honestly if we dropped Snaps, Unity 8, UITK... what makes it Ubuntu Touch. If we did this, let's just join forces with KDE on Plasma Mobile and Kirigami, introduce convergence to KDE, wait for Halium, create OS based on that and port it.

I believe that a single codebase has important advantages - ability to run the same app on phone and the desktop and seamless transition to desktop when you dock your phone. I think that this is the heart of convergence - having your PC in your pocket. Microsoft's and Google's approach? Chromebooks are not the convergence - you can just run Android app on the laptop, but not the other way around. And there is no docking - a phone doesn't become a desktop. Microsoft tries (or tried) to do this and they are thinking about the single codebase as well. But with all their power in my opinion they have failed.

I believe that it's Ubuntu who started to do the convergence right. It is an enormous amount of work, I fully agree. But I don't think there is a way around. We can do the less work, but then we will not make the convergence a reality.

UBUNTU UI TOOLKIT

Where we are?

Nothing to add here.

The legacy

Well, I also have the specifications for each component of the UI Toolkit. I never mentioned it in the Telegram group since I'm not sure if it's a good idea to publish an internal document. In any case, for the design we're almost fully covered.

UITK devs, anyway, weren't planning to use QtQuick Controls 2.
Ride With Us: The Road To UI Toolkit 2.0

Let's use it then!

I'll be pragmatic. UITK devs wanted to keep their "custom" code for the 2.0 release. We simply can not.
We need to consider a few things first:

• We don't have any traction from Canonical trying to "force" its own standard, both in community and commercial products.
• We need to be appealing with third party developers so that they support our platform. The more we use standard (upstream) technologies, more developers would be interested in supporting and using our stuff.
• We don't have resources to support an UI Toolkit written from scratch (~200k lines of code - if it's worth to mention it). How many of us are interested in maintaining a toolkit that was about to be refactored in many ways? If we have no people working on this, it could be a problem.

Just going a bit technical, a bit part of the Ubuntu UI Toolkit is not necessary anymore:

• Screen Pixel Ratio is not required anymore. QtQuick natively supports high-DPI screen since Qt5.6
• Theming and Styling. QtQuick Controls 2 already implements support for theming, it works nicely, and it's easy to use.

By the way, in order to add a bit of context at the original discussion (which started on Telegram), I was porting the Suru design language (used by Ubuntu UITK) on QQC2. This was the result of just a few days of work.

The required effort to support QQC2 is extremely low, and it would help us in case we want to distribute our apps on other platforms.

CLICK AND SNAPS

I'd like to use Ubuntu Core too. So, a big +1 from me. An interesting consequence about adopting Ubuntu Core (if it's a viable solution, of course) is that whatever the shell will be, it could be ported on RaspberryPi 2/3 too, with just minor changes. That would simplify development a lot, and would help UBports in recruiting new forces.

Anyway, I would enlarge the discussion, including Flatpak too.

Snaps

• They are developed by Canonical. They still have plugs for Mir/U8/UT, but Canonical is still pushing its technology on desktop now. How can snaps be useful for us in our goal to converge? Most of the apps in the store support only those "transitional" interfaces. Our content sharing model, based on ContentHub, would be broken, I guess.
• Snaps have interfaces. Not sure how the current set of interfaces would fit with our confinement model. Extending the set of interfaces doesn't seem something easy to do, since they are hardcoded in "snapd". (not sure though - needs exploration)
• ContentHub has been written in order to integrate with Click and Snap confinement policies. And no, that copying files around was actually a feature, not a bug. Many core app developers, included me, asked Canonical to whitelist core apps, but it hasn't been allowed. (If we want to keep ContentHub, BTW, what we surely need is mime type support)

Clicks

I see some advantages in keeping clicks. However they won't fit in a long terms, since they heavily rely on what the single platform offers. To be brief, we can't force developers to adapt to a platform with a low adoption. It should be the other way round. But as @Flohack pointed out, they could be preferable on low-end devices, because of their low memory requirement.

Flatpak

• It's a FreeDesktop.org standard, so we can expect support on any major distribution. This is relevant for political issues.
• I was having a look at the KDE interfaceportal implementation for their apps. It seems it could do the work ContentHub currently does on UT. Plus, it seems to be easily extendable, and to provide an easy way to track hardware usage or content access for each app (I saw some GNOME design proposal).
• Anyway we still need to provide a .deb-based image, unless we move to OSTree (however, at that point, what's left of Ubuntu?)
• No AppArmor requirements in the kernel. That should make it easier to support legacy devices.

Summing up

• Click is preferable since we could avoid to deprecate support on legacy devices.
• Flatpak seems to be more flexible and would give us an extra traction on different distros.
• Snap is almost equivalent to Flatpak (except for AppArmor req.), but, as an extra, we could provide the whole system image as Snap. However, it seems we can't use Snap on legacy devices.

Just a note on memory management. It's Unity8 that uses ~400-500MB of RAM, so I think it's better to fix the issue there. Also, if we ship a more recent version of Qt libraries, we could benefit of all the performance and resource-usage improvements Qt did since version 5.5.
I'd be more than happy to give up on the ability to run 4-5 apps in background, if I can use the latest version of the OS.

Furthermore, Oxide vs. QtWebEngine

I'll be extremely brief. When the Oxide development has started, there was no QtWebEngine (Chromium-based) alternative. What to choose? QtWebEngine. Like for UITK, I don't think maintaing a Chromium fork is in our current abilities.

Furthermore #2, the Shell

I'm probably looking for a flame war here. But even Unity8 needs to be discussed.
This is probably the piece of software we won't replace, since it would be the core of any convergence strategy we'll decide to adopt. And it's where we might need to lead any design decision.

My considerations here are personal concerns:

• We all want convergence. But what does really mean "convergence"? We have more ways to achieve convergence, even Canonical tried different approaches (e.g. Ubuntu for Android - abandoned because no OEM was interested in).
• Just for records - don't take it serious - for the M10, we could even consider to run Ubuntu GNOME directly (its UI would be easily adaptable).
• A single codebase is not really necessary, see what Microsoft of Google did with UWP and Chromebooks.
• If we plan to support ARM devices, we wouldn't need any "Mir on Wayland" solution in a short-term then. Just Mir is enough, and Canonical is still keeping maintaing it.
• What about Yunit? I'm not discussing their possibilities to success, and I'm happy to see that a former Mir/U8 developer has joined their forces. I'm just talking about the common efforts. It's still unclear to me which kind of collaboration has been publicly announced. It has been said "we'll collaborate", but since now I haven't seen anyone (Marius G. excluded, which is extending support for Wayland in Mir) really willing to take changes.
• Why don't start anew, writing a new software on QtWayland at that point? Or, on phones, we could still use e.g. Lipstick.
• How much time would take to develop something new or to add support for Wayland in Unity 8?

It has been told (I can't find the article now) that Unity 8 would have required ~4-6 months of further work, in order to work properly on desktops. Now, with Mir not being developed for desktops anymore, without those resources Canonical employed on Unity 8, it could require ~12-18 months, or even more. Are we sure people will still be interested in Unity? Or that other projects (e.g. KDE) wouldn't improve their mobile projects (e.g. Plasma Mobile)?

I'd start any discussion on these topics by considering which are our current internal and external limitations. It potentially implies some compromise, but what I personally want to see now is my apps running and being distributed both on phones and desktops of any kind (no matter whether it's Ubuntu, Fedora, OpenSUSE running Unity, GNOME or KDE).

A few things have happend since I started this thread. I have some recent thoughts that I would like to add to discussion - especially regarding convergence:

Ubuntu UI toolkit

Where we are?

The current situation is not too happy I believe: there is an SDK abandoned by Canonical using ony the custom controls (created before QtQuick Controlls have landed). Those custom components have no adoption outside of Ubuntu Touch ecosystem and they are probably not portable.

Another problem is that other Qt apps, GTK+ apps etc. do not integrate graphically with Ubuntu Touch, which is a pitfall as well if we wanted to deliver the seamless convergence. A sweet spot would be if you couldn't tell the toolkit without at a first glance when looking at a siple app (I don't mean the situation where toolkit specific widgets are used etc. of course).

The legacy

So, what we are left with?

1. The toolkit. Working code and many apps based on it.
2. The beginning of the new (2.0) toolkit planned to be transited to Qt Quick Controls.
3. Suru design language. A beautiful and well thought-out approach to applications UI. Designed for convergence.
4. Ubuntu design page - there are the gui guidelines and tons of mockups - including those not implemented yet but showing the direction Canonical had with the toolkit.
5. Canonical design blog - there are some app mockups that can be invaluable for continuing both SDK and Core Apps.

Honestly? It's a lot!

Let's use it then!

I wasn't aware of the UITK2.0's existance until a couple of minutes ago. So there goes the plan suggestion:

1. In general I believe the UITK vision and concepts are unique and cool and apps like core music app, Dekko and uNav proved it. I am totally for keeping it.
2. Canonical realized that Qt Quick Controls are the base to move onto and that is the best plan I think. The UITK2 repo has appeared on GitHub - it should be evaluated and forked. Most probably in cooperation with YUnit and under their GitHub team (if they will want to do this).
3. The mockups should be moved somewhere in case Ubuntu Design webpage disappears someday.
4. The goal should be to have the two things: one is a portable Ubuntu (or Suru) style for QQC (who knows, maybe it could even pushed upstream to Qt?) which could be used to style anything - including existing QQC applications written without UITK in mind and a portable library providing a set of additional components - AdaptivePageLayout, Ubuntu's list items, bottom edge, headers etc. There should be no duplication though - Ubuntu buttons, label, checkboxes, radio buttons etc. should be dropped in favor of Suru styled QQC.

Clicks and snaps

On this topic I'm still in favor on snaps and even moving to Ubuntu Core (to be precise I mean wrapping Halium-based images into core, os and gadget snaps to make the Ubuntu Core images out of them). I know, there are many different thoughts on this topic, it's just my opinion (as the whole of this post, frankly). Let's list the reasons I see now:

1. Snaps are actively developed by Canonical, further development of Clicks would be yet another task for Ubports' devs.
2. Snaps have interfaces. It can be worth to investigate them, as they can allow to build the awesome permission system - where the apps could hypothetically declare their own permissions (such as Dekko declaring permission to read mails that are stored somewhere inside its snap settings - you could decide in system settings what apps can read from dekko).
3. Maybe it could be possible to replace content hub with a set of snap interfaces. Maybe it could be possible to avoid copying files around and multiplicating them every time you pass it from app to app. In my opinion apps should be able to read (for example for viewing) files from other apps without copying them to their own directories.
4. Convergence. If we want convergence, there will be the need for incorporation probably both snapd and flatpak in the images (and not to use things such as Libertine to install desktop apps at some point of time).

I think that's all for now. I'll keep posting any further ideas for discussion here.

They could have get us some last minute contacts to organize the takeover. But we are more or less alone, and our network to former employees is not that huge.

Bear in mind that it might not be legal for them to pass on (former or current) employees' contact details to you without those people's explicit permission. And since those people are probably quite busy sending out CVs and suchlike at the moment, they may not be very responsive in the short term even if they want to get involved with Yunit/UBPorts.

3.Contact as many Canonical developers and designers directly. Request them to share all the information, plans, designs and everything else what could speed up resuming development. Find out who of them would like to help. Have a chat with Ubuntu Core team to find out their attitude and how Ubuntu Core can power the phones.

Seems to be a very good advice. the abrupt end of the project may drive some individuals toward a personal commitment and support for the project .
has anyone tried something in this direction?

And what I would suggest for the start of the development

You've made a very nice summary of ideas here, but for the start of development it may be important to distinguish much more clearly between what's genuinely needed versus what might be helpful at some point in the future.

Probably the most valuable thing that can be done as a starting step is just to look at what are the minimum set of changes needed to complete Unity 8 on its own terms (and "complete" in this sense probably means finalizing a viable desktop). No major re-architecting or trying to replace important bits of the stack -- just try to follow through on the final touches of the project as it exists, the kind of stuff that Canonical's team would have been doing if the project had carried through.

The reason to do that is because, by trying first to understand and complete the project on its own terms (i.e. the convergent OS where the same codebase can serve mobile, tablet and desktop), everyone involved will learn a good deal about the actual issues of the project, and about why its developers made the choices they did.

From that vantage point, everyone will be much better placed to make informed decisions about what really needs to change in the long run -- whether it's what to do with Mir (it may not need to be replaced at all given Canonical's ongoing plans for it in IoT projects), whether a new app store is necessary (it may be possible to continue to use the existing snap store just fine), or any of the other considerations that might come up.

• Video: https://youtu.be/MVEm4X2ptEk
• Text: https://blog.ubports.com/2017/04/08/ubports-community-q-a.html