Martin Alvarez: So, thank you. thank you for… for being here. This proposal for the breakout session was one idea we had, after the discussions we had in the past in the… specifically in the… in TPAC, the previous TPAC, where we were discussing about the new… way to create, web-based applications, hybrid applications, those that are depending on browser or web engine somehow, like, the mini apps and the super apps that are using, in all the platforms they usually… use, web views, and the new… trend of applications that we are seeing out there, that is light applications created by chatbots or by AI systems to generate the interaction with the user with a small part, a small subset of what we have on the web. So this is the main rationale for proposing this discussion as well to introduce, or to discuss new topics, new potential topics into the mini-apps working group and community group that is in the process of being, re-chartered.

Martin Alvarez: So basically, it will be, the idea is, presenting the, the challenges we have, in the… specifically in the Mini Apps Community Group and the Mini Apps Working Group, in terms of, how we can continue the work ahead, and how we can include perhaps some third-party activities that can fit in this same scenario. So, hybrid applications, light applications, that at the end, it depends on… they depend on… on the web engines.

Martin Alvarez: And at the end, some discussion with you, specifically for the extension of the Mini Apps Working Group, or the rechartering. Wanted to have some feedback from you, and also from the rest of the… groups that are somehow related to this.

Martin Alvarez: First, we already presented the IRC, well, and I gave you the welcome, just reminding that we are operating under the Code of Ethics and Professional Conduct in W3C, and under the antitrust and Competition Guidance, as usual, just for you to know, and you have here the links also. In the agenda, you can find the slides of this. We are following the IRC, lightweight, hyphen apps. Thank you, Xosiev, for scribing. And, yeah, please, feel free to interrupt me, or just, raise the questions after that, after the… this, short presentation.

Martin Alvarez: And I will start by presenting the current challenges and the current activities that led this proposal of the breakout session. So, as you know, we have a working group working on specifications for mini-apps. We have several specifications, some of them very, let's say, solid. We don't have concrete implementations or reference implementations to support these specifications, which is important, but the specifications we have created are more or less solid, some of them. We have specifications for controlling the lifecycle, or monitoring, or specifying the life cycle of the mini-app, something different than the normal web applications, because we can install the mini-apps inside a super app or a framework, adding some super-app context event, communicating with some mini-apps inside the context, and so on. So, it's a bit different. So, basically, new events included here. The distribution of mini-apps. How to compress, how to sign the package, and how to distribute the mini-apps, since most of the mini-apps are distributed using the internal mechanism, so an internal app store that is managed by the super app, or the framework of the mini apps.

Martin Alvarez: Metadata, basically how to define, declare the permissions, the setup, the look and feel of the mini-apps. This is not very, very important, in terms of their challenges, I mean, because it's something that we have solved with the extension of the progressive web application manifest.

Martin Alvarez: So this is something that it's easy to cover, and more or less, it could be… yeah, it's covered. It's almost solid. How to create these mini-apps, how to distribute them, and how to reduce the mini-apps. So, if you want to create a mini-app for one platform, how you can duplicate or create a similar mini-app for another platform, for another super app.

Martin Alvarez: So, we have been discussing how to create the templates, the components, the APIs, the minimum APIs, because so far, there is no way to reuse a mini-app. So you cannot create a mini-app using, like, the HTML we can use and deliver, or represent or render in all the browsers, we cannot do it in the… in different, super apps at the same time. So we cannot code once and deliver in all the super apps. So this is a big challenge. We still have it.

Martin Alvarez: Addressing, so how we do versioning, we create this versioning of the mini-apps, since they are maintained inside the super app. Also, how we create deep linking once the user scans the QR code, how they access the specific part of the mini-app that is related to this QR code, or this URL.

Martin Alvarez: And something that is not very active, but we are starting looking at widgets, so different small mini-apps that can be running on widgets on top of the operating system, like the widget in the home screen of a mobile device, for instance.

Martin Alvarez: And the last topic that is one of the most relevant in the latest conversations in the mini-apps, discussion on how to create the applications more inclusive, because accessibility is still missing in most of the mini-apps. So these are the challenges. Some of them, as you can see here, we already solved it, or we have the possibility to solve it using the existing mechanisms and the existing, discussions we have. In lifecycle, we are extending, for instance, the DOM events, so creating new events for, the installation of the applications, or for accessing a specific part of the specific events in concrete for the mini-apps, but something that is still missing, we don't have a standard DOM, which is very important, right? But, this is something that, we defined the lifecycle with new events for the DOM, but we don't… we are not using the standard DOM, so this is a big topic.

Martin Alvarez: About the distribution, we have a solution based on the common way, so the standard way for most of the mini-app implementations, which is using containers, SIP containers. Plus signatures, signatures for including the, the information about the developer, also signature for the, the marketplace, for instance, to protect the integrity, and also to guarantee this, the security of the distribution. But we have still missing some parts, like the… if we pack one application in a zip container, and we distribute it using a pen drive, for instance, we lose the origin model, right? We have this missing part here, so we need to include something there.

Martin Alvarez: Regarding the metadata, as I told you, we have extended the web app manifest with new attributes. Some of these attributes might solve the previous problems, like the the origin model, or even for adding more information about the permissions, and so on. But more or less, this is something that we can solve using the standard way, extending the web app manifest.

Martin Alvarez: About reusability of the, mini-apps. This is the… main, perhaps the main challenge we have right now, because all of the… or most of the mini-apps, they are creating domain-specific… they are using domain-specific languages, and they have different APIs. Similar, all of them, so they have a very similar way to do it, but all of them different. And what we are, we have still missing is a kind of subset of these, HTML-like, templating models and the APIs, so creating a, perhaps what we have been discussing as well, perhaps a subset of the existing HTML elements plus DOM plus the web APIs could be enough for solving this, this problem of reusability.

Martin Alvarez: Addressing. We have defined a URL schema, this is straightforward. We can enhance it, or we can do something better, but we already have one solution for this.

Martin Alvarez: Regarding accessibility, some of the, or most of the mini-apps, or the super apps, they include role attributes for, including accessibility roles and accessibility meta information, but, this is not enough. This is not enough for… enough for, solving the requirements of accessibility, right? If just adding the possibility to… to include a role attribute, it doesn't guarantee that it's accessible. So, this is one of the main challenges. So, indeed, semantics. The semantics of the elements, the semantics of the components are not there, and this is something that we can solve with the standards. So, it's part of the current discussions.

Martin Alvarez: And regarding the widgets, we reduced the priority of this, and so far we collected some requirements, but we haven't worked on concrete specifications on this. So this is the status.

Martin Alvarez: And we have been, after receiving some comments from the TAG and some other members, we are considering some other activities that can fit in these, challenges and the missing parts we have in these, specifications and requirements, we included in the… at the beginning in the working group of mini-apps. That you can, find some parallel requirements in some other, not only mini-app, but also in some other, type of applications, like, as I told you at the beginning, perhaps related to AI, that can be something similar, and we need a… super app, that would be the environment, it could be the chatbot, it could be the AI framework, and at the end, this framework might create a small application that can run isolated here.

Martin Alvarez: One of the activities we are considering, we are observing, is, for sure, progressive web applications. This is the standard, and why not reusing the standard, right?

Martin Alvarez: Since most of the applications we have in this mini-app ecosystem can be done, can be solved using the web applications, the normal web applications. And there is something new, well, it's not new, it has been several months already, the isolated web apps. A new way to pack and distribute and create isolated context for web applications. And having a look at the things that they offer could solve some of the problems. It's just… high-level reflection, we need to think about this, but this is one of the things that we can consider. In terms of the life cycle. why not using the standard DOM of the progressive applications is there, and why not reducing what is already there? That can also solve some of the problems that we have for accessibility, right? If we take the web access… the web… standards. We will have, by default, all the requirements or all the solutions for accessibility.

Martin Alvarez: In terms of the distribution, isolated web apps, they propose a way to pack the web applications into bundles, signed bundles, and also including content security policy, specifically in the part of the metadata in the manifest, so extending as well the standard manifest.

Martin Alvarez: And about the reusability. So, it's something trivial, right? If we can use the web application or the existing standards, we will have the universality of the web, but applied to super apps. So, this is something straightforward.

Martin Alvarez: URL schema, isolated web apps, they are proposing a specific URL schema. I think it's something that could be compatible as well, and as I told you, if we apply standards, we have accessibility in our super apps and in our platforms. Or it will be easier.

Martin Alvarez: Some other ongoing discussions with some groups. Thank you to some of you that you are… you have participated in these discussions, in the web views, community groups. They are including mini-apps and AI light apps as part of these use cases for hybrid applications, so this is something that we can… Yeah, somehow it's related to these discussions we have in the Mini Apps working group and community group.

Martin Alvarez: Also, interest from WinterTC, since they are creating a minimum common of APIs, web APIs for runtimes, for JavaScript runtimes, and this is something that we have been discussing for the mini-apps, because most of the mini-apps, they don't need the full web capabilities, so they only need a specific subset of these APIs, so they are interested in in, experimenting and see what we can, we can do together. So, we have similar objectives.

Martin Alvarez: Also, we are having a look at the incubation of the… incubations of the progressive web applications, all of them, like, related to the ones related to the installation of, web applications. that as, this is part of the things we need, right? Installing the web applications into concrete, scopes scenarios.

Martin Alvarez: And, something new, that is the AI-generated light applications that perhaps could act something like the mini-app, so creating small mini-apps inside the… specifically created ad hoc for the requirements of the user in each moment. And, yeah, as this example, why not using the existing web? Even… perhaps we don't need the full web, but reusing the existing web can enable this universality of running in all the platforms, right?

Martin Alvarez: Other discussions about, if we need to create lighter engines, still, we are looking for, yeah, more feedback and see what is missing here. Why would… do we need to create these lighter engines, or why is the… the concrete bottleneck of these use cases, and some others, like the connection with the WebNCP technologies, and so on. You see, these are some of the ongoing discussions that we are considering for our activities, and the possibility of including these discussions and these activities in the rechartering or the extension of the Mini Apps working group.

Martin Alvarez: Now we have an extension of the working group, and we don't have clear direction, so this is why this breakout session and the subsequent conversations will be about collecting feedback based on the main objective of the working group, that is having a better convergence with the standards. So, we have the standards, so why not reducing them directly? Also discussing if we need to change something in the scope of the working group, perhaps broadening the scope, as we discussed, and if we broaden the scope, what we should include here.

Martin Alvarez: Important. Should we keep the current specs, even changing the content, but, are they still valid in the activities? And also the fourth point here, should we involve other solutions? Are other solutions interested in, taking part in these standardization activities, like the isolated web applications.

Martin Alvarez: For others, and covering these, these gaps that we have. Interesting, the discussions, this chart in the right-hand side about the Mini App ecosystem and how now they, they are running, so, using. A kind of hybrid web app, so, with a domain specific language, similar to the HTML, but it's not standard. And at the end, these, hybrid, mini-apps, or these hybrid web apps, might run, concrete, or are running right now in super apps, so concrete. So perhaps, with, web views, integrated in them, and, yeah, run in this way. So this is… was one of the solutions we… not the solutions, the alternatives we have been discussing.

Martin Alvarez: If we need native web app engines running directly the web apps, or we need to fit this into AI frameworks, or if we do as we do right now, creating a kind of web compiler that could be the compiler of the super app, or the super framework. And running the mini-apps inside this hybrid model.

Martin Alvarez: So, these are the ongoing discussions, and this is what we want to discuss with you today, and also hearing from you some feedback about the, yeah, if we need to broaden the scope, or we need to include some… some things besides what we have been discussing. And also, getting some feedback from the community.