Thank you so much for joining.
So we'll take a look at you know latest news on the OpenXR side of things also going to give you some updates about what we do on collaboration with Manado again and some other very cool things happening in the open source world.
So let me check if I can use this.
It should work. Yes. Very quick on this. My name is Fred. So I have two hats. I'm out reach.
My main affiliation is with Calabra where I'm very happy to lead the XR domain.
So reading a team very talented, open XR engineers, XR engineers. You know that, you know Calabra of course for those of you who are really, really young here. We're consultants.
Mostly using open source. We're doing that. So we're using open source to leverage to for our customers in many across industry. So XR, but also graphics core. We have multimedia.
We have also AI. I'm at machine learning. My second hat is Outreach Officer for OpenXR at Kronos, where I spread the good news and you know about OpenXR API, try to reach out to other industries explain the benefits of the standard and so on.
I just discussed Calabra here is a slide for it. If you don't know us come to see me after this show.
As I said, mostly leveraging open source solutions for our customers. Usually in the Fortune 500 sector, I'm slice, but it's not always a case rate. I've been working with startups as well.
And so yeah, I'm going to be talking a bit more about that. Before I move on to the next slide.
Inado, Calabra has been within the OpenXR working group for a long time now. We had Manado, one of the first two OpenXR 1.0 compliant run times in 2019.
And ever since we've been working in Manado, we are also the OpenXR, the CTS riders. I'm on Kronos. So if you guys have an XR OEM, some hardware that you want to have OpenXR compliance, this is the test that you have to pass and then we submit the results and stuff. And we are writing those tests.
There's also the OpenXR spec editor in our ranks, Riley Pavlik. It's been doing an amazing job. So you see we're pretty much really involved in this really nice open standard.
For today, I'm going to be discussing some OpenXR news. Do I hear me well? We're discussing that first. We're also going to be taking a look at the difference between the runtime and client clients.
Sorry, you'll see that there's a bit of education there. And we'll close that call that talk with some overview of the OpenXR, the XR ecosystem and see that how it's possible to do everything open source.
For the OpenXR news, you'll probably see we have on the Kronos side released some extensions lately. We have blog posts on that, but mostly we went to the scene understanding.
And so you have all of those spatial entities related extensions that came out. If you are already an XR developer, interested in OpenXR, take a look at that. We have the spatial anchors that's a new concept that's being used and everything that you see there.
You know, apart from being able to detect 3D and 3D markers in space, you of course can out with those extensions detect planes and surfaces. And there's also a semantic layer that detect if we're talking about a table, if it's a ceiling, if it's a wall. So pretty cool stuff that you might want to take a look at.
Of course, if you're on the other side of the story, XR OEMs, if you have hardware, then it's also important to know where the OpenXR standard is at the moment.
And then you might want to contact me after the show. We've also been working on this.
The multi-app aspect is unreleased right now. So most of that is still under NDA and I cannot, unfortunately, I cannot disclose as much as I would like.
But we've been working on this very extensively for maybe more than a year. And as you might expect, so we're division right for those extensions that I will come out.
Soon is really what you think about. So we want to have multiple apps, be able to interact spatially with each other.
Think of a game with some desktop tools, calendars floating around, stuff like that, minimally. But also we would like the rendering to be coherent, right?
So cross-lightings between those apps, occlusions, and so pretty, pretty intense work. We are working on standardizing all that.
So stay tuned. This is something that's really important for OpenXR developers, so pay attention. So we at Cronus are always trying to make it easier for developers.
Not only standardizing, but explaining and showing the way. And so we've worked on this recently, and this is already out.
We released that a few months ago, it's called the best practice validation layers. Now as you might know on the Vulcan site, for example, validation layers, it's really like a thing really common.
Usually catching the invalid user, just right for the API. But this guy here is not about catching the valid user, but maybe suboptimal users, right?
And so it's a normal validation layer in intercept the calls, but we'll tell you with warnings that you might not have, you're maybe a duplicated this or that.
There's like five or six very basic checks right now, that lets you maybe spot that your application is going to perform, maybe suboptimally, or you're going to be running into some cross device incompatibilities.
But mostly, it's really there to help you guys get better code. Now, we're going to be building on this, and also welcoming the community to join and contribute.
So if you get your hands on those layers and think that we're missing some tests, it's going to be our pleasure to welcome your feedback and try to integrate.
In the same, in the same, you know, desire to help the community, we've also worked on the tutorial, we call it tutorial, open exotic tutorials. You can see the link at the bottom, here, what is the, yeah, okay.
So most links, so this is going to be, by the way, it's going to be available, the recordings as well, so you can also always revert to it. The tutorial projects, pretty simple, it tells it all. So it's like a step by step, you get a folder is the by steps application, starting with a really, really basic number one application creating session, creating devices, and then it builds on top, adding more complexity.
And so it's a really nice way for you guys to learn how to, you know, develop an canonical opening application and start from there, and you can find it on our GitHub.
I recommend that you check it out. Now, this was, this was mostly the news about what we've worked on recently. Here's a very important distinction that I want to make.
This is something else that we added recently because there's been some misunderstanding in the community lately, maybe last year, we had some communication that we had, we had some reframing to do with the community about stuff and here it is.
So what happened is that, you know, when you pick an engine as a developer, you pick the OpenXR plugin, you know, you depends your application on a lot of tools, and then you interface with this or that OpenXR runtime, right, that is compliant.
Well, it's, it's kind of normal for you to, to expect that if you picked an engine and you use an OpenXR plugin, you should expect that it just, your application is going to be working across all the OpenXR devices, right, it's not quite the case.
Why is that? Because of the ecosystem, right, let's just, let's just take a quick look at that about the XI ecosystem. So you have the applications on top that do not talk to the OpenXR runtime, usually directly right.
Here's the OpenXR API and the runtime's down there. Most of the time, you guys are going to be interfacing and using your game engine, right, you need to keep on real good though, or some other means, right.
There's actually very few applications that interface with OpenXR directly.
And so when that happens, and so I just want to, just have no many clutches here, and this, this layer is what we call it, you need a middleware, it's probably what you know already, and we're talking about the platform layer. Now, what happens is that OpenXR, the OpenXR compliance guarantee, right, when you, when you present an OpenXR runtime to grown us, you pass a CTS, you guess, OpenXR compliance you,
but the benefits like the API framework, this only pertains that layer rate, the platform, the runtime code, and the associated on associated devices.
Now, game engines, game engine plugins, this is all outside compliance territory, and this is where the problem came from, right, the misunderstanding came from.
It's not because you are picking an, an OpenXR plugin on certain, uncertain, runtime, that your game is going to be running,
right, out of the box everywhere, right, you might be locking yourself into some vendor specific extensions, or, or flags on injuries, for example,
and then you're just realized, and behind happy that you're a game, your APK, whatever, there's not wrong and data to hardware, so it's really important for you guys to know this, and so, as additional help, we've,
we've also enhanced our OpenXR extension reports, right, initially, we were communicating, what are the OpenXR extensions that the runtime support,
and then you might recognize this guy here, it's called the runtime support matrix, we've had this on our OpenXR inventory for years, later ready.
But we figured there was like a missing gap, right, what about those engines that you're using, what about, and so we, so we called the client support matrix, but we're going to change that name to middleware, middleware support matrix, right, which encompasses any, you know,
engine or XR toolkit that you might be using, and so in this first version of what we released, it's, this, this space is life, you'll find, you'll find good though, unity, unreal, but also lover,
it's you saw the very good, you saw the very good presentation from my colleague, Chris stuff about Manado and other tools, so you found lover and steering kit in there.
And so if you have, if you're working on an engine, then implement, not implemented, but use the OpenXR API, if you have a toolkit, a library in the XR space, and you like that piece of software through peer here, you can contact me
or anyone at corners and we'll take a look at that. We're usually basing our decision on, you know, is there, you know, how much of the OpenXR API is covered by your software, but also is there, like a community or maintaining your software and those, like a kind of a general portrait.
I'm not sure I have time for everything in my presentation, so we'll skip that one. Pretty quickly with just to give you a sense of, you know, how, how possible it is to go XR in the open source world.
Well, I will just tell a very quickly about Manado here that you, I'm, I'm recommending you to go back to, again, to the talk from my colleague, Chris stuff, but just to give you a sense of Manado for XR headset or platform makers is really a pretty good deal, a pretty big deal.
Because Manado is like a construction, it's like a construction kit for a runtime. You can use what we call the state trackers, right, to enable the OpenXR API.
You can also use any of the, in a very modular way, any of the internal components, exact composers that we have, we have SLAM algorithms or even a driver, it's called the Mercury for hand tracking detection.
So it's pretty easy to pick, you know, didn't get your hands on Manado and use or use any of the components start playing right thought, right?
And we have a very active community, we're welcoming you to join our Discord and try to open up your first MRI.
Just know that we have a relatively important release recently, where among other things we had EXT future implemented, it's really important for what's coming next.
All of the scene understanding within ProNUS is a good part is going to be based on async operations, which is implemented and unlocked by the XR EXT future extension.
And so this is part of what we release pretty recently.
I'm skipping some text as I said that my time is really, I still have a few minutes.
Good though, we cannot, we cannot go and talk about open source XR, of course, and not talk about good though.
Good though is you're working on 4.exversions right now.
It is a pretty complete 2D, 3D, and XR engine, you shouldn't really take it out.
Very cool thing to happen with good though is that they were lucky enough last year to win a contract with ProNUS for implementing a lot of XR feature.
And we call that project the good, any right, open XR integration project.
It's complete now, there's maybe going to be a follow up piece of work, you could check it out.
There's a lot of new, you know, random models got integrated, you have spatial entities that got integrated for the most part.
And there's a lot of improvements, you know, a cross platform and a consistency.
Now good though for XR is really becoming a thing, and we do have the next slide about this.
So we got Calagra, we're lucky enough to do a project called so Marna, not so long ago, based on good though.
And it just worked like a bliss.
The next very important piece of software, and by the way, who's maintainer, we welcome very recently in the coronavirus group as an individual member is lover.
It's a lover, basically in just a few lines of code, right, but it's based on the Lua language.
You can basically create an XR experience such as a few lines of code.
You're going to get a lot out of it, like right out of the box, but recent releases added, fixed phovier, so phovier rendering using quad views.
And you'll see there's also extended support for more interaction profiles.
The cool thing to say in terms of news about the lover is that you might know that cloud XR is having some very cool announcement these days from Nvidia.
They also just released that they're going to, you know, ship a plugin for cloud XR that runs on lovers.
So this is a pretty, pretty cool news.
We also mentioned the circuit, which is sort of a very cool almost engine like XR toolkit or XR library or framework.
And here, again, you can create very cool things, which is few lines of code.
Mostly for CC sharp, you're going to be finding C and C++ headers.
Cool here is that the rendering is pretty nice, PBR rendering. I also skined animation.
You should really check it out. You can import your own objects and start playing with it.
Importantly enough here, you're going to have a very easy to implement and interact with UI.
And so at Calabra, when we have, when we have, you know, projects or we're going to have like a demo projects, it's not.
I mean, it's not rare that we're going to circuit just to have something working and set up quickly. Pretty cool.
That's about it for the news, even on the XR pipeline of things. So if, and so, again, with my two hats, if you're working on cool hardware, if you are interested in open XR, you might want to reach Calabra, if you want help.
Or if you want a job, reach out to me. I'm always very keen to meet people from your community.
If you have experience in XR, open XR, if you've hacked that monado, I might be really interested in knowing you or talk about your skill set.
And so you can reach us here. You'll see, we also have a landing page pretty easy to find us.
And now in the chrono side, if you're already working as an open XR developer and are wondering about anything, if you want to contribute.
If you are using open XR and discover a bug, of course, get hubs and we would be more than happy to welcome your PIs.
And so, here's part of some ways that you can reach us.
And I think this is about it, and I'd be really glad to take questions. Thanks.
All right, we have some questions.
Hello, thank you for your presentation. I have two questions. The first one is, you talk about the middle way of support metrics.
So the question is, can you explain a little bit the process to the way you feel this support metrics?
And does user can check if a specific middle way is compliant with several extensions?
We still hear me. All right, thank you for that question. Yes, I forgot.
So for the, for what we call the runtime support metrics, where you initially had there, this is managed by pronouns because the members were all members, right?
And so we're verifying that it's represented over the reality. Now for the middle way support metrics, this is self-reported, right?
Since this is outside open excite compliance territory, it's just, you know, on good faith that we're taking those guys.
And then we're asking once in a while, hey, could you update your report matrix?
But you have to know that this is all self-reported. No one is actually checking the variety right now of those reports.
It's, it's all in the faith, right? It's, we're assuming it being a responsibility of the maintainer that that that reports.
And what was your second question, sorry?
So, yes, so unless you have, unless you have the device that's been tested on it, there's no easy way to check.
The question was, can you use a quickly check compliance for this and that path, you know?
Unless you have the device on which the, you know, compliance was recorded, it's a bit hard for now. We don't have this.
But I would be really glad to have a message from you, like, hey, pronouns, that would be nice.
And then I would probably add it to my list of things to do.
Thank you.