Beyond the web of today

Kenneth Rohde Christiensen: Good morning and welcome to Web Directions.

I hope you're going to get some two amazing days.

let's get started.

So thanks for introducing me, John.

this is me.

I've been working on the web for many years.

I guess more than 15 years, actually.

I've been working on WebKit, browser implementations Different standards I'm one of the co inventors of progressive web apps.

You might've heard about that.

and today I work at Intel, trying to lead our strategy on the web and actually go and implement all of these things.

so yeah, the first thing you might be wondering is you said, Intel, you're a semiconductor, you do chips.

Why do you care about the web?

the thing is that software.

Everything today, like software, is what's controlling the world today.

And I can make a chip that has an amazing new feature.

If you can't use it as a developer, it's useless.

You're just paying for dead silicon.

So we need to enable everything to run on our hardware, to optimize it, and to make sure that you have.

We have the APIs available to you.

So at Intel, we really value openness, choice, and trust.

Everything should run our system.

So we're heavily involved in standards.

You might recognize Wi Fi, the W3C, that's the World Wide Web Consortium.

That's what's relevant to us today.

bytecode alliance, USB, et cetera.

We also love sustainability.

This is something that's really close to my heart.

we actually.

Last year was number one most sustainable company in the US.

I'm pretty proud of that.

the Intel vision is that the web is an unquestionable key application platform.

We have all those core building blocks that you need to create applications.

while it's also fast, it should be as fast as native apps.

And you should have all the capabilities available to you to create those applications you want to create.

But, that said, we also want to strengthen the unique qualities of the web.

it's really cool that you can type in a URL and it just immediately loads.

You don't have to wait five minutes to download a big app and install it and all of that.

It works across different platforms, so just across a platform thing.

And, most importantly, it's safe.

you can go to many sites and you shouldn't worry.

about like this, like stealing your data on your computer.

So why do we care?

if you're a developer, you probably want to support more than one platform.

that costs money.

So are you going to do an iOS app, an Android app, a Windows app, a Mac app?

You probably don't have the money for that.

And you might also lack people with the skills.

So people have always been looking at these cross platform solutions to this, or hybrid.

What we're seeing today, especially on desktop, is that a lot of people are using web or using like maybe some hybrid solution like Electron.

To get those experiences out there.

So we can say the web is doing really well because it's on the right path.

We have really good building blocks for installability, creating these app like experiences.

We have the progressive web app specs like web manifest.

it's one thing I've worked on, service workers.

We also keep on improving the core.

We better CSS.

We, of course we have like CSS grid now.

A lot of people are excited about that.

A lot of people have always wanted container queries.

That's finally in browsers.

We have Open UI.

There's a group of people, a community group, working together on creating new HTML elements that people really need, like a styleable select element.

They just created a popover that is even implemented in the future, upcoming version of Safari.

So that's also going to be available to everyone.

New APIs, especially around navigation.

That's something I've complained a lot about.

Like, session history has a lot of quirks.

Now, at least in Chromium based browsers as Edge and Chrome, we have Navigation API.

There's the coming View Transition that allows you to create all these nice animations, like you click on a video, it will expand to a different view and expand back.

All of that is being solved on the web, so you can create those amazing experiences.

At Intel, we have a relentless focus on performance, so we need those applications to run fast on our hardware as well.

So we're working on WebAssembly.

We've been adding support of something called SIMD.

I'll talk about what that is later.

It stands for Single Structural Mobile Data.

Worked together with Google, for instance, MediaPipe.

That's their library based on WebAssembly that, that actually like does background blurring in, say like Google Meet, stuff like that.

And, we're bringing native Machine Learning to the web as well.

This is something we're working on.

So what is really exciting for me is that today Intel is building the web and web standards into our hardware roadmaps.

So we always consider this.

And we're innovating on new capabilities as a product called Project Fugu.

We'll also talk about that later.

We want developers to be able to bet on the web.

It's really important for us.

You should be able to create nice, great experiences without having, with ease, without having to rely on big libraries that might not work together with other libraries that has a lot of magic going on.

So if you look at DevTools, you might not understand what's going on.

You can't modify it.

And we want to provide APIs for diverse experiences.

We don't want the web to just be for one specific set of apps.

if, you're Lego and you want to create a web app where you can control a Lego thing, you probably need Bluetooth.

So we need to make sure that you have that API available, otherwise you can't create that sort of apps on the web.

and we want the web to be there for the next industry, revolution.

Something like today we're getting AI.

It's very important.

Because you're investing in the web as a developer.

you want to make sure that you can keep investing in, five years and you don't need to suddenly.

Remove everything and start over and do a native app.

Interop also really matters.

So it's really important that what you built...

work across different browsers, sometimes the feature is not available in a certain browser and you can do feature detection.

That's fine.

But at least behavior should be the same.

So I'm very happy that all major browsers have gone together and worked on this interop project every year.

They choose a certain set of APIs, they believe are the core APIs that developers need today.

They actually ask for feedback from developers and then they go and make sure that they're really well tested and they work the exact same way in all browsers.

It has been a pretty winning strategy.

for Intel, we see that there's 17.

4 million JavaScript developers today.

More than 60 percent of time, on a PC is spent on the web.

And we're seeing enormous growth in progressive web apps.

This is the data from Intel.

We have some stats ourselves.

and it's interesting.

You see the top application on Windows, is actually Chrome.

It's a browser.

Second most popular application is Edge.

That is also a browser.

Then you have Firefox, that's also a browser.

then you have Outlook, that is becoming a progressive web app.

also web.

then you have other browsers like Brave, Vivaldi, etc.

Then you have Excel and Word, they're also becoming progressive web apps.

It's basically all turning into web.

Really good.

But as I said before, we really need diverse APIs, so you can build all these kinds of experiences.

on the web, we've really done that with the last year, we've come up with like seamless copy paste where you can really modify what you're pasting in, what kind of data, frictionless access to local files, very important for desktop, and safe access to, external hardware.

This is part of a project we call Project Fugu.

So Project Fugu was a project that was started by Google and then Intel and Microsoft and...

Later, Samsung and Electron joined to make sure that we have all those APIs available to developers, basically bridging the gap between native and web, making sure that you can rely on the web in the future.

Here are some great examples.

First, Visual Studio Code.

I don't know if you knew it, but you can go to vscode.dev today, and you can even install it as a progressive web app.

And you can start coding.

You can open your local repositories because it's using a new API called the file system access API that we engineered to get us as part of the Project Fugu, even like this is the app.

I always heard people say the one app that is never going to be available on the web is going to be Photoshop because that's impossible.

And here we are, Photoshop is running in the browser.

They made that possible because we had like WebAssembly.

So WebAssembly allowed them to take their old C++ code, get it compiled to somebody that works in the browser.

It was unfortunately too slow, so we worked together with them on bringing multi thread support to WebAssembly, that made a big difference.

Then we worked on this like SIMD, I'll talk about that later, some other specific instruction sets we have in our chips.

And there was actually one case that was 160 times faster, but it averaged three to four times faster, and that made it possible for them to have Photoshop in the browser.

They had another issue, like images are really big, you might have an image that's five gigabyte, that's not fitting in memory, so they needed some kind of swapping cache, so normally you could use the hard drive for that.

So, Google came up with this API called, originally it was called like native IO, then it's turned into become origin private file system.

So it's based on the file system access APIs, very similar.

but it allows a website per origin.

So it's only yours to create a file that you don't see if you go to your file explorer or whatever you have to look at the file system.

You don't see it.

It's hidden.

It's to your site only.

And this, file has like specific APIs that makes it really fast.

This has also allowed people to bring MySQL to the web.

so WebSQL is being deprecated in browsers.

Instead, you can just download MySQL and have it work fast.

Another example, here you have iRobot.

They have this tool for kids, schools, it's called Root.

And basically you can learn to program like in the visual programming style.

and then you can put a pen in the middle, I believe, and you can draw on some paper.

and all of this is controlled by Bluetooth because we have the Web Bluetooth API also as part of Project Fugu.

What is really important, is that this stays safe on the web.

so a lot of people, they have this idea that, native app is great, but it's a fake kind of safety, just because an app is being reviewed by someone doesn't mean that it's safe by, the way that things was designed on native, is that long ago, everything was safe.

You had access to everything.

So you don't know what these apps are doing.

you just trust them, but on the web, you visit many, sites every day, every month.

so it really needs to be safe.

One example, Bluetooth, WebBluetooth.

you don't want a website to be able to see what Bluetooth devices are around you.

Maybe use that for tracking.

so on the web, you don't get access to Bluetooth unless you click on something, then it's able to show you a dialogue.

They can add some filters to what devices to show you.

Those devices in that dialogue, it's not shared with any website.

Only the one you select and connect to.

So we're trying to always to keep this in mind and innovating in safety.

and we're always improving.

So what's the current focus at Intel?

at Intel, we're working on capabilities like bridging the gap as part of Project Fugu, and we're working on performance to make sure that you have near native performance, as we say at Intel, we don't want any silicon left behind and, and we really want to optimize for silicon.

So sometimes performance is actually enabled by new capabilities.

here's some examples, WebAssembly provides really fast CPU execution.

if you have some code that really has to be fast, you could write that in WebAssembly.

it now has support for SIMD and multi threaded support.

WebGL is also something we've worked on, works on almost every device today.

But we've been working on WebGPU and bringing that to web.

That's 3.

7 times faster than WebGL in, in, some of our testing.

That's really amazing.

And we're bringing, Web Neural Network to the web where you can access, it can work on CPU, GPU, and any accelerator that supports, Machine Learning.

So SIMD, the first thing we added to WebAssembly, it stands for Single Instruction Multiple Data.

So you can imagine normally I could add two numbers, it's a scalar.

But actually many, CPUs that support doing this per vector.

And it's really important if, for instance, if you say that you are doing something with an image, every pixel is normally like four numbers.

There's red, green, blue, and alpha.

So now you can maybe multiply these, in one instruction.

That's generally four times faster.

And actually on our hardware we have that, normally it's like the standard, because that's supported globally, on ARM and every other silicon, supports 128 bits, so that's normally four values of 32 bits.

We actually have hardware that supports up to 512.

normal CPUs actually have 256 bits.

So what we are doing now is that we found out, if you, can see that you're using two instructions with 128 bit, why not just use our hardware for 265 bits?

So we did that, detect that manually, like, dynamically.

And that provides you an, 20 to 50, percent speed up.

Just using SIMD.

So one of the examples of what we've been doing, another example we talked about enabling hardware.

Chips today often have, encoders and decoders in the chip.

In the sock.

so you can imagine that to get like good, YouTube, playback time on your phone.

It's, it should use that hardware fit.

So that's great.

That works fine for playback, but if you like a game developer, you don't want to do streaming, or you're creating like Google Meet or Microsoft Teams.

You might want to modify that.

You probably want to set the resolution, the frame rate, and all of that.

And we haven't been able to do that before.

So we've been working together with Google on WebCodec, an API that exposes all of this hardware enabled codecs and encoders to web developers.

And that is being adopted by companies such as Zoom.

To make this really much better on the web and more performant.

Something else that's happened, you've probably heard about this on your, maybe your phone.

You talk, ARM talk about Big Little, or Apple talk about performance cores and efficiency cores.

We have the same, today.

So you, can see the difference here.

Every time we have one of these performance cores, that's the best performance you can get.

You could actually just have maybe four efficiency cores instead.

That's better if you're doing parallelism, it's better for battery, but we need to use that on the web as well.

So one of the things we did is that we just looked, for instance, at different threads inside of Chrome.

some of them are not so important.

So we did it should just be a background task that should be like a resource efficient task, display critical, and the schedule, we'll try to schedule those the right way.

And for instance, with video conferencing, we had like more than 100 milliwatts power savings in Windows just by making this one change.

So another example.

We also just look at Chrome, Chrome is a multi threaded architecture.

You have many processes.

Every tab is its own process.

There's the compositor thread where it's doing all the graphics.

So there's a lot of what's called IPC, Inter Process Communications, going on.

And here we just went and exercised it.

Can maybe, we can reduce that communication to the bare minimum.

And by doing that, we got like, here a 10 percent power saving on, video playback on Windows as well.

And this benefits everyone, there's also benefits for ARM and AMD, so we're doing all these kind of optimizations inside of Chromium.

I mentioned like WebGPU before, so WebGPU is bringing modern graphic and compute to the web.

Intel has been involved basically since the beginning, on the standard and on the implementation and it was recently at Google I/O announced by Sundar, the CEO of Google, that they're now shipping WebGPU in Chrome.

And you'll see there also a shout out to Intel for invaluable support of making this possible.

So this is really, cool.

WebGPU is awesome for graphics.

This is basically like in the old days everyone was doing like something like OpenGL.

that had a lot of state, it managed state.

So a lot of CPU, and that was great when people started to learn how to program like 3d graphics.

it was awesome.

Then people found out it's not always the most efficient, especially if you're doing a game engine, you could probably do it better manually.

So people came up with, Apple came up with Metal.

there's Vulkan, used on Android and other platforms.

There's DirectX, all our modern, graphics libraries.

And, basically, this is what WebGPU is for the web.

It's like a modern, low level API that allows you to do something amazing graphic.

You're probably not going to use it directly.

You're going to use something like Babylon.js or Unity or, 3GS when developing.

And that also provides me like a segue to AI.

Let's talk about AI because WebGPU is modern graphics.

It also allows you to run, compute.

Basically GPUs have this called shaders.

We have a vertex shader But you also have a compute shader.

We can actually do calculations.

That's why a lot of people are using GPUs for Machine Learning because it's great at that.

So cool.

We have this available to the web as well now and actually we're trying to support those existing frameworks.

So Intel is the owner of the WebGPU back end for TensorFlow, for Machine Learning.

So we've been collaborating closely with Google on making this possible.

And here you see, like, how much faster it is.

So this is, this one case here was a bit slower, but in general it's much faster, just moving to WebGPU.

And in one case it's almost two times as fast.

It's more than two times as fast.

So here's one example of what you can do now in the browser without using the cloud.

So we're doing stable, Diffusion here.

It should take around seven seconds, I believe.

So I'm generating a, a sunflower here.

And that's just running in the web browser using WebGPU.

What is interesting about Machine Learning, so I'm focusing on Machine Learning because it's one of the new big thing that is on everyone's mind, is that there's a lot of different kind of hardware.

So in some cases, the CPU is actually the best for inference.

it could be for like...

You just need to get a result really fast.

memory is on the CPU, so you have access to that.

So it might be very fast to get result, but you also see if you, performance, it's never going to be great, and you're spending a lot of power.

In some use cases, that's better.

For some models, this actually works better.

Then you have something like the very best today is like discrete GPU.

You don't have a discrete dispute normally in your phone, it will take too much power, but you see it scales really nicely, get good performance.

What you notice is that it also has a minimum, you need first off to prepare all your data and copy it to the GPU, so it's not good for like a quick result.

It's good for sustainable AI, keep on figuring out what's in the screen, track my eyes, something like that.

It's really great for that.

if you go to an integrated GPU, it normally shares the memory with the CPU.

So it's slightly, it's better, but it doesn't scale as much as a discrete one, because of power envelopes, et cetera.

And then they have the new thing, what's called like a hardware accelerator.

We call it VPU for Versatile Processing Unit.

It used to be Video Processing Unit.

That's why the V, I believe, Microsoft call it an NPU for Neural Processing Unit.

Google calls it a Tensor Processing Unit.

Yeah.

Many names, same thing.

But it would be really cool to get that available to the developers.

You also have to understand that AI can also just be there in a general API.

Like we've been working together with Zoom on, for instance, adding background blurring to the web platform.

So that might use like a VPU in the background and be really fast.

You don't necessarily need to use TensorFlow or anything like that.

So let's look at this new Web Neural Network API that's soon coming to browsers.

actually, I said that these Web APIs are becoming part of our roadmap and this is the first time I've seen an official intro slide that actually shows Web Neural Network.

That's a Web API.

I think that's pretty amazing for our team.

Very proud of the team here.

And, as it says on the slide, our next CPUs coming out this year, actually has a VPU built in.

really great.

we have some good quotes here from, Bilt.

There's one from Microsoft saying we are working on Web Neural Network, can do local inferencing in browser.

We also implement the Web Neural Network standard and working with Intel.

It's coming soon at this point.

So it's like even Microsoft and Intel and others are very excited about this coming to the web.

Here's some stats.

Let's just zoom in.

this is just using CPU.

That's the implementation we have in Chrome today.

We also have an experimental GPU implementation.

There'll be a VPU implementation.

But you see here, if you're using WebAssembly today, you get like one.

It's that's our base.

if you go native, that's 9.

8 times faster than WebAssembly.

So this, if we start adding, SIMD, then you see WebAssembly becomes much faster.

You can, three times speed up.

If you use Web Neural Network, it's basically as fast as native.

So I think that's pretty amazing.

That really shows that how much faster we can get this on the web.

so let's look at this in a, I don't know if the sound is going to work here, but here we have one of my colleagues, Benham Jiang, who did this demo.

He's trying to show you that they're doing background blurring using a model.

using, I believe it's WebGL.

Let's see what, I think it's SIMD and then with the Web Neural Network, and then he's doing background, segmentation as well.

And you'll see the speed up.

Let's see if, if it's going to play with sound.

Hello, you will see the inference time and frames per second data showing the indicators.

Furthermore, on the right side, I collected the performance data for every two seconds, display a total of 11 groups.

And calculate the medium value of them.

Let me click the web backend button.

The inference time and the frames per second is faster, and the performance comparison result is based on the medium value above.

As you can see, the web is about 2.5 times faster than WebAssembly.

Now, I will showcase the background replacement performance with DeepLab model.

It is a relatively bigger model than CLP Segmentation, and I will compare the WebAssembly performance with WebNN.

Let me go to the full screen and click the Background Replacement button, and change the background at first.

It's running on CLP Segmentation now.

Let me click the DeepLab button.

By using the WebAssembly backend, you can see the inference time is more than 130 million seconds, and the frames per second is about 7 in the indicators.

Let me switch to the WebNN backend.

The performance is much faster now.

The inference time is less than 40 million seconds, and the frames per second is more than 30.

It's about 4 times faster than WebAssembly.

So you, really see that this can really make a difference for web developers, especially because it's going to democratize AI, like you can get it on any website, you don't have to install an app and you can start to use this for any kind of use case you find with AI, right on the client.

so why are we bringing this to the web?

we want to enable those new, exciting use cases for web developers.

and of course we want to take advantage of our hardware, right?

So there's different options today for using machine learning.

You can use WebAssembly that runs on the CPU, great for some use cases.

You can use WebGPU that is running on GPU only.

With the new Web Neural Network API.

It's, it'll run on whatever hardware you have available and it will allow you to choose.

so here's like an understanding of how it works.

below you have like hardware, so there's like chips, like a SOC often called.

It contains maybe a GPU, a CPU and a BPU then you have like native APIs, like on Windows, you'll be DirectML.

or you can use like an API like Intel's OpenVino.

then you have browsers and on top of that, you get those low level APIs, but as a developer, you're probably gonna use something like TensorFlow.js or MediaPipe web for Google for, or.

OpenCV.

js, or you're going to use like high level APIs, like I said, just turn on noise suppression, background segmentation, etc as we're bringing those to the web.

So WebNN is a low level API, just like WebGPU, it's not supposed, you're not supposed to use that directly unless you're a framework developer, but provides really native like performance and reliability of results.

if you know anything about Machine Learning, you can see this is like how it looks, very low level, if you don't know about it, you can ignore it.

This would be like how you would code it, but as I said, you're probably going to use a framework instead.

our current focus at Intel is also bringing working on capabilities to creating these amazing experiences.

one of the things I've been working on is telemetry.

how could we provide some of the telemetry we have on our chips to web developers?

we actually had a lot of requests for this, for instance, Zoom wanted, for instance, saying Oh, it's really bad on, some hardware.

people are in a meeting, someone's taking minute notes, and they type.

And nothing happens.

And then they see 500 letters on the, keyboard, on the screen.

and we really want to avoid that.

So maybe it would be good to know that it's the system is being stressed and maybe we should just turn off the video feeds or lower the resolution or whatever we can do.

So we've been working on, bringing that to the web.

like example here, like you can turn off noise suppression, you could adjust the resolution, feeds, et cetera.

The API, because everything on the web can be abused, we want to make it privacy preserving and secure.

So we came up with some high level, like pressure states, like the system is on a nominal pressure, it's on a fair pressure, now it's getting serious.

So you see there's some, explanation here of what that would mean, and critical now is really, bad.

Very simple API, try to make sure that it works in workers and iframes, because that's what people want.

Maybe you want to have your Zoom or Meet SDK built in, maybe on a website as a.

like a hotline, integration with permissions.

we were building this on the Observer pattern.

It's very popular on the web today.

I have one example and let me see if I can actually show that here.

And if that's actually going to work.

The idea here is quite simple, it's a website, you turn it on, it will show like a nice emoji of how the system is doing, if it's not turned on, it will just be sleeping, and then I have this Mandelbrot, I'm, just doing that, and running Mandelbrot in as many workers as possible, so you can stress the system by, adding workers and you'll see the guy is, here, he's under critical pressure.

It's just a very nice example where we just, we're announcing an audio trial, so that's in the next version of Chrome, I believe 115.

That's audio trial.

You can sign up and start using this API, try it out, on your websites.

Pretty cool.

There's an article here on developer.chrome.com.

If you want to check that out, we're also working on improvement for streaming.

So I said a bit about AI before.

You've probably noticed that during COVID, like a lot of people started working from home.

we saw like a, it's like Google meet had a 30 times increase in daily usage from January, 2020.

so it's really, important.

That also means it's very important to us.

Because people use that on their machines.

So we've been looking at and talking to developers, what kind of APIs do you need for, meetings?

And they said, native background blurring, that's fast and efficient.

face detection, face framing, noise suppression, uh, web codecs, we already talked about.

So here's some example of what we've been working on.

So here's one of my coworkers, showing that we have this, background blurring, natively supported in browsers.

So this is a prototype.

I actually believe there's an [indistinct] as well in Chrome today.

so it's one of the examples.

we played around with the APIs, tried to make it really simple.

So this is using WebRTC.

So you see, basically it's just you just add a capability.

I don't know if we ended up with exactly this API.

There's some, playing around to find out what is the best API for users.

Do they really want to configure the amount?

Maybe they want just two states.

Maybe just want background blurring.

Here's some examples of the, is it actually faster and better?

And yes, it is.

MediaPipe, that's what Google was using.

For Meet, you see that's using, here with GPU, so probably using WebGL.

that takes a lot more power, than not using the feature.

And with our prototype, you see it's...

A little bit more power, and this is not even the final prototype.

This is just, I don't know how to implement that.

That's not even using our VPU yet, so that would be more efficient even.

Face detection, something we worked on at Intel for a long time.

We played around with OpenCV some years ago, many years ago, It's 8 megabytes with WebAssembly.

It's a bit too big for regular users to adopt it.

Google, they did something very similar with the MediaPipe.

It's two megabytes.

It's also big, but it's maybe manageable.

we worked on shape detection, which apparently is, actually something, an experimental feature on the latest version of iOS.

So you can apparently play around with that.

So that's pretty cool.

so that, but that works on still images.

So it's really good for say like detecting a barcode, a QR code.

so now we're working on doing this as part of WebRTC instead.

And of course we have an example here, so another one of my co workers, and you'll see it's just, it's detecting where his face is, and it even works with more than one person, so let's see, someone else is joining, and it should be tracking two people.

Perfect.

But the same thing as like here, we also do, we're playing around with the API shape.

Always want feedback from developers like yourself.

here we're just looking at bounding box, but in reality we will, we probably want something as a contour as well.

So you can do like funny hats.

It's very nice where the eyes, where it was the nose and you can do funny things.

So yeah, early prototype, same thing as before, much more efficient.

people today will be using something like MediaPipe.

wow, it takes a lot of power.

You're losing many hours of your battery.

but with this new implementation, it's not so bad.

Maybe it's just 20 percent more.

we've also worked on APIs some years ago, with my co worker, Rijo, showing that some cameras actually support native zoom and pan and tilt.

so you can do that manually on the web.

You could run a Machine Learning algorithm and do that yourself.

But why not just bring that also as a high level API, just follow my face, follow me around.

so we also have a prototype of that working.

and, we've been looking at something like, eye gaze correction.

It's not the best picture, it's a bit difficult to see, but a lot of people, they have the camera up here.

And you're looking at the screen to your friends and it looks like everyone's looking down.

so actually using Machine Learning and slightly modifying the eyes, it looks, it's maybe a bit like Uncanny Valley, so let's see if we do this or not.

But it's like, those are the things we're toying around with.

and of course like we also brought some years ago, we brought all these like knobs to, to, to the web, like with media captures, you can actually change the color temperature brightness manually.

But why not just do that?

As well, let's just do it like a high level API, correct lighting.

Perfect.

Before we're ending off, I just want to show you one last thing we've been working on.

So this is my coworker, Alexis Minard.

he's working on stylus support because it's also one of those use cases for the web.

This is super exciting.

And there's actually a standard Intel is involved with called Universal Stylus Initiative.

that allow people to buy stylus from different companies.

They can use it at the same time.

And in this, small video, it's going to show you.

That you can actually configure and store in every stylus, like the size of the pen, the color, and you can just, oh, this is my red pen, this is my blue pen, and there's even some of these pens that you can use for detecting colors in the real world and have that, work.

So let's check it out and see if sound is working.

[computer audio] Hi everyone, my name is Alexis Minard and I'm a software engineer at Intel.

Today I'm going to showcase the, use cases that we can enable with the Pen Customization API that we're proposing in the W3C.

So let me take this laptop and then switch it to a kind of a tablet and then, and then showcase the API.

I have with me the styluses.

They are compatible with the, USI, standouts.

So USI stands for Universal Stylus Initiative.

it's a, pen to touchscreen protocol.

that works across brands and, touch controllers, right?

the benefit of this, Universal Studies initiative is that the, pens, they don't need any pairing whatsoever.

And this pen from HP works, but I can take this pen from another brand and it works.

And then the last one is from Lenovo, and same thing, it does work, right?

so that's very convenient, you can take your pen and then use them on different hardware of different brands, and you don't have to worry of buying a pen for a given computer, right?

The other thing that the, Universal Stylus, Initiative pens have is a little memory inside them, where you can store preferences or customization, for example, your preferred inking color, your preferred inking style or your preferred inking width, right.

So, in this web application, we made a little panel that only shows up if the paint customization API is supported, and then if you click on it, you can see what's inside the stack, right?

In this case, there was a red color that was stored with a 21 pixel width and then a pencil style, right?

let's say I can draw and then I like my setup and then I want to store, for example, let's say the black color into the pen, right?

And I can just store it and then automatically it gets stored into the memory of the stylus, right?

As you can see, if I pick another pen, then, we can see a different set of, preferences, right?

And then if I take the last pen, for example, here, you can see here a different set of colors, right?

and, attributes.

as it is right now, it's not super useful.

Now, imagine a scenario where you set up your pen the way you like, with maybe a different tip, and then, you want to be able to quickly switch them like if you were doing in the real life, right?

that's, in this application, we actually developed a little setting here, which is I'm saying that anytime a pen comes close to the screen, then we will automatically fetch the preferred customization and then set them into the editor automatically, right?

So here in your case, so like you can see up, it's drawing with the right preferences, which was black, 21, and pencil, right?

Now, let's say I take this other pen here, and then it will draw with another color, right?

And same thing with the last one, which was yellow, if you remember.

it's very convenient.

I can, switch pen very quickly and then do things, right?

as a designer, it's very cool.

so that's one of the use cases.

The other use case that we enable is, for example, on this pen.

This pen has a little color sensor, on the end of it.

It's on the other end of its tip, right?

it basically, it's a kind of a color picker, but in the real life, right?

for example, you brings it close to a color like here, and then you can scan the color with it by just clicking on the button, right?

And then when we bring it here, automatically we read the color.

You can see it was picked up right here, right?

Which is quite convenient, right?

So now let's say and then I can draw with it, right?

You can see it's a different color.

Now, let's say I scan that blue color So I can scan it and then if I bring it here you can see it picks it up, right?

So and then I can you know draw with it, right?

And then let's do one more time with the red or the green color Sorry And then you can bring it here, you can see it picks it up, right?

So it's very convenient, if you have an actual color palette here, you can read to it and then store it and then bring it to your computer, right?

so yeah, that's basically the kind of two main use cases that we enable with the new API and I hope you enjoyed the video and feel free to give me feedback and I'm looking forward to talking to you.

Thank you.

Yeah.

So that was my last example of, to show that we work on all kinds of different APIs, it's not always just like CPU or hardware, sometimes we're actually working on a new experiences as well.

even like foldable displays, we worked on a spec for that.

so with that said, like Intel, we are working to empower the web and future experiences.

And I hope you enjoyed this conference.

And I will stick around both days, so come talk to me if you want to learn more.

And with that said, I have now kicked off this conference.

Take care.

Thanks for listening.