ConFoo 2026 in Review

A short article talking about my experience applying to speak at ConFoo, attending the conference, and being given an opportunity to speak after all.

ConFoo is one of Canada’s biggest developer conferences drawing in over 100 speakers from around the world. The speakers converge in Montreal to share their knowledge by giving close to 200 talks over the course of three days.

Gare Centrale (Central Station) next to the conference hotel in Montreal

Every year I submit proposals to speak at ConFoo and I’ve been fortunate because I've been selected 5 times over the past 6 years. I don’t take being selected for granted because there are so many talented speakers vying for a spot. This year there were 964 talks proposed which appears to be a new record.

Unfortunately, I wasn’t selected to give a talk this year but an opportunity arose allowing me to go as an attendee. To save money, I decided to drive up which gave me the opportunity to visit with my dad for a couple days before the conference. My dad lives in Toronto which is about five and a half hours from Montreal. That’s not bad considering I live in Moncton. A trip to see him from Moncton is usually between a 15 and 17-hour drive depending on traffic and if you stop for a break.

In the lead-up to the conference, I was digging into Slack so I decided to turn some of that information into a talk just in case another talk is needed. At the very least, I figured I could present it to a local developer user group.

The conference kicked off on Wednesday, February 25th and the number of attendees this year seemed higher. After Covid, people were a reluctant to start attending in-person conferences again so it’s nice to see ConFoo bouncing back.

This was my first time being at ConFoo as an attendee and that made it a bit different. I was still able to reconnect with some speakers that I hadn’t seen since last year but it was less stressful because I didn’t have my next talk in the back of my mind.

As it would turn out, word came on day 2 of the conference that one of the speakers couldn’t make it because he just became a dad. The organizer asked the speakers if someone would like to replace him so I spoke to the organizer to see if he’d want me to give the replacement talk and he gave me the ok.

I spent the evening rehearsing in my hotel room and then, on Friday, I gave my Slack talk. In return for giving the talk, I received one of this year’s fancy speaker badges as shown in the following image:

As always, it was a really good conference! I learned a lot and got to meet some new people.

I’ve already started work on talk ideas for ConFoo 2027 which will be the 25th anniversary of the conference. If you have the opportunity to attend, I highly recommend it. Not just because of the high-quality talks but also because of the networking opportunities with attendees and speakers.

The State of WebAssembly - 2025 and 2026

The State of WebAssembly – 2025 and 2026. For the sixth year in a row, I've had the privilege of writing an article on the state of WebAssembly. In this article, I start off by reviewing the WebAssembly developments during 2025 and then I try to predict what I think will happen in 2026.

For the sixth year in a row, I've had the privilege of writing an article on the state of WebAssembly (Wasm).

In this article, I start off by reviewing the WebAssembly developments during 2025. Things like Safari rounding out browser support for Exception Handling with exnref and JavaScript String Builtins, the progression of Wasm features including the recently announced WebAssembly 3.0 specification milestone, and what's happening outside the browser in areas like debugging and WASI.

The second part of the article gives some insights into what's possible for 2026.

As we saw with WebAssembly 3.0 being announced, developer tooling improvements, Wasm support from most of the top 25 programming languages, and adoption in a wide variety of areas, WebAssembly has matured to the point where it's not longer an experiment. It's ready for production.

The article can be found here: The State of WebAssembly - 2025 and 2026

Presenting at ConFoo 2025

With 191 presentations chosen out of 895 proposals, being accepted to speak at ConFoo is not something I take for granted. This year, my first talk was "Local-First Web Development With the Help of WebAssembly" where I walked the attendees through how SQLite and PGLite compare and work in the browser. My second demo extended the PGLite database to showcase ElectricSQL's approach to synchronizing your data with a server in a local-first architecture. My second talk, "Using WebAssembly in a Web Component as a Polyfill", explored using WebAssembly as a polyfill to extend a feature that might not be in all browsers yet. I showed the attendees how to compile the libjxl library to WebAssembly and I used the module in a web component to decode and render a JPEG XL image.

With 191 presentations chosen out of 895 proposals, being accepted to speak at ConFoo is not something I take for granted. I invest a lot of time into getting the code ready for the demos, preparing slides, and practicing to ensure each talk goes as smoothly as possible while providing the latest cutting-edge information to attendees.

This year, my first talk was "Local-First Web Development With the Help of WebAssembly" where I first walked the attendees through how SQLite and PGLite compare and work in the browser. These products enable web developers to interact with their data in a familiar way by being able to run SQL statements against the database. My second demo extended the PGLite database to showcase ElectricSQL's approach to synchronizing your data with a server in a local-first architecture.

My second talk, "Using WebAssembly in a Web Component as a Polyfill", explored using WebAssembly as a polyfill to extend a feature that might not be in all browsers yet. For this talk, I showed the audience how to go about compiling a library to WebAssembly, in this case libjxl, and then making use of the module in a web component to decode and render a JPEG XL image.

Because my second talk was before lunch on the second day of the conference, no more practicing was needed so I was able to take it easy for the rest of the conference. That evening, I decided to do some sightseeing. Not knowing Montreal very well, I did a quick online search and found that some people recommended checking out the Saint-Laurent area so I jumped on the subway and then did some exploring.

The following are some of the pictures I took that evening. The left image is from inside the Lionel-Groulx Metro station, the middle image is the Place des Arts building when looking at it from the Saint-Laurent Metro station, and the right image is from my walk down Saint-Catherine Street near the Place des Arts building.

In 2022, I met a couple guys at ConFoo who were from Fredericton, a city that’s close to where I live. We stayed in contact and would joke about how we had to go all the way to Montreal to meet fellow developers from near us.

This year, the guy who used to lead the developer user group in my city posted on Facebook that he was at the Montreal Canadiens game. I gave his post a like and thought it was neat that he was in Montreal at the same time as me. Much to my surprise, the next morning when I was grabbing breakfast at ConFoo, I heard my name! It turns out that he was in town for ConFoo and we got to hang out a bit.

At the end of each conference, there's a time for lighting talks by anyone who would like to present. If you're ever at ConFoo, I recommend it. This year, one of the volunteers gave a presentation talking about Postgres and he kept flipping to a slide promoting an upcoming conference... in Montreal... in May. It was quite humorous and I was glad he was able to join the group of us later that evening for supper. The conference he was talking about is PGConf if you're interested.

I mentioned to my friends that speaking, especially at ConFoo, is a high. Weeks of work go into preparing and practicing my talks. Then, as the time draws near to give the talk, the nerves hit. Thankfully, the internet stays up, the demos work, and all the practicing pays off as the talk goes well. As soon as the first talk is over, the mind shifts to the next talk I need to give and I practice more to ensure I'm as ready as possible for the next one. In between the stress and nerves leading up to the talk, and then the relief that the talk went well, there's the networking and meeting of friends from previous years and the making of new friends. It's a rollercoaster of emotions but, as soon as it's over, I can't wait to do it all over again.

Speaking of wanting to do it all over again, if you have a conference and want someone to speak about WebAssembly, something WebAssembly related, or building a Slack bot, I'm your guy. If you'd like to reach out, you can find me on LinkedIn: linkedin.com/in/gerard-gallant

If there's interest, I'd also like to put together a pre-conference workshop related to WebAssembly at ConFoo next year. If you'd be interested in attending and, if there's anything in particular that you'd like to learn, please fill out the following form: https://forms.gle/GSkU923A1k8fdYCG8

The State of WebAssembly - 2024 and 2025

The State of WebAssembly – 2024 and 2025. For the fifth year in a row, I've had the privilege of writing an article on the state of WebAssembly. In this article, I start off by reviewing the WebAssembly developments during 2024 like Safari rounding out browser support for a number of features including Garbage Collection, newly available features like JavaScript String Builtins and Memory64, WASI 0.2 (formerly called Preview 2) being released, Uno Platform performance improvements, Hyperlight being open-sourced, and even a NIST report on how wasm can help improve security. Then I try to predict where I think things will go in 2025.

For the fifth year in a row, I've had the privilege of writing an article on the state of WebAssembly.

In this article, I start off by reviewing the WebAssembly developments during 2024 like Safari rounding out browser support for a number of features including Garbage Collection, newly available features like JavaScript String Builtins and Memory64, WASI 0.2 (formerly called Preview 2) being released, Uno Platform performance improvements, Hyperlight being open-sourced, and even a NIST report on how wasm can help improve security. Then I try to predict where I think things will go in 2025.

Every year we see many WebAssembly-related improvements and 2024 was no exception. It's easy to get caught up waiting on the next amazing feature but the reality is that wasm and WASI are already very capable as we can see from the increased adoption.

The article can be found here: The State of WebAssembly - 2024 and 2025

7 Tips for Achieving Your Goals

January is typically seen by a lot of people as a chance for a new beginning. It’s unfortunate that a lot of people fail to achieve their resolutions and quickly fall back into their old habits. Of those who achieve their goals, are there things they do that can help the rest of us out?

January is often seen as a chance for a new beginning. It’s a new year so we hit the gym hoping to get that beach body we’ve always wanted. Perhaps we decide to take some courses to advance our career. Maybe the resolution is living a healthier lifestyle or dropping something that we see as a bad habit.

As I started writing this article, I remembered a goal I set for myself a few years ago where I wanted to take part in the Paris Marathon. I posted the goal on my office wall with a picture of the Arc de triomphe de l’Étoile in Paris and I was doing a lot of running to get ready for it. Unfortunately, I lost focus and stopped practicing.

The Arc de triomphe de l’Étoile in Paris

Whatever the goal, it’s unfortunate that a lot of people fail to achieve their resolutions and quickly fall back into their old habits.

Of those who achieve their goals, are there things they do that can help the rest of us out?

In the following article, I present you with 7 tips to help you realize your goals.

The State of WebAssembly: 2023-2024

The State of WebAssembly – 2023 and 2024. For the fourth year in a row, I've had the privilege of writing an article on the state of WebAssembly. In this article, I start off by reviewing the WebAssembly developments during 2023 around Garbage Collection, Tail Calls, fixed-width SIMD, multiple memories, improvements in .NET, and work happening with the WebAssembly System Interface (WASI) and the Component Model. Then I try to predict where I think things will go in 2024.

For the fourth year in a row, I've had the privilege of writing an article on the state of WebAssembly.

In this article, I start off by reviewing the WebAssembly developments during 2023 around Garbage Collection, Tail Calls, fixed-width SIMD, multiple memories, improvements in .NET, and work happening with the WebAssembly System Interface (WASI) and the Component Model. Then I try to predict where I think things will go in 2024.

A lot happened last year and 2024 is already shaping up to be an exciting year! It feels like WebAssembly's use is about to take off both as normal WebAssembly modules and as WebAssembly components with WASI.

The article can be found here: The State of WebAssembly: 2023-2024

Dovico Timesheet: Year in Review and Plans for 2024

As the current calendar year draws to a close and a new one is about to begin, this is often a good time to take a moment to reflect on the past and plan for the future. With that in mind, we wrote an article to review what happened with Dovico Timesheet over the past year as well as our plans for 2024.

As the current calendar year draws to a close and a new one is about to begin, this is often a good time to take a moment to reflect on the past and plan for the future.

With that in mind, we wrote the following article to review what happened with Dovico Timesheet over the past year as well as our plans for 2024: Dovico Timesheet: Year in Review and Plans for 2024

Dovico Timesheet - Quick Assign

We're pleased to announce that a new Quick Assign view has been created for Dovico Timesheet that allows you to assign or unassign employees across projects quickly!

We're pleased to announce that a new Quick Assign view has been created for Dovico Timesheet that allows you to assign or unassign employees across projects quickly!

The new Quick Assign view is made possible thanks to a feature we released earlier this year, where tasks can now remain linked to a task template.

The following article walks you through how the new view works: Dovico Timesheet Quick Assign

Dovico Timesheet - Allowing tasks to be kept linked to a task template

We just released a feature for Dovico Timesheet where a task can be kept linked to a task template. This new feature allows you to easily adjust the properties of the task template and have those changes applied to all tasks that are linked to it.

Today, I'm pleased to announce that the company that I work for, Dovico Software, just released a feature for our Dovico Timesheet product allowing tasks to be kept linked to a task template.

Because a project can have multiple tasks created from the same task template, it can be time consuming, tedious, and error prone to manually make adjustments to each task especially if you need to make adjustments across projects.

This new feature allows you to easily adjust the properties of the task template itself and have those changes applied to all tasks that are linked to it.

For more information on how this feature works, the following article gives a detailed overview: The ability to have a task linked to a task template

Safari 16.4 and WebAssembly Fixed-Width SIMD from C#

This week, Safari 16.4 was released and with it came support for WebAssembly's fixed-width SIMD feature! With this update, all modern browsers now support this feature.

As shown in the following image, WebAssembly fixed-width SIMD allows code to take advantage of hardware instructions on the device to speed up certain computations by running them in parallel.

A visual representation comparing data being processed
one element at a time with normal arithmetic (Single
Instruction, Single Data) versus four at a time, in
this case, with SIMD

The Uno Platform allows you to write an application that works on multiple systems including in the browser thanks to WebAssembly. The Uno Platform uses .NET and the ability to target WebAssembly fixed-width SIMD was added in .NET 7.0.

I wrote the following article that walks you through creating an Uno Platform application and how to work with vectors to leverage SIMD. The article also explains how to compile your application ahead-of-time (AOT) with SIMD support: https://platform.uno/blog/safari-16-4-support-for-webassembly-fixed-width-simd-how-to-use-it-with-c/

Leveraging WebAssembly fixed-width SIMD in Blazor WebAssembly

Because the Uno Platform is using .NET, with a few slight modifications the same code can also be used in Blazor WebAssembly as well.

With both platforms, to take advantage of WebAssembly's fixed-width SIMD support, you need to AOT compile the application but there are a couple differences between how it's done with the Uno Platform versus Blazor.

For Blazor, you'll need to edit your project file and include the following tags in a PropertyGroup tag:

• <RunAOTCompilation>true</RunAOTCompilation>
• <WasmEnableSIMD>true</WasmEnableSIMD>

With the Uno Platform, simply adding Uno's version of the previous tags is enough to trigger the AOT process depending on if your build configuration matches that of the PropertyGroup you added them to (Release mode for example). However, with Blazor, AOT is only triggered when you publish the project.

Also with Blazor, the AOT option on the Publish dialog is on and you can't uncheck it. With Uno you need to make sure you don't check it by accident because doing so will cause an error to be thrown that can only be fixed by deleting a tag from the publish profile file.

A Blazor WebAssembly version of the code can be found here: https://github.com/cggallant/blog_post_code/tree/master/2023-March-BlazorSIMD

Demos

If you'd like to see it in action, the following links are demos built form the code in the article. Note that because these are AOT compiled, they are bigger so they may take a few seconds to download and display especially if you're on an older device or on a slower network.

• Uno Platform: https://sda-bytes.com/uno-wasm-simd/index.html
• Blazor WebAssembly: https://sda-bytes.com/blazor-wasm-simd/

ConFoo 2023 in Review

My experience at ConFoo 2023

On Tuesday, February 21st, I started my journey to Montreal to speak at the ConFoo developer conference for my third time.

Usually, when I travel to the big cities, I try to use public transportation to get to and from the airport. The city I live in isn't very big but I decided to give our transportation system a try anyway.

Unfortunately, for me to get to the airport using this approach, I needed to take two city buses and then a coach bus. It's doable but it takes time and the coach bus only goes to the airport twice a day so the timing didn't allow me to use this approach when I returned.

One highlight of my trip to the airport, however, was a pheasant that graced me with his presence.

The conference was held at the Hotel Bonaventure where we were greeted by over 700 attendees and over 150 sessions in 3 days! Being in Montreal, it was fitting that some of the sessions were also available in French.

The past two times that I spoke at this conference, I only spoke for one session each time. This year, I gave two presentations.

My first presentation was given on the second day of the conference. For this session, I talked about how we're using Docker at Dovico to prototype views, try out different UI frameworks, and help speed up the development of Timesheet.

(source: https://www.flickr.com/photos/confoo/52734935208)

The second presentation that I gave was on the final day of the conference. This time, I walked the audience though creating a Slack bot from start to finish by building a simple hot desk booking system!

(source: https://www.flickr.com/photos/confoo/52733940852)

My slides, notes, and links to the code from my talks can be found in the following GitHub repository: https://github.com/cggallant/confoo-2023

As my new friend, Andres Pineda, so correctly articulated in one of his sessions, there's more to a developer conference than just taking in the talks. There's also a networking component to these conferences. When I saw him at the opening party for the speakers, I recognized him but couldn't figure out where from. Later I realized that I had seen him talk online as part of UnoConf and he's one of the contributors to the open-source Uno Platform. We have something in common because I've been privileged to work with Uno and write them several articles for their blog. We were able to connect during the conference.

Speaking of the Uno Platform, while I was in Montreal, I had the opportunity to meet Matthew Mattei in person for lunch. I work with him when writing articles for their blog. I wasn't expecting it but I do appreciate that the Uno Platform sent me home with some swag:

Over the course of the conference, I was fortunate to meet some great people and to take in a number of really good sessions. My only regret is not being able to take in all of the sessions because there are usually 8 other sessions happening at the same time as the session that you're in.

On Saturday, February 25th, I made the journey from the hotel back to the Montreal airport. I thought this was a neat idea as I was walking through the airport to my gate:

It was a great conference and I already miss it. I hope to be able to attend next year's conference and I recommend ConFoo to everyone.

A huge shout out to Yann Larrivée for putting on another amazing event!


As a side note, if you happen to be putting on a developer conference, or know of one that's looking for speakers, let me know because I'd like to speak more. I've started setting up a Sessionize profile but you can also reach me on Twitter or on LinkedIn.

The State of WebAssembly - 2022 and 2023

The State of WebAssembly – 2022 and 2023. For the third year in a row, I've had the privilege of writing an article on the state of WebAssembly. In this article, I started by revisiting developments during 2022 to see if any of my predictions came true and if there were any surprises. Then I tried to predict where I think things will go in 2023.

For the third year in a row, I've had the privilege of writing an article on the state of WebAssembly. In this article, I started by revisiting developments during 2022 to see if any of my predictions came true and if there were any surprises. Then I tried to predict where I think things will go in 2023.

2022 didn't really feel like it had a lot of movement as far as features being released go. However, it did feel like there were a lot of things coming into place for what's to come. I think 2023 is going to be really exciting for WebAssembly and even for JavaScript.

The article can be found here: The State of WebAssembly - 2022 and 2023

The State of WebAssembly - 2021 and 2022

The State of WebAssembly – 2021 and 2022. In this article, I show you the current state of WebAssembly by looking at the big events of 2021 and then try to predict where I think things are going in 2022.

As one year comes to an end and a new one begins, it serves as a good opportunity to take a moment and reflect on what happened over the past year and, at the same time, try to predict what may happen in the new year.

For the second year in a row, I've had the privilege of writing an article on the state of WebAssembly. In the article, I talk about some of the big events of 2021 around WebAssembly and then I tell you what some of my expectations for 2022 are.

The article can be found here: The State of WebAssembly - 2021 and 2022

Uno Platform WebAssembly applications and Azure Static Web Apps

This week, the Azure Static Web Apps service came out of preview. I was honored with the opportunity to create an article that shows you how to create an Azure Static Web App and link it to a GitHub repository containing an Uno Platform WebAssembly application.

This week there was an announcement that the Azure Static Web Apps service came out of preview.

As the name implies, Azure Static Web Apps give you a way to host static web apps and it comes with many features including global distribution of your content and free SSL certificates to name a couple.

Static web apps are applications where all the work happens in the browser and the app is decoupled from server-side code. Because an Uno Platform WebAssembly application is all client-side, it's a static web app and can take advantage of the Azure Static Web Apps service.

I was honored with the opportunity to create an article that expands on some documentation that the Uno Platform already had on Azure Static Web Apps. In the article, I walk you through creating a GitHub repository, creating an Azure Static Web App, and then linking the two together. Then you create an Uno Platform WebAssembly application, check it into your repository, and see the Azure Static Web App automatically detect the change and deploy your new code.

The article can be found here: "Hosting Uno Platform WebAssembly apps on Azure Static Web Apps"

From ConFoo to deploying web applications with Docker

The story of how discovering Docker helped me create the demos for my ConFoo 2021 presentation about the WebAssembly System Interface (WASI). Then the continued learning about Windows containers resulting in my latest Uno Platform article about Deploying C# web applications with Docker.

In 2020, ConFoo opened a call for papers for their February 2021 conference. I submitted several proposals and was pleased to find out in January 2021 that one of them had been accepted.

The talk was going to be about the WebAssembly System Interface (WASI). I knew what I wanted to talk about but I wanted a couple demos that were more real-world than the typical 'hello world' style. I had an idea for the applications I wanted to write but, to write them, I needed to compile some C libraries. Unfortunately, I was having some difficulties getting things set up on Windows.

My first thought for a workaround was to set up a Linux virtual machine but I was curious if there was another way. One thought that crossed my mind was, can Docker help here?

Docker

I had seen Docker demonstrated at a couple user group events but I hadn't used it myself so I needed to get up to speed quickly. Thankfully, I found the following YouTube video that not only explained the Docker theory but also walked through several examples that I was able to follow along with: https://www.youtube.com/watch?v=3c-iBn73dDE

After watching the video, I started looking though the images on Docker Hub and discovered that there's a Docker image for the Emscripten SDK. This is useful to me for a couple of reasons:

 
• I prefer to have Emscripten use the versions of the tools it installed rather than a different version on my machine just in case the changes impact things when compiling a module. Being in a container, all the tools Emscripten needs are in the container with it allowing me to adjust the tools on my machine as needed.
• I often switch between versions of Emscripten to test different things. Having an image for each version I need makes things a lot easier. Sometimes I've had to uninstall a version of Emscripten before being able to install the next one. Now, I just need to pull and run the image with the version I need.

In the end, I created a Docker image derived from an Emscripten image and was able to build the demos I wanted for my ConFoo talk.

A few days before the ConFoo conference started, I was talking with the Uno Platform team about Docker. I thought Docker might be useful for C# developers for one-click deployment because I saw on Docker Hub that there was an image with IIS (Internet Information Services).

An article about Docker

After the conference was over, I started looking into Docker from a C# perspective. Unfortunately, every time I tried to build a Windows Docker image, I'd get errors. I spent a number of evenings reading about Windows containers and trying different things but kept spinning my wheels.

I learned a lot about Windows containers in the process but I felt a little dumb when I ran across an article that explained my problem. It turns out that you can't create Linux and Windows containers at the same time. You need to switch Docker Desktop to use one or the other and I was trying to create a Windows container while configured for Linux.

Today, I'm pleased to announce that my latest article "Deploying C# Web Applications with Docker" has been published on the Uno Platform's blog. The article walks you through building an image with IIS and .NET Core, publishing it to a private registry, pulling the image, and running the container.

The State of WebAssembly - 2020 and 2021

The State of WebAssembly – 2020 and 2021. In this article, I show you the current state of WebAssembly by looking at the big events of 2020 and then try to predict where I think things are going in 2021.

With the start of a new year, it's common to reflect on what happened over the past year and plan for the upcoming year.

In this article, I'll give you a quick overview of what WebAssembly and WASI are. Then I'll look at the state of WebAssembly in 2020 and tell you where I see things going this year.

The article can be found here: The State of WebAssembly - 2020 and 2021

WebAssembly threads arriving on Android devices

WebAssembly threads arrive on Android devices! Chrome for Android (version 88) was released with the SharedArrayBuffer enabled which means you can now use WebAssembly threads on your Android phones and tablets!

This week, Chrome for Android (version 88) was released and will become available on Google Play over the next few weeks. With this release, the SharedArrayBuffer has been re-enabled which means you'll be able to use WebAssembly threads on your Android phones and tablets!

To enable the SharedArrayBuffer, you need to specify the Cross-Origin-Opener-Policy (COOP) and Cross-Origin-Embedder-Policy (COEP) response headers. Because of the COEP response header, if you include resources from another domain that you trust, you'll need to include the crossorigin attribute with those links.

In July, I wrote an article that walks you through returning the response headers, using the crossorigin attribute, and using WebAssembly threads to convert a user-supplied image to greyscale. You can find my article here: https://cggallant.blogspot.com/2020/07/webassembly-threads-in-firefox.html

Although the article talks about Firefox because it was the first browser to require the new response headers, the content of the article applies to Chrome for Android too.

The response headers will be needed for use with Chrome desktop in the near future (version 91). Safari will require them as well so it's a good idea to update your server response headers with these values if you currently use, or plan to use, the SharedArrayBuffer.

ConFoo Online 2021

I am very pleased to announce that I'll be speaking at ConFoo Online 2021! To flow with the conference theme, I titled my talk "Joining forces to free WebAssembly from the browser".

I am very pleased to announce that I'll be speaking at ConFoo Online 2021!

As a fan of Star Wars, the organizer decided that this year's conference theme will be "a new hope" because of COVID-19 and the feeling that the world needs hope that things will improve. To flow with this theme, I titled my talk "Joining forces to free WebAssembly from the browser".

In this talk you'll learn about the WebAssembly System Interface proposal (WASI) that defines a standard for using WebAssembly outside the browser in a secure way. You'll see several examples including interacting with a WebAssembly module from your C# code and at the command line.

The conference will be virtual this year and will take place from February 22nd to 26th. You can find the full list of sessions here: https://confoo.ca/en/yul2021/sessions

Hope to see you there.