Proposed content

[molant]

The following is a work in progress of the proposed content. Please feel free to provide feedback.

Intro

Why do many developers need to build with cross-platform in mind?
Many factors to consider, not all the technologies are the same, some are more suited for some scenarios than others.
Hope to help them better understand the strengths and weaknesses of each one so you can be more productive and successful.

Types of cross-platform technologies

Not all cross-platform technologies are the same. Go a bit into details as well into each one of the following categories.

Web and PWA

Chromium, WebKit, and Gecko

WebView based

Cordova, Ionic, Tauri, WebView2, CEF...

Browser engine bundled

Electron, NW.js...

JavaScript runtime + OS controls (could probably use a better name)

React Native, NodeGUI (although this projects to Qt)...

Compiled (could probably use a better name)

Xamarin, Flutter, Qt...

Technology

Each technology (Electron, Tauri, Ionic, etc.) should have its entry point with the following subsections:

Overview

• Cross-platform support: Desktop, mobile, OS versions, etc.
• Release cadence and model: How often is there a new version? Is it predictable? Does it use an evergreen model (i.e.: it gets updated automatically) or do developers need to take care of that?
• Governance:
  • Open Source Licensing: Permissive (MIT / Apache-2), Restrictive (GPL-3, BSD), etc.
  • Governance model (e.g.: Corporate owned or community, consensus, benevolent dictator, etc.)
  • Bus Factor / Staleness

Developer experience

What does the developer need to install in order to get started?
How long does it take to set up the environment (with a video of the process)? Is there an active community to get help?
Additionally we should highlight what developers love most about the technology (e.g.: Hot reload)

Architecture overview

The different moving pieces (e.g.: main process and renderer process), links to more in depth reading (e.g.: How Browsers Work, although there’s probably something newer)

Technology comparison

Side by side technology comparison of different dimensions.

Disk and network I/O

I/O is one of the biggest bottlenecks. We need a series of common benchmarks that measure the speed and even push the limits of what is a reasonable I/O interaction (i.e.: read/write tens of thousands of files simultaneously). We should check for

• Read/write from a disk
• Read/write from a URL (local and remote)

Performance

A collection of algorithms to calculate raw performance (like calculating prime numbers) although it would be good to have less synthetic measures.
I wonder if we should have something around 3D here although the library/framework used could have a great impact.

Integration with other technologies, processes, multi-threading, etc.

• Can developers create threads in their app? Are there any limitations?
• What are the out of the box solutions to communicate different processes (maybe threads as well?)? How performant is the IPC layer?
• Can parts of the applications be written in another language (to increase performance or other reason)?
• What are the 3P alternatives for IPC (packages, custom made, etc.)?

Memory consumption

There is a lot of talk about memory consumption. The reality is that “Hello world” apps are not representative. There are frameworks that are barebones and require developers to add many dependencies, others bring everything you need and more. The reality is that the moment you need to load web content it increases significantly.
It will be good to compare SxS different technologies loading a somehow similar solution and compare them. This can be easily done for the web based ones or the ones that can load web content (e.g. RN using the webview control). For others it might be more complicated.
We will have to decide on a "reference app" that implements certain common scenarios that is more complex than a TODO app.

Disk footprint

Does the framework need to be bundled always? Can it be installed system or user wide? How does the space consumption change if there are multiple apps using the same technology?

Scenarios

Common scenarios that developers need to implement in their applications and how they are achieved with each technology (if possible).

UI

• How easy is it to adapt to different window sizes and form factors?
• Compositing of different UI technologies (e.g.: web and OS provided)
• Multi window support (and cross window communication)

Bundling, distributing and updating the app

What are the different strategies for all of the above for the different technologies?

Notifications

How do developers implement notifications in their applications?

Offline

• Does the technology enable offline support? How complicated is it?

Access to hardware capabilities

• How much access does the technology have to custom hardware and OS features?
• How complicated is it to add capabilities that are not supported Out Of the Box?