Learn the fundamentals of Web Assembly in 100 Seconds, then build your first WASM binary with AssemblyScript. https://fireship.io

- WASM Docs https://developer.mozilla.org/en-US/docs/WebAssembly
- Figma's Story https://www.figma.com/blog/webassembly-cut-figmas-load-time-by-3x/
- AssemblyScript https://www.assemblyscript.org/


#webdev #wasm #100SecondsOfCode

Install the quiz app 🤓

iOS https://itunes.apple.com/us/app/fireship/id1462592372?mt=8
Android https://play.google.com/store/apps/details?id=io.fireship.quizapp

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

My VS Code Theme

- Atom One Dark 
- vscode-icons
- Fira Code Font
2024-02-04T06:03:49.337Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
69c2fadd-e7e3-4b09-885f-87b5b9576c52
f29b6f3194062a06333919a6caf7eed8c20c47a2afc1dbeae603f7eea9b18b31
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
WebAssembly.
Write applications for the web in languages other than JavaScript.
Imagine a world where you could build software with c plus plus Rust, Python, Go, or even COBOL, then deliver that software to the end user in a web browser without any installation and near native performance.
That world became a reality in December 2019, when WebAssembly became an official w three c standard.
It includes a low level language similar to Assembly that can be represented with text, then convert it to a binary format that runs on all modern browsers.
However, you won't actually write this code directly, but rather use it as a compilation target for programs written in other languages.
For example, you might build a game with Unity and c sharp, and compile it to WebAssembly where it can be delivered in the browser.
Now, it's important to note that it's not intended to replace JavaScript.
In fact, the 2 work well together side by side.
Figma, for example, uses React JS for its outer UI.
Then on the inside, you have a high performance c plus plus design tool that feels just as fast as native software.
As a developer, there are many different ways you can build a WebAssembly app with many more under development.
One of the most popular tools is Emscripten, which can convert a c or c plus plus program to WebAssembly, as it did by bringing AutoCAD to the web, which is a 30 year old code base.
No way.
One of the best ways to get started is with AssemblyScript, which is a language that looks like TypeScript, but compiles to WebAssembly.
We can easily start a new AssemblyScript Project using Node JS and NPM, then we'll write our first WebAssembly module in the index TS file.
Unlike JavaScript, a dynamic interpreted language, WebAssembly is a static compiled language, with strict type guarantees.
For example, our code can't use the any type.
When it comes to numbers, we need to specify a 32 bit integer or a 64 bit floating point.
In addition, we can't use dynamic objects.
Instead, we use maps where we can strongly type the key value pairs.
Once we're happy with our code, we can then compile it down to a binary, which is a file that ends in dotwasm.
We can now run this binary in the browser, open an HTML page, and then use the WebAssembly API to instantiate streaming.
Simply fetch the binary, and when the promise resolves, do something with it.
This has been WebAssembly in 100 seconds.
If you wanna see a more in-depth video on this topic, please let me know in the comments, and make sure to subscribe and hit the like button.
Thanks for watching, and I will see you in the next one.

Speaker 0: WebAssembly. Write applications for the web in languages other than JavaScript. Imagine a world where you could build software with c plus plus Rust, Python, Go, or even COBOL, then deliver that software to the end user in a web browser without any installation and near native performance. That world became a reality in December 2019, when WebAssembly became an official w three c standard. It includes a low level language similar to Assembly that can be represented with text, then convert it to a binary format that runs on all modern browsers.

However, you won't actually write this code directly, but rather use it as a compilation target for programs written in other languages. For example, you might build a game with Unity and c sharp, and compile it to WebAssembly where it can be delivered in the browser. Now, it's important to note that it's not intended to replace JavaScript. In fact, the 2 work well together side by side. Figma, for example, uses React JS for its outer UI.

Then on the inside, you have a high performance c plus plus design tool that feels just as fast as native software. As a developer, there are many different ways you can build a WebAssembly app with many more under development. One of the most popular tools is Emscripten, which can convert a c or c plus plus program to WebAssembly, as it did by bringing AutoCAD to the web, which is a 30 year old code base. No way. One of the best ways to get started is with AssemblyScript, which is a language that looks like TypeScript, but compiles to WebAssembly.

We can easily start a new AssemblyScript Project using Node JS and NPM, then we'll write our first WebAssembly module in the index TS file. Unlike JavaScript, a dynamic interpreted language, WebAssembly is a static compiled language, with strict type guarantees. For example, our code can't use the any type. When it comes to numbers, we need to specify a 32 bit integer or a 64 bit floating point. In addition, we can't use dynamic objects.

Instead, we use maps where we can strongly type the key value pairs. Once we're happy with our code, we can then compile it down to a binary, which is a file that ends in dotwasm. We can now run this binary in the browser, open an HTML page, and then use the WebAssembly API to instantiate streaming. Simply fetch the binary, and when the promise resolves, do something with it. This has been WebAssembly in 100 seconds.

If you wanna see a more in-depth video on this topic, please let me know in the comments, and make sure to subscribe and hit the like button. Thanks for watching, and I will see you in the next one.
WebAssembly. Write applications for the web in languages other than JavaScript. Imagine a world where you could build software with c plus plus Rust, Python, Go, or even COBOL, then deliver that software to the end user in a web browser without any installation and near native performance. That world became a reality in December 2019, when WebAssembly became an official w three c standard. It includes a low level language similar to Assembly that can be represented with text, then convert it to a binary format that runs on all modern browsers. However, you won't actually write this code directly, but rather use it as a compilation target for programs written in other languages. For example, you might build a game with Unity and c sharp, and compile it to WebAssembly where it can be delivered in the browser. Now, it's important to note that it's not intended to replace JavaScript.
programming
software development
software
computer science
In fact, the 2 work well together side by side. Figma, for example, uses React JS for its outer UI.
Then on the inside, you have a high performance c plus plus design tool that feels just as fast as native software. As a developer, there are many different ways you can build a WebAssembly app with many more under development. One of the most popular tools is Emscripten, which can convert a c or c plus plus program to WebAssembly, as it did by bringing AutoCAD to the web, which is a 30 year old code base. No way. One of the best ways to get started is with AssemblyScript, which is a language that looks like TypeScript, but compiles to WebAssembly. We can easily start a new AssemblyScript Project using Node JS and NPM, then we'll write our first WebAssembly module in the index TS file. Unlike JavaScript, a dynamic interpreted language, WebAssembly is a static compiled language, with strict type guarantees. For example, our code can't use the any type.
software development
software
programming
When it comes to numbers, we need to specify a 32 bit integer or a 64 bit floating point. In addition, we can't use dynamic objects.
Instead, we use maps where we can strongly type the key value pairs. Once we're happy with our code, we can then compile it down to a binary, which is a file that ends in dotwasm. We can now run this binary in the browser, open an HTML page, and then use the WebAssembly API to instantiate streaming. Simply fetch the binary, and when the promise resolves, do something with it. This has been WebAssembly in 100 seconds. If you wanna see a more in-depth video on this topic, please let me know in the comments, and make sure to subscribe and hit the like button. Thanks for watching, and I will see you in the next one.
streaming
programming
youtube
social media
video gaming
multimedia
WebAssembly. Write applications for the web in languages other than JavaScript. Imagine a world where you could build software with c plus plus Rust, Python, Go, or even COBOL, then deliver that software to the end user in a web browser without any installation and near native performance. That world became a reality in December 2019, when WebAssembly became an official w three c standard. It includes a low level language similar to Assembly that can be represented with text, then convert it to a binary format that runs on all modern browsers. However, you won't actually write this code directly, but rather use it as a compilation target for programs written in other languages. For example, you might build a game with Unity and c sharp, and compile it to WebAssembly where it can be delivered in the browser. Now, it's important to note that it's not intended to replace JavaScript. In fact, the 2 work well together side by side. Figma, for example, uses React JS for its outer UI. Then on the inside, you have a high performance c plus plus design tool that feels just as fast as native software. As a developer, there are many different ways you can build a WebAssembly app with many more under development. One of the most popular tools is Emscripten, which can convert a c or c plus plus program to WebAssembly, as it did by bringing AutoCAD to the web, which is a 30 year old code base. No way. One of the best ways to get started is with AssemblyScript, which is a language that looks like TypeScript, but compiles to WebAssembly. We can easily start a new AssemblyScript Project using Node JS and NPM, then we'll write our first WebAssembly module in the index TS file. Unlike JavaScript, a dynamic interpreted language, WebAssembly is a static compiled language, with strict type guarantees. For example, our code can't use the any type. When it comes to numbers, we need to specify a 32 bit integer or a 64 bit floating point. In addition, we can't use dynamic objects. Instead, we use maps where we can strongly type the key value pairs. Once we're happy with our code, we can then compile it down to a binary, which is a file that ends in dotwasm. We can now run this binary in the browser, open an HTML page, and then use the WebAssembly API to instantiate streaming. Simply fetch the binary, and when the promise resolves, do something with it. This has been WebAssembly in 100 seconds. If you wanna see a more in-depth video on this topic, please let me know in the comments, and make sure to subscribe and hit the like button. Thanks for watching, and I will see you in the next one.
WebAssembly.
webassembly
Write
write
applications
applications
for
for
the
the
web
web
in
in
languages
languages
other
other
than
than
JavaScript.
javascript
Imagine
imagine
a
a
world
world
where
where
you
you
could
could
build
build
software
software
with
with
c
c
plus
plus
plus
plus
Rust,
rust
Python,
python
Go,
go
or
or
even
even
COBOL,
cobol
then
then
deliver
deliver
that
that
software
software
to
to
the
the
end
end
user
user
in
in
a
a
web
web
browser
browser
without
without
any
any
installation
installation
and
and
near
near
native
native
performance.
performance
That
that
world
world
became
became
a
a
reality
reality
in
in
December
december
2019,
2019
when
when
WebAssembly
webassembly
became
became
an
an
official
official
w
w
three
three
c
c
standard.
standard
It
it
includes
includes
a
a
low
low
level
level
language
language
similar
similar
to
to
Assembly
assembly
that
that
can
can
be
be
represented
represented
with
with
text,
text
then
then
convert
convert
it
it
to
to
a
a
binary
binary
format
format
that
that
runs
runs
on
on
all
all
modern
modern
browsers.
browsers
However,
however
you
you
won't
won't
actually
actually
write
write
this
this
code
code
directly,
directly
but
but
rather
rather
use
use
it
it
as
as
a
a
compilation
compilation
target
target
for
for
programs
programs
written
written
in
in
other
other
languages.
languages
For
for
example,
example
you
you
might
might
build
build
a
a
game
game
with
with
Unity
unity
and
and
c
c
sharp,
sharp
and
and
compile
compile
it
it
to
to
WebAssembly
webassembly
where
where
it
it
can
can
be
be
delivered
delivered
in
in
the
the
browser.
browser
Now,
now
it's
it's
important
important
to
to
note
note
that
that
it's
it's
not
not
intended
intended
to
to
replace
replace
JavaScript.
javascript
In
in
fact,
fact
the
the
2
2
work
work
well
well
together
together
side
side
by
by
side.
side
Figma,
figma
for
for
example,
example
uses
uses
React
react
JS
js
for
for
its
its
outer
outer
UI.
ui
Then
then
on
on
the
the
inside,
inside
you
you
have
have
a
a
high
high
performance
performance
c
c
plus
plus
plus
plus
design
design
tool
tool
that
that
feels
feels
just
just
as
as
fast
fast
as
as
native
native
software.
software
As
as
a
a
developer,
developer
there
there
are
are
many
many
different
different
ways
ways
you
you
can
can
build
build
a
a
WebAssembly
webassembly
app
app
with
with
many
many
more
more
under
under
development.
development
One
one
of
of
the
the
most
most
popular
popular
tools
tools
is
is
Emscripten,
emscripten
which
which
can
can
convert
convert
a
a
c
c
or
or
c
c
plus
plus
plus
plus
program
program
to
to
WebAssembly,
webassembly
as
as
it
it
did
did
by
by
bringing
bringing
AutoCAD
autocad
to
to
the
the
web,
web
which
which
is
is
a
a
30
30
year
year
old
old
code
code
base.
base
No
no
way.
way
One
one
of
of
the
the
best
best
ways
ways
to
to
get
get
started
started
is
is
with
with
AssemblyScript,
assemblyscript
which
which
is
is
a
a
language
language
that
that
looks
looks
like
like
TypeScript,
typescript
but
but
compiles
compiles
to
to
WebAssembly.
webassembly
We
we
can
can
easily
easily
start
start
a
a
new
new
AssemblyScript
assemblyscript
Project
project
using
using
Node
node
JS
js
and
and
NPM,
npm
then
then
we'll
we'll
write
write
our
our
first
first
WebAssembly
webassembly
module
module
in
in
the
the
index
index
TS
ts
file.
file
Unlike
unlike
JavaScript,
javascript
a
a
dynamic
dynamic
interpreted
interpreted
language,
language
WebAssembly
webassembly
is
is
a
a
static
static
compiled
compiled
language,
language
with
with
strict
strict
type
type
guarantees.
guarantees
For
for
example,
example
our
our
code
code
can't
can't
use
use
the
the
any
any
type.
type
When
when
it
it
comes
comes
to
to
numbers,
numbers
we
we
need
need
to
to
specify
specify
a
a
32
32
bit
bit
integer
integer
or
or
a
a
64
64
bit
bit
floating
floating
point.
point
In
in
addition,
addition
we
we
can't
can't
use
use
dynamic
dynamic
objects.
objects
Instead,
instead
we
we
use
use
maps
maps
where
where
we
we
can
can
strongly
strongly
type
type
the
the
key
key
value
value
pairs.
pairs
Once
once
we're
we're
happy
happy
with
with
our
our
code,
code
we
we
can
can
then
then
compile
compile
it
it
down
down
to
to
a
a
binary,
binary
which
which
is
is
a
a
file
file
that
that
ends
ends
in
in
dotwasm.
dotwasm
We
we
can
can
now
now
run
run
this
this
binary
binary
in
in
the
the
browser,
browser
open
open
an
an
HTML
html
page,
page
and
and
then
then
use
use
the
the
WebAssembly
webassembly
API
api
to
to
instantiate
instantiate
streaming.
streaming
Simply
simply
fetch
fetch
the
the
binary,
binary
and
and
when
when
the
the
promise
promise
resolves,
resolves
do
do
something
something
with
with
it.
it
This
this
has
has
been
been
WebAssembly
webassembly
in
in
100
100
seconds.
seconds
If
if
you
you
wanna
wanna
see
see
a
a
more
more
in-depth
in-depth
video
video
on
on
this
this
topic,
topic
please
please
let
let
me
me
know
know
in
in
the
the
comments,
comments
and
and
make
make
sure
sure
to
to
subscribe
subscribe
and
and
hit
hit
the
the
like
like
button.
button
Thanks
thanks
for
for
watching,
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
The speaker discusses the benefits of Web reminded for building web applications with multiple languages and recommends using AssemblyScript for dynamic interpreted code. They also suggest building a Web reminded app using advised builds and Emscripten for dynamic objects. The speaker emphasizes the importance of setting a 32 bit integer or 64 bit floating point for dynamic objects and recommends Emscripten for dynamic interpreted code.
Web Assembly (WASM) in 100 Seconds
WebAssembly. Write applications for the web in languages other than JavaScript. Imagine a world where you could build software with c plus plus Rust, Python, Go, or even COBOL, then deliver that software to the end user in a web browser without any installation and near native performance. That world became a reality in December 2019, when WebAssembly became an official w three c standard. It includes a low level language similar to Assembly that can be represented with text, then convert it to a binary format that runs on all modern browsers. However, you won't actually write this code directly, but rather use it as a compilation target for programs written in other languages. For example, you might build a game with Unity and c sharp, and compile it to WebAssembly where it can be delivered in the browser. Now, it's important to note that it's not intended to replace JavaScript. In fact, the 2 work well together side by side. Figma, for example, uses React JS for its outer UI. Then on the inside, you have a high performance c plus plus design tool that feels just as fast as native software. As a developer, there are many different ways you can build a WebAssembly app with many more under development. One of the most popular tools is Emscripten, which can convert a c or c plus plus program to WebAssembly, as it did by bringing AutoCAD to the web, which is a 30 year old code base. No way. One of the best ways to get started is with AssemblyScript, which is a language that looks like TypeScript, but compiles to WebAssembly. We can easily start a new AssemblyScript Project using Node JS and NPM, then we'll write our first WebAssembly module in the index TS file. Unlike JavaScript, a dynamic interpreted language, WebAssembly is a static compiled language, with strict type guarantees. For example, our code can't use the any type. When it comes to numbers, we need to specify a 32 bit integer or a 64 bit floating point. In addition, we can't use dynamic objects. Instead, we use maps where we can strongly type the key value pairs. Once we're happy with our code, we can then compile it down to a binary, which is a file that ends in dotwasm. We can now run this binary in the browser, open an HTML page, and then use the WebAssembly API to instantiate streaming. Simply fetch the binary, and when the promise resolves, do something with it. This has been WebAssembly in 100 seconds. If you wanna see a more in-depth video on this topic, please let me know in the comments, and make sure to subscribe and hit the like button. Thanks for watching, and I will see you in the next one.
The speaker discusses the benefits of Web reminded for building web applications with multiple languages and recommends using AssemblyScript for dynamic interpreted code. They also suggest building a Web reminded app using advised builds and Emscripten for dynamic objects. The speaker emphasizes the importance of setting a 32 bit integer or 64 bit floating point for dynamic objects and recommends Emscripten for dynamic interpreted code.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : Web Assembly (WASM) in 100 Seconds 
        and a small summary : The speaker discusses the benefits of Web reminded for building web applications with multiple languages and recommends using AssemblyScript for dynamic interpreted code. They also suggest building a Web reminded app using advised builds and Emscripten for dynamic objects. The speaker emphasizes the importance of setting a 32 bit integer or 64 bit floating point for dynamic objects and recommends Emscripten for dynamic interpreted code.
        [/INST]
        
        Generate the video : WebAssembly. Write applications for the web in languages other than JavaScript. Imagine a world where you could build software with c plus plus Rust, Python, Go, or even COBOL, then deliver that software to the end user in a web browser without any installation and near native performance. That world became a reality in December 2019, when WebAssembly became an official w three c standard. It includes a low level language similar to Assembly that can be represented with text, then convert it to a binary format that runs on all modern browsers. However, you won't actually write this code directly, but rather use it as a compilation target for programs written in other languages. For example, you might build a game with Unity and c sharp, and compile it to WebAssembly where it can be delivered in the browser. Now, it's important to note that it's not intended to replace JavaScript. In fact, the 2 work well together side by side. Figma, for example, uses React JS for its outer UI. Then on the inside, you have a high performance c plus plus design tool that feels just as fast as native software. As a developer, there are many different ways you can build a WebAssembly app with many more under development. One of the most popular tools is Emscripten, which can convert a c or c plus plus program to WebAssembly, as it did by bringing AutoCAD to the web, which is a 30 year old code base. No way. One of the best ways to get started is with AssemblyScript, which is a language that looks like TypeScript, but compiles to WebAssembly. We can easily start a new AssemblyScript Project using Node JS and NPM, then we'll write our first WebAssembly module in the index TS file. Unlike JavaScript, a dynamic interpreted language, WebAssembly is a static compiled language, with strict type guarantees. For example, our code can't use the any type. When it comes to numbers, we need to specify a 32 bit integer or a 64 bit floating point. In addition, we can't use dynamic objects. Instead, we use maps where we can strongly type the key value pairs. Once we're happy with our code, we can then compile it down to a binary, which is a file that ends in dotwasm. We can now run this binary in the browser, open an HTML page, and then use the WebAssembly API to instantiate streaming. Simply fetch the binary, and when the promise resolves, do something with it. This has been WebAssembly in 100 seconds. If you wanna see a more in-depth video on this topic, please let me know in the comments, and make sure to subscribe and hit the like button. Thanks for watching, and I will see you in the next one.
        