projects – Page 2 – Martín Abente Lahaye

Portfolio 0.9.11

Catching up

The last couple of months have been particularly busy:

A few more releases down the road, the portal permissions support in Flatseal has finally matured. I took the opportunity to fix a crash in Flatpak’s permission store and to complete its permissions API, to pave the way for existing and future Flatseal-like front ends.
I took a short break to take care of my twenty five Sugar applications. Released a new version of the BaseApp, and updated every application to the latest upstream release and GNOME runtime.
On a personal note, I have been mentoring some brilliant interns at work, which is a refreshing experience after so many months of lockdown due to COVID.

What’s new in Portfolio?

On the visuals department, this new release brings a refreshed icon by @jimmac, which looks fantastic and takes it closer to the modern art style in GNOME.

Regarding features, well, there’s quite a lot. The most noticeable one is the Trash folder.

One of my goals for Portfolio is that, for the little it does, it should just work™. It shouldn’t matter what the users environment might be or how it’s being distributed. This imposes some technical challenges and, I imagine, is one of the reasons why a few file managers available on Flathub don’t provide feature parity with their non-flatpak versions.

Because of this, I prototyped different Trash folder implementations. Initially, I went for the right way™ and simply relied on the gvfsd. Sadly, there were a few issues with the sandbox interaction that prevented me from fulfilling my goal. Therefore, I stuck to my own implementation of freedesktop’s Trash spec. I must admit though, that I really enjoy reading these specs for Portfolio.

But there’s more!

A common issue among users, of the Flatpak version, is that they can’t see the real root directory. This is understandably confusing. Therefore, Portfolio now includes a Host device shortcut, as a best-effort attempt to mitigate this.

If you have been using Portfolio on devices with slow storage, you have probably seen that loading screen a few times when opening folders. I will eventually get around to something more elaborated but, for the time being, I reduced these load times with a bit of cache.

Among other improvements, there are now proper notifications when removing devices, filtering and sorting options will persist between sessions, and the files view will restore its scroll position to the previous directory when navigating back.

As for the bugs, kudos to @craftyguy for fixing a couple ones that prevented Portfolio to run on Postmarket OS.

Last but never least! Thanks to @lqs01, @AsciiWolf, @eson57, @Vistaus, @rffontenelle and @cho2 for helping me with translations.

Flatseal 1.7.0

A big new release of Flatseal is out! It took a bit longer, due to that little Portfolio detour 😅, but it finally happened. This release introduces some subtle improvements to the UI, along with one major new feature; initial support for Portals.

Starting with the UI improvements, a massive libhandy’fication happened. Main widgets such as the window, groups and permissions rows are now using libhandy widgets. This helped to remove a lot of custom code, but also brought neat little details like rounded corners, the ability to toggle permissions by simply tapping the rows, among other things. Thanks to @BrainBlasted for starting this work.

The applications search entry can now be toggled, and its position is now independent of the scrolled window. Not having to scroll back to the top to change the search terms, makes it a bit more usable.

This release comes with an offline version of Flatseal’s documentation, thanks to a newly-added viewer. For now, the documentation is only available in English. I am hoping to improve the document before any attempt to translate it. Thanks to Apostrophe for such nice exporters 🙂.

Moving on to the new big feature, yes, portals! With this release, it’s now possible to review and manage dynamic permissions. Thank @hferreiro for requesting this feature.

This initial support includes six of the most basic permissions. The plan is to support as many of these, as long as it makes sense of course. Having said that, a few important notes:

Not all dynamic permissions rely on stored “decisions” and, therefore, there’s nothing for Flatseal to manage.
Not all Flatpak applications use portals currently and, therefore, many of these new options won’t be very useful until portals get more adoption.
It is expected to see many of these permissions “grayed out”. Check the tooltips for the specific reason but, it is likely due to the fact that some of these portals have not been used yet and, therefore, have not set up any data for Flatseal to manage.

Well, that’s it for now. Any suggestions, ideas, bugs, I am always available. And if you haven’t tried Flatseal yet, I recommend getting it from Flathub.

Last but never least, thanks to everyone who contributed to this release, @BrainBlasted, @cho2, @Vistaus, @ovari, @eson57, @TheEvilSkeleton, @AsciiWolf and @MiloCasagrande.

Portfolio 0.9.10

Almost 3 months, and 15 releases later, Portfolio development has been moving pretty fast. Well, for a weekend project 😅. So much so, it’s worth of another blog post. With today’s release, it provides a much smoother file management experience for mobile users. These are the highlights:

This new release introduces a new home page, which serves as the starting point for the navigation experience. Besides its utility as “quick access”, it also provides a better interface for managing external devices. Kudos to @nahuelwexd for designing it.

Moving places and devices to the home page solved one of the biggest issues preventing Portfolio to run in portrait mode. Even though is not perfect, it feels pretty good already, like holding a handheld game console.

Another missing piece, now set in place, is the properties viewer. For now, the viewer displays the most basic properties but, I can keep adding more on demand. Thanks to @bertob for the design hints.

With the properties viewer in place, I was finally able to finish the org.freedesktop.FileManager1 interface implementation. In case you’re wondering, this is what other applications invoke to display files, e.g. Chromium’s “Show in folder” button on it’s downloads page.

Like these, many other things improved and changed since the original release. Portfolio is, and feels, generally faster, e.g. the loading progress bar doesn’t show up anymore unnecessarily, cancelling paste operations is now instant, and is available in 6 different languages. But, if you’re curious, here’s the full CHANGELOG.

Of course, all of these improvements would not have been possible without the feedback from the community. Big thanks to everyone who has contributed so far. Now roll the credits!

Kudos to @eson57, @Vistaus, @henry-nicolas, @AsciiWolf, @cho2, @rffontenelle, @srevinsaju, @GNUuser, @aVolpe, @philipzae, @MobianLinux, @linmobblog and @DanctNIX.

Portfolio: manage files in your phone

On mobile phones with GNOME

Ever since I met @Kekun in Barcelona, during LAS 2019, I got intrigued by this wave of “running GNOME on phones”. It took several months until I could get my teeth into it though. Between my Sugar applications project, Flatseal, a new job and, mostly, due to how hard it is to get a proper Linux-capable phone in Paraguay, I had no time or choice really.

My first mobile-related project started in August, after many failed attempts to buy a proper Linux-capable phone, I decided that my only way forward was to get a refurbished Moto G4 Play, which has acceptable support thanks to PostmarketOS. The project goal was to provide more clarity on how far we are from a Flathub-powered GNOME community-driven OS for phones. The results were better than I expected, but still far from a daily driver. If you’re curious about this research you can find it here.

To my surprise, one of the biggest missing pieces was the file manager. I tried all the options that fell into my selection criteria, but none provided a good experience for me. The major issue I found is that the available options seem to land on a “designed for the desktop, but will fit in a small screen with a few tweaks to improve the UI” category.

Since then, I started to think about how would a simple file manager for phones would look like. By simple I mean two things. First, that it provides that ninety percent of things that people need to manage their files and, second, a UI/UX that is specifically crafted for phones and small touch screens.

A couple of weeks ago I finally got the weekend slots I needed to hack on these ideas.

Introducing Portfolio

A minimalist file manager for those who want to use Linux mobile devices.

That was the best description I could come up with, hah, it’s funny because it’s true. Portfolio is my first application that is one hundred percent designed for mobile devices. Supports the most simple, yet most common, tasks like browsing, opening, moving, copying, deleting and renaming files.

A whole weekend went into just getting the interaction model right, but I believe it paid off. The UI is clean. The relevant actions are always visible and just one tap away. The application assumes it’s running on a resource limited device and, therefore, sacrifices some speed for improved responsiveness. As seen above, it even provides an About “dialog” fit for small screens.

Of course, this application is far from perfect and, actually, it’s just a few days old. It urgently needs lazy loading, an explicit way to get out of selection mode, tests, tests, tests, among other things but, I believe getting the interaction model was the right priority for these limited weekend slots.

Portfolio is now available on Flathub. If you have a Linux-capable phone, please give it a try!

Last but not least, thanks to @eddsalkield and @bertob for their amazing early feedback.

Sugar Learning Tools – Part III

Catching up

The last couple of months have been hectic: more Sugar applications with Flatpak, quality of life improvements to Flatseal, tinkered with the idea of a Flathub-based OS for phones, showed case the tools to create modern native applications with JavaScript, shared my views on how Flatpak is reshaping the desktop’s future, teased the GNOME Circle at the Linux App Summit, planted the initial seeds to kickstart the GNOME community in my home country, started contributing to Flathub’s backend and other non-desktop projects (oh, yeah, and then my actual job 😂).

For this post though, I would like to focus on the progress made to Sugar applications with Flatpak.

Sugar Learning Tools

During my GUADEC presentation I mentioned the things I wanted to achieve moving forward with this project. Primarily, improving the documentation and porting guide to ensure that this project can scale and, of course, port more art-oriented applications.

For improving the documentation, I ported Sugar’s official “hello world” and re-wrote the porting guide based on this application. By using this minimal application as an example, it becomes much easier to highlight the key porting steps and concepts. I also took the opportunity to update the application itself to the latest version of the Sugar toolkit.

As for porting new applications, I didn’t get to port as many art-oriented applications as I wished. Mostly due to the fact that most of those are still using GTK2 and Python2, so it would require more time I can afford at the moment. Nevertheless, I ported some pretty awesome ones.

Paint is a playful painting application. It provides all the classic tools a young learner would expect, e.g. brushes, shapes, text, transformations, adding images, etc. Plus, it can enable sounds to make the experience extra funny.

Pukllanapac is a Rubik’s Cube-like game. The objective is for the learner to exercise their problem solving skills. The application has different patterns for circles, triangles, and hexagons.

Solar System is an interactive visualization. The goal is encourage the learner to know more about the planets and their moons. In words of the original developer of this application (@cvgarciarea) :

It is my hope that this tool serves as a practical and interactive way to explore astronomy.

It’s worth noticing that he was one of the early young Sugar hackers that showed up, when the Uruguayan government introduced OLPC nation wide.

Swift Feet provides a series of entertaining physical activities. It encourages the learner to stay active. Includes exercises and dances. This application was originally designed for OLPC Canada in collaboration with ParticipACTION Canada and Ophea organizations.

Sugar Chess is a friendlier front-end for gnuchess. Its features go beyond and above other popular chess applications, e.g. allows the learner to customize the graphics, replay matches, use different modes, and more.

Moving forward

There’re still plenty of applications that need to be ported but, for the time being, I need to find a better way to monitor these twenty five applications that were ported so far.

I have discussed the idea of a developer Dashboard with Flathub’s maintainers but, for the short term, I might end up hacking something quick for my own needs.

Another imminent task is to update the BaseApp and all applications to the latest GNOME runtime, but this should be trivial. If anyone is interested in learning about packaging applications with Flatpak this task could be good a opportunity, so feel free to contact me!

GUADEC 2020 and Flatseal 1.6.1

GUADEC 2020

Two weeks ago, I had the chance to share my experiences Flooding the desktop with learning tools, with the wider GNOME community at GUADEC Even though the event went online for the first time, due to COVID-19, it went pretty smooth!

The event was full of great talks, including many from former colleagues, Archaeology of Accessibility by @ebassi, Parental controls in GNOME by @pwithnall, What’s new with JavaScript in GNOME by @ptomato, Communication Hacks by @1nuritzi and many, many others.

The social hours were hilarious and was great to see so many familiar faces. I am really hoping that, whenever we go back to physical events, we can still keep this online experience for those unable to assist.

Flatseal 1.6.1

Since the previous release, I have been slowly making improvements and have finally collected enough of these for a new release.

What’s new?

I started with a second pass on the big refactor I made for 1.6.0. I finally got rid of some “evolutionary” leftovers, and made all the individual permissions models even more self-contained. Again, this makes things much easier to extend and maintain.

Before I move on to the user-visible work, a few words about this project. Flatseal uses overrides as its backend to modify permissions, but it’s really more than just a graphical version of flatpak-override command-line tool. What I am (at least) trying to do with this project is to provide an improved experience for how Flatpak users interact with their applications permissions.

The most noticeable change in this release happens to be a good example of that.

This release adds support for session-bus and system-bus overrides. Users can remove, add or modify existing bus names. Thanks to @digitalethics for requesting this feature.

Being able to modify an existing bus name without having to explicitly think in terms of removing an existing name and adding a new one, seems trivial, but it’s quite an improved experienced already. The model is “smart” enough to detect these changes and translate these properly to one or more overrides. Like this, every switch and text entry in Flatseal went through these kind of considerations.

This release also adds other minor changes, including a fix for cases where applications icons were missing (e.g. for LibreOffice), a small change in the permissions groups labels to match even closer the terms used in flatpak-run and flatpak-override (e.g. “allow” instead of “features“), a fix that prevents Flatseal from crashing when multiple versions of libhandy are available (e.g. when running non-flatpak versions of Flatseal) by @fushinari , among other even minor fixes.

What’s next?

As I mentioned in my previous blog post, my short term goal was to keep adding support for more overrides. Now that Flatseal has almost reached feature-parity with flatpak-override, and that the model representation is way more readable, I will start to reach out to some people from the community to see if they would be interested in seeing Flatseal model moved into a separate library. Help will be welcome!

Last but never least, special thanks to @eson57, @AsciiWolf, @ovari, @cho2 , @Vistaus and others for keeping Flatseal translations up to date.

Flatseal 1.6.0 and beyond

It’s been five months since the original release of Flatseal. Seventeen releases later, this project has evolved incredibly fast thanks to the Flatpak community.

Flatseal is a graphical utility to review and modify basic permissions from your Flatpak applications.

When I started this project as a weekend-long challenge, I considered the possibility of creating something useful but, I clearly did not expect such overwhelming reception.

From the first Flathub discourse members testing it, to having a humble chunk of the Flatpak community using and recommending it, this has been a really fun experience that I’d love to share in more detail at some point.

For now, I would simply like to thank everyone who contributed so far and share the new things coming with the 1.6.0 release.

So, what’s new?

The biggest change in this release is the complete rewrite of how Flatseal manages and mixes permissions and overrides. This is one of those things that no one should ever notice, when it goes well of course. In this case though, these changes makes it easier to expand Flatseal with new override options and, more importantly, to maintain it.

To put these changes to test, I added support for two new overrides options: persistent homedir-relative paths and environment variables.

You can add new persistent homedir-relative paths. Even though this override is not the most commonly used one, it has proven to be quite useful. Thanks to @ManIVIctorious for the suggestion.

You can add, remove or modify the environment variables that are exported to the application. Thanks to @trashcan55 for the suggestion. I have been using this quite a lot myself to debug Flatseal.

Another key feature, made possible with the rewrite, is that Flatseal is now fully aware of overrides that it doesn’t support. If you have been using Flatseal and flatpak-override CLI together you know exactly what I am talking about.

Before this release, Flatseal would only load the overrides that it did support, and later drop the ones that didn’t. Of course this caused confusion and headaches to people using both tools. Well, these will be kept intact from now on, making Flatseal future proof at the same time. Thanks @WhyNotHugo for highlighting this issue.

Before moving on to other changes, I would really like to give special thanks to Tobias Bernard @bertob for all the design ideas, mockups and feedback from the very beginning of this project.

Talking about Tobias and his ideas, now Flatseal displays basic information for applications. Aside for the obvious usefulness of this information, e.g. for troubleshooting, I like to see this as a small tribute to applications developers.

The title, author, version, last-updated date and Flatpak runtime are now displayed.

Moving on, another quite popular family of requests from the community has been to include application-management features, e.g. options to uninstall or launch an application. Even though I understand why it would make sense to have those, I decided to draw a line and keep Flatseal focused on managing permissions. Well, that was until @Johnn3y suggested to add a show details button, which is a good compromise.

This button will redirect you to the software manager page for the application, where you can launch, update or uninstall the application. For the time being, only GNOME Software is supported since it provides API for doing this, but I am looking forward to add support for others if possible.

As part of this change, I had to reconsider how to display these buttons, so that there would be enough space left in the top header bar in mobile mode. To solve this, Tobias suggested to move these buttons to a separate action bar at the bottom.

Having these buttons down there solves the space problem, and also improves Flatseal ergonomics when used on a phone.

Another small change I managed to land last minute was to rename permissions references. Instead of showing something like features=bluetooth, it will now show allow=bluetooth which is what you would use from flatpak-override or flatpak-run CLI. Thanks to @digitalethics for the suggestion.

Last but not least, special thanks to @eson57, @MiloCasagrande, @AsciiWolf, @ovari, @cho2 and others for keeping an eye on Flatseal and helping me with translations!

So, What’s next?

Well, for the short term I will keep adding support for more overrides requested by the community.

For the longer term though, considering that I now have a better idea of how to model this problem and, that other projects have found Flatseal source code useful to kickstart their permissions managers, I think it would be interesting to consider moving Flatseal backend to an introspectable library, to make things easier for other projects. But, let’s see if there’s interest for that.

Sugar Learning Tools – Part II

It’s been many months since my visit to Barcelona and the Linux App Summit. Since then, I got unexpectedly distracted by another project , started a new job and, well, COVID-19 happened.

But, even before all that, a lot of progress was made to bring Sugar applications to the desktop with Flatpak and Flathub. I thought it would be worth sharing the progress.

Here’s a quick summary:

Twenty applications were ported, with the help of Google Code-In students, and are now available on Flathub.
Identified the most common issues of running these applications outside of Sugar. Many of those issues are handled nicely by Sugarapp now.
Made several upstream contributions, which also benefits other Sugar Labs community efforts.
The process of porting applications is decently documented.
Started making these Flatpak bundles easier to maintain.
Nowhere near to support collaboration yet.

Here’s an overview of these applications:

Abacus it quite self explanatory. What’s remarkable about this application, is that it includes a tool to build a custom abacus. Fun fact, many years ago, it was used by teachers from Caacupé – Paraguay, to build their own abacus to handle fractions. The Caacupé abacus has been part of this application since then.

Chart is a simple tool to visualize data. What’s nice about this application is that the learner can take data from other Sugar applications and visualize it. Works with the most classic visual representations.

ColorDeducto is not the typical learning tool. It’s a challenging game about recognizing patterns and developing inductive logic. Something cool about this application is that the learner can create custom patterns using Python. The application was ported by our all-star Google Code-In winner Srevin Saju.Dimensions is a fun pattern-matching game. The learner can compete against an AI, and it can be quite challenging as categories, difficulty levels and timers start mixing .

Finance is an interesting take on learning by doing. This application can help the learners to manage a real budget, and use basic home-finance concepts while they’re at it. Another awesome port by Srevin, by the way.

FotoToon lets the learner create their own comics. It’s simple and fun. These comics can be saved to many formats, including video. A popular choice nowadays, with everyone spamming memes at each other, haha.

What to say about FractionBounce, learn the concepts of fractions and percentages while kicking a football? It can never go wrong. Yet another port from Srevin.

Implode is a tetris-like game. Dear learner, watch out for this application, it’s quite entertaining. Don’t let anyone try it on your computer, they might not give it back for a while, hah.

Maze is a simple game but, activate these mines, turn off back tracking and go crazy with that difficulty button. It will blow anyone’s mind. This application was ported by Marcus Chong, another brilliant student and one of our runner up winners.

We are half way through the list, so let’s take a little breath and remind you that if you don’t have high school students contributing to your project, you’re really missing out.

Alright, let’s continue.

Measure is one of my personal favorites. This application bridges the real world and the digital world. The learner can visualize their own voice, tune instruments, and record and export that data to visualize it with the Chart application.

Memorize is more than just a pair-finding game, it’s a tool to create these games. Learners can mix sounds, images, text, text to speech and send these games to their friends.

Another personal favorite, Music Keyboard. Simply put, converts the learners computers into more than thirty instruments. They can record and share their masterpieces. Fun fact, my 4 year old nephews approved it, very loudly.

Physics is the perfect example of playful learning. It’s simply a physics sandbox. Learners can create structures, machines and simulations. Of course, they can also watch it all crumble, hah.

I suppose is no surprise that Pippy is my personal absolute favorite. Lets the learners write and run Python scripts in a surprisingly simple way. It comes packed with tutorials for writing Python games, physics simulations, and even GTK applications.

ReadETexts does many things. Helps the learner find books from a freely-available catalog of thousands of books. It downloads the books and it can even read them with a delightful robotic voice, hah. Works with dozens of languages. Another application ported with the help of Srevin.

It can’t never hurt to have a slipstick calculator available right? hah. I think it’s a great example of many other Sugar applications, tiny curiosity-driven tools. Sliderule is another port from Marcus.

Speak is another personal favorite. It engages the learner to write and read, while conversing with Alice, a bot with a particular sense of humor. It works in many different languages.

Story is probably one of most lovely applications I ported. The premise is quite simple, it randomly generates a sequence of images and asks the learner to create a story that connect these images. They can record their voices or use text.

Turtle in a Pond is a gem in disguise. At first sight is simply a game about trying to catch a turtle before it runs away. The real fun though, is when the learner realizes that is possible to write Python code to make the turtle smarter.

Words is a simple, yet powerful, dictionary. Doesn’t require internet access. It can read the words and their definitions with its robotic voice. Works in many different languages.

That’s it!

The focus of this project will move onto making these Flatpak bundles more easily maintainable, for now. I am working on a BaseApp for that purpose, and will soon start updating each of these applications.

If someone is interested in any of the topics I discussed here, or just wants to contribute to this project, contact me via the GNOME Rocket chat. I can help you get started. There’s a lot of work to do!

Finally, I want thank everyone who contributed to this project during these months. Special thanks to Srevin Saju, Marcus Chong (and all our Google Code-In students), Bilal Elmoussaoui, Bartłomiej Piotrowski, Nick Richards (and all other Flathub admins who helped me with the reviews), and Jorge García Oncins for all the early testing and feedback.

Linux App Summit 2019 and Sugar Learning Tools

Last week I traveled to Barcelona, Spain to attend the Linux App Summit. For the first time, GNOME and KDE co-hosted this event to bring together everyone involved in the Linux application ecosystem. The summit was packed with a diverse audience from all over the desktop community and the world. Being there and being part of what is coming for the future of this ecosystem was truly an enriching and motivating experience.

Equally important, I was able to meet with former colleagues and friends from Endless, and from the GNOME community. I made many new friends as well. All of this is certainly priceless for someone living far, far away. If you want to know more details about what happened during the summit, I highly recommend reading blog posts like the ones from Julita Inca, Daniel Garcia Moreno, Nick Richards and others. The social media coverage was superb, so check their twitter and youtube channels as well.

During the summit, I had the opportunity to present a lightning-talk titled Flooding the desktop with great learning tools. In this blog post, I will try to expand just a bit more on the details of this project. TL;DR I am making Sugar applications available to all desktops and Linux distributions using Flatpak and Flathub. But first a bit of context.

That is me making the most out of my precious five minutes. Thanks to Matthias Clasen for the encouragement and this picture.

Sugar is a unique desktop and a set of applications for Linux. It was designed for children to learn while having fun. It is Free and Open Source Software. Sugar Labs is a community of volunteers who maintains the project until this day. Since its original release, as part of the One Laptop Per Child project, dozens of educators and developers have created hundreds of great learning tools, most of which are only available for this platform.

Flatpak is a next-generation technology for building, distributing and safely running applications on Linux. It allows developers to build their applications once, and ensures that it will run properly on any Linux distribution. Beyond its technical marvels, it is a game-changing technology that will bring developers and users closer than ever before. Flathub is a community-driven hub for distributing and downloading applications powered by Flatpak. Both Flatpak and Flathub are Free and Open Source Software, as well.

I have spent many years working on desktop technologies in education and access to information, including the Sugar desktop and Endless OS. So the idea of putting Sugar and Flatpak together started a few years ago, while I was working at Endless, one of the early-adopters of Flatpak.

Sugar homepage screenshot — The Sugar desktop with a custom background image

It was easy to see that this is a clear win-win situation. Sugar has many unique learning tools that do not exist on the desktop, and Flatpak has the potential to reach new desktop users.

But, how does this project differ from the Sugar applications already available through package managers? Depending on your Linux distribution, you could technically install a small selection of these applications today. But there are two big caveats. First, you will need to install the Sugar desktop or at least some of its system services just so they can run. Second, and most important, you won’t be able to do much with these applications unless you are doing it within Sugar. These applications depend heavily on the Sugar paradigms and APIs, which are quite different from desktops like GNOME or KDE.

As an example, Sugar users don’t need to deal with file system directly, instead they use something called the Journal, which is not available outside Sugar. But they certainly need to deal with the file system in the desktop.

So, to combine both worlds, I created a small library that makes it easier to port these applications to the desktop. It provides the basic building blocks needed for the job, like:

A base desktop application that acts as a middle man between the desktop and the Sugar application.
A set of compatibility UI components that can be used as a replacement for Sugar-specific components.
A set of utilities to generate the metadata needed for a desktop application, basically, the appdata.xml, .desktop and mimetypes.xml files.

With the help of this library, porting applications is surprisingly easy. In most cases, the changes result in small patches that are easily maintainable downstream. Of course, this simple approach has its downsides. As an example, collaboration is disabled since there is no Sugar collaboration service, nor is mimicked by the library.

Once the application is ported, it can be packaged as any other desktop application with Flatpak and published on Flathub. I already ported a few of my favorite applications, two of which are already published on Flathub. My plan is to port as many applications as possible with the help of Google Code-in students this winter.

If you find this project interesting and want to contribute, feel free to contact me!

Last but not least, special thanks to Nick Richards, a former colleague at Endless and Flathub admin, for his early review of this work during the summit, and to Javier Martinez Canillas and his family for hosting me during that week in Barcelona.