Tauri is a tool for building cross-platform desktop apps on Windows, MacOS, and Linux with JavaScript & Rust. It is very lightweight and fast compared to similar tools like Electron.  

#dev #programming #100SecondsOfCode

🔗 Resources

Tauri https://tauri.studio
Tauri GitHub https://github.com/tauri-apps/tauri
Reddit thread about Tauri https://www.reddit.com/r/programming/comments/lns5mj/tauri_an_electron_alternative_written_in_rust/
Electron in 100 Seconds https://youtu.be/m3OjWNFREJo

🔥 Get More Content - Upgrade to PRO

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

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font

🔖 Topics Covered

- Tauri tutorial
- How to build a desktop app with JavaScript
- Electron vs Tauri
- Electron.js Alternative
- Windows app with JS
- Linux app with JS
- MacOS app with JS
2024-02-04T05:27:15.886Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
164893a2-f4db-4106-b4a1-762cdd19a82c
e02ffd3ac99a3c933864a718623dcf4e27c9adfe17ea41e69be202ef37e17103
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Taori, a toolkit for building native desktop apps with front end web technologies and a lightweight Rust back end.
It allows you to use your favorite Java script framework to design a UI, then package it for Mac OS, Windows, and Linux from a single code base.
Since the dawn of time, JavaScript developers have been searching for the perfect way to build cross platform apps.
For the last decade, Electron has been the leader in this space, which provides a back end in Node.
Js and a front end with the Chromium browser.
The main criticism of this approach is that it results in a very large executable file that consumes a lot of memory on the machine.
Tauri takes a different approach by replacing Node.
Js with and Chromium with libraries like TAO and RIE to provide a lightweight web view.
The end result is a smaller bundle size and more efficient memory consumption.
It so take security very seriously, and provides an isolation pattern to prevent untrusted scripts from accessing the back end from a web view.
The Tauri API by its a secure way to access native functionality like the file system, HTTP, and system notifications.
It's secure by default, and the only way for the front end to call back end and code is when the developer explicitly allows it.
To get started, install Rust Node JS, then create a new Towery app.
Choose your favorite JavaScript framework to build the front end.
It looks identical to a web project, except for the source Towery directory.
This is the back end for your native desktop app, inside of which you'll find icons ones that will be displayed when the app is installed.
The icons are referenced in the tower config file, which also contains important information like as the bundle identifier, as well as build settings for macOS, Windows, and Linux.
Now the entry point for your back end is in the main dot RS file.
From here, we can customize the experience on the native operating system.
By importing the menu types, we can create a custom native menu that will work seamlessly on all platforms.
In addition, we can define code in Rust that can then be invoked from the JavaScript front end, and it has its own custom event system that allows complex message passing from the front end to the back end and vice versa.
Now in the front end code, a variety of native APIs can be accessed with JavaScript.
For example, We might import write file from the file system, then simply bind that function to the click event on a button.
And now the app has the ability to create a file on the user's hard drive.
After that, we may want to show a native dialogue, which we can accomplish with a single line of code from the Towery API.
And access to any API method can be controlled from the allow list in the tau reconfig file.
Now to compile and build the app, run the tau rebuild command.
This will create an executable in the target directory.
Congratulations.
You just built a high performance native desktop app that can run on any platform.
This has in Tauri in 100 seconds.
If you wanna see a full tutorial, let me know in the comments.
Thanks for watching, and I will see you in the next one.

Speaker 0: Taori, a toolkit for building native desktop apps with front end web technologies and a lightweight Rust back end. It allows you to use your favorite Java script framework to design a UI, then package it for Mac OS, Windows, and Linux from a single code base. Since the dawn of time, JavaScript developers have been searching for the perfect way to build cross platform apps. For the last decade, Electron has been the leader in this space, which provides a back end in Node. Js and a front end with the Chromium browser.

The main criticism of this approach is that it results in a very large executable file that consumes a lot of memory on the machine. Tauri takes a different approach by replacing Node. Js with and Chromium with libraries like TAO and RIE to provide a lightweight web view. The end result is a smaller bundle size and more efficient memory consumption. It so take security very seriously, and provides an isolation pattern to prevent untrusted scripts from accessing the back end from a web view.

The Tauri API by its a secure way to access native functionality like the file system, HTTP, and system notifications. It's secure by default, and the only way for the front end to call back end and code is when the developer explicitly allows it. To get started, install Rust Node JS, then create a new Towery app. Choose your favorite JavaScript framework to build the front end. It looks identical to a web project, except for the source Towery directory.

This is the back end for your native desktop app, inside of which you'll find icons ones that will be displayed when the app is installed. The icons are referenced in the tower config file, which also contains important information like as the bundle identifier, as well as build settings for macOS, Windows, and Linux. Now the entry point for your back end is in the main dot RS file. From here, we can customize the experience on the native operating system. By importing the menu types, we can create a custom native menu that will work seamlessly on all platforms.

In addition, we can define code in Rust that can then be invoked from the JavaScript front end, and it has its own custom event system that allows complex message passing from the front end to the back end and vice versa. Now in the front end code, a variety of native APIs can be accessed with JavaScript. For example, We might import write file from the file system, then simply bind that function to the click event on a button. And now the app has the ability to create a file on the user's hard drive. After that, we may want to show a native dialogue, which we can accomplish with a single line of code from the Towery API.

And access to any API method can be controlled from the allow list in the tau reconfig file. Now to compile and build the app, run the tau rebuild command. This will create an executable in the target directory. Congratulations. You just built a high performance native desktop app that can run on any platform.

This has in Tauri in 100 seconds. If you wanna see a full tutorial, let me know in the comments. Thanks for watching, and I will see you in the next one.
Taori, a toolkit for building native desktop apps with front end web technologies and a lightweight Rust back end. It allows you to use your favorite Java script framework to design a UI, then package it for Mac OS, Windows, and Linux from a single code base. Since the dawn of time, JavaScript developers have been searching for the perfect way to build cross platform apps.
architecture
For the last decade, Electron has been the leader in this space, which provides a back end in Node. Js and a front end with the Chromium browser. The main criticism of this approach is that it results in a very large executable file that consumes a lot of memory on the machine. Tauri takes a different approach by replacing Node. Js with and Chromium with libraries like TAO and RIE to provide a lightweight web view. The end result is a smaller bundle size and more efficient memory consumption.
It so take security very seriously, and provides an isolation pattern to prevent untrusted scripts from accessing the back end from a web view. The Tauri API by its a secure way to access native functionality like the file system, HTTP, and system notifications. It's secure by default, and the only way for the front end to call back end and code is when the developer explicitly allows it.
security
To get started, install Rust Node JS, then create a new Towery app. Choose your favorite JavaScript framework to build the front end. It looks identical to a web project, except for the source Towery directory. This is the back end for your native desktop app, inside of which you'll find icons ones that will be displayed when the app is installed. The icons are referenced in the tower config file, which also contains important information like as the bundle identifier, as well as build settings for macOS, Windows, and Linux.
architecture
Now the entry point for your back end is in the main dot RS file. From here, we can customize the experience on the native operating system. By importing the menu types, we can create a custom native menu that will work seamlessly on all platforms. In addition, we can define code in Rust that can then be invoked from the JavaScript front end, and it has its own custom event system that allows complex message passing from the front end to the back end and vice versa. Now in the front end code, a variety of native APIs can be accessed with JavaScript. For example, We might import write file from the file system, then simply bind that function to the click event on a button. And now the app has the ability to create a file on the user's hard drive. After that, we may want to show a native dialogue, which we can accomplish with a single line of code from the Towery API. And access to any API method can be controlled from the allow list in the tau reconfig file. Now to compile and build the app, run the tau rebuild command. This will create an executable in the target directory. Congratulations. You just built a high performance native desktop app that can run on any platform.
This has in Tauri in 100 seconds. If you wanna see a full tutorial, let me know in the comments. Thanks for watching, and I will see you in the next one.
teaching
Taori, a toolkit for building native desktop apps with front end web technologies and a lightweight Rust back end. It allows you to use your favorite Java script framework to design a UI, then package it for Mac OS, Windows, and Linux from a single code base. Since the dawn of time, JavaScript developers have been searching for the perfect way to build cross platform apps. For the last decade, Electron has been the leader in this space, which provides a back end in Node. Js and a front end with the Chromium browser. The main criticism of this approach is that it results in a very large executable file that consumes a lot of memory on the machine. Tauri takes a different approach by replacing Node. Js with and Chromium with libraries like TAO and RIE to provide a lightweight web view. The end result is a smaller bundle size and more efficient memory consumption. It so take security very seriously, and provides an isolation pattern to prevent untrusted scripts from accessing the back end from a web view. The Tauri API by its a secure way to access native functionality like the file system, HTTP, and system notifications. It's secure by default, and the only way for the front end to call back end and code is when the developer explicitly allows it. To get started, install Rust Node JS, then create a new Towery app. Choose your favorite JavaScript framework to build the front end. It looks identical to a web project, except for the source Towery directory. This is the back end for your native desktop app, inside of which you'll find icons ones that will be displayed when the app is installed. The icons are referenced in the tower config file, which also contains important information like as the bundle identifier, as well as build settings for macOS, Windows, and Linux. Now the entry point for your back end is in the main dot RS file. From here, we can customize the experience on the native operating system. By importing the menu types, we can create a custom native menu that will work seamlessly on all platforms. In addition, we can define code in Rust that can then be invoked from the JavaScript front end, and it has its own custom event system that allows complex message passing from the front end to the back end and vice versa. Now in the front end code, a variety of native APIs can be accessed with JavaScript. For example, We might import write file from the file system, then simply bind that function to the click event on a button. And now the app has the ability to create a file on the user's hard drive. After that, we may want to show a native dialogue, which we can accomplish with a single line of code from the Towery API. And access to any API method can be controlled from the allow list in the tau reconfig file. Now to compile and build the app, run the tau rebuild command. This will create an executable in the target directory. Congratulations. You just built a high performance native desktop app that can run on any platform. This has in Tauri in 100 seconds. If you wanna see a full tutorial, let me know in the comments. Thanks for watching, and I will see you in the next one.
Taori,
taori
a
a
toolkit
toolkit
for
for
building
building
native
native
desktop
desktop
apps
apps
with
with
front
front
end
end
web
web
technologies
technologies
and
and
a
a
lightweight
lightweight
Rust
rust
back
back
end.
end
It
it
allows
allows
you
you
to
to
use
use
your
your
favorite
favorite
Java
java
script
script
framework
framework
to
to
design
design
a
a
UI,
ui
then
then
package
package
it
it
for
for
Mac
mac
OS,
os
Windows,
windows
and
and
Linux
linux
from
from
a
a
single
single
code
code
base.
base
Since
since
the
the
dawn
dawn
of
of
time,
time
JavaScript
javascript
developers
developers
have
have
been
been
searching
searching
for
for
the
the
perfect
perfect
way
way
to
to
build
build
cross
cross
platform
platform
apps.
apps
For
for
the
the
last
last
decade,
decade
Electron
electron
has
has
been
been
the
the
leader
leader
in
in
this
this
space,
space
which
which
provides
provides
a
a
back
back
end
end
in
in
Node.
node
Js
js
and
and
a
a
front
front
end
end
with
with
the
the
Chromium
chromium
browser.
browser
The
the
main
main
criticism
criticism
of
of
this
this
approach
approach
is
is
that
that
it
it
results
results
in
in
a
a
very
very
large
large
executable
executable
file
file
that
that
consumes
consumes
a
a
lot
lot
of
of
memory
memory
on
on
the
the
machine.
machine
Tauri
tauri
takes
takes
a
a
different
different
approach
approach
by
by
replacing
replacing
Node.
node
Js
js
with
with
and
and
Chromium
chromium
with
with
libraries
libraries
like
like
TAO
tao
and
and
RIE
rie
to
to
provide
provide
a
a
lightweight
lightweight
web
web
view.
view
The
the
end
end
result
result
is
is
a
a
smaller
smaller
bundle
bundle
size
size
and
and
more
more
efficient
efficient
memory
memory
consumption.
consumption
It
it
so
so
take
take
security
security
very
very
seriously,
seriously
and
and
provides
provides
an
an
isolation
isolation
pattern
pattern
to
to
prevent
prevent
untrusted
untrusted
scripts
scripts
from
from
accessing
accessing
the
the
back
back
end
end
from
from
a
a
web
web
view.
view
The
the
Tauri
tauri
API
api
by
by
its
its
a
a
secure
secure
way
way
to
to
access
access
native
native
functionality
functionality
like
like
the
the
file
file
system,
system
HTTP,
http
and
and
system
system
notifications.
notifications
It's
it's
secure
secure
by
by
default,
default
and
and
the
the
only
only
way
way
for
for
the
the
front
front
end
end
to
to
call
call
back
back
end
end
and
and
code
code
is
is
when
when
the
the
developer
developer
explicitly
explicitly
allows
allows
it.
it
To
to
get
get
started,
started
install
install
Rust
rust
Node
node
JS,
js
then
then
create
create
a
a
new
new
Towery
towery
app.
app
Choose
choose
your
your
favorite
favorite
JavaScript
javascript
framework
framework
to
to
build
build
the
the
front
front
end.
end
It
it
looks
looks
identical
identical
to
to
a
a
web
web
project,
project
except
except
for
for
the
the
source
source
Towery
towery
directory.
directory
This
this
is
is
the
the
back
back
end
end
for
for
your
your
native
native
desktop
desktop
app,
app
inside
inside
of
of
which
which
you'll
you'll
find
find
icons
icons
ones
ones
that
that
will
will
be
be
displayed
displayed
when
when
the
the
app
app
is
is
installed.
installed
The
the
icons
icons
are
are
referenced
referenced
in
in
the
the
tower
tower
config
config
file,
file
which
which
also
also
contains
contains
important
important
information
information
like
like
as
as
the
the
bundle
bundle
identifier,
identifier
as
as
well
well
as
as
build
build
settings
settings
for
for
macOS,
macos
Windows,
windows
and
and
Linux.
linux
Now
now
the
the
entry
entry
point
point
for
for
your
your
back
back
end
end
is
is
in
in
the
the
main
main
dot
dot
RS
rs
file.
file
From
from
here,
here
we
we
can
can
customize
customize
the
the
experience
experience
on
on
the
the
native
native
operating
operating
system.
system
By
by
importing
importing
the
the
menu
menu
types,
types
we
we
can
can
create
create
a
a
custom
custom
native
native
menu
menu
that
that
will
will
work
work
seamlessly
seamlessly
on
on
all
all
platforms.
platforms
In
in
addition,
addition
we
we
can
can
define
define
code
code
in
in
Rust
rust
that
that
can
can
then
then
be
be
invoked
invoked
from
from
the
the
JavaScript
javascript
front
front
end,
end
and
and
it
it
has
has
its
its
own
own
custom
custom
event
event
system
system
that
that
allows
allows
complex
complex
message
message
passing
passing
from
from
the
the
front
front
end
end
to
to
the
the
back
back
end
end
and
and
vice
vice
versa.
versa
Now
now
in
in
the
the
front
front
end
end
code,
code
a
a
variety
variety
of
of
native
native
APIs
apis
can
can
be
be
accessed
accessed
with
with
JavaScript.
javascript
For
for
example,
example
We
we
might
might
import
import
write
write
file
file
from
from
the
the
file
file
system,
system
then
then
simply
simply
bind
bind
that
that
function
function
to
to
the
the
click
click
event
event
on
on
a
a
button.
button
And
and
now
now
the
the
app
app
has
has
the
the
ability
ability
to
to
create
create
a
a
file
file
on
on
the
the
user's
user's
hard
hard
drive.
drive
After
after
that,
that
we
we
may
may
want
want
to
to
show
show
a
a
native
native
dialogue,
dialogue
which
which
we
we
can
can
accomplish
accomplish
with
with
a
a
single
single
line
line
of
of
code
code
from
from
the
the
Towery
towery
API.
api
And
and
access
access
to
to
any
any
API
api
method
method
can
can
be
be
controlled
controlled
from
from
the
the
allow
allow
list
list
in
in
the
the
tau
tau
reconfig
reconfig
file.
file
Now
now
to
to
compile
compile
and
and
build
build
the
the
app,
app
run
run
the
the
tau
tau
rebuild
rebuild
command.
command
This
this
will
will
create
create
an
an
executable
executable
in
in
the
the
target
target
directory.
directory
Congratulations.
congratulations
You
you
just
just
built
built
a
a
high
high
performance
performance
native
native
desktop
desktop
app
app
that
that
can
can
run
run
on
on
any
any
platform.
platform
This
this
has
has
in
in
Tauri
tauri
in
in
100
100
seconds.
seconds
If
if
you
you
wanna
wanna
see
see
a
a
full
full
tutorial,
tutorial
let
let
me
me
know
know
in
in
the
the
comments.
comments
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
In this video, Speaker 0 explains the use of the Taori toolkit for building native desktop apps with front end web technologies and a lightweight Rust back end. He highlights the advantages of Electron, including a secure approach to the app and a lightweight web view, and provides instructions on installing and building the app. He also mentions the use of native APIs and the ability to access any API method on any platform.
Tauri in 100 Seconds
Taori, a toolkit for building native desktop apps with front end web technologies and a lightweight Rust back end. It allows you to use your favorite Java script framework to design a UI, then package it for Mac OS, Windows, and Linux from a single code base. Since the dawn of time, JavaScript developers have been searching for the perfect way to build cross platform apps. For the last decade, Electron has been the leader in this space, which provides a back end in Node. Js and a front end with the Chromium browser. The main criticism of this approach is that it results in a very large executable file that consumes a lot of memory on the machine. Tauri takes a different approach by replacing Node. Js with and Chromium with libraries like TAO and RIE to provide a lightweight web view. The end result is a smaller bundle size and more efficient memory consumption. It so take security very seriously, and provides an isolation pattern to prevent untrusted scripts from accessing the back end from a web view. The Tauri API by its a secure way to access native functionality like the file system, HTTP, and system notifications. It's secure by default, and the only way for the front end to call back end and code is when the developer explicitly allows it. To get started, install Rust Node JS, then create a new Towery app. Choose your favorite JavaScript framework to build the front end. It looks identical to a web project, except for the source Towery directory. This is the back end for your native desktop app, inside of which you'll find icons ones that will be displayed when the app is installed. The icons are referenced in the tower config file, which also contains important information like as the bundle identifier, as well as build settings for macOS, Windows, and Linux. Now the entry point for your back end is in the main dot RS file. From here, we can customize the experience on the native operating system. By importing the menu types, we can create a custom native menu that will work seamlessly on all platforms. In addition, we can define code in Rust that can then be invoked from the JavaScript front end, and it has its own custom event system that allows complex message passing from the front end to the back end and vice versa. Now in the front end code, a variety of native APIs can be accessed with JavaScript. For example, We might import write file from the file system, then simply bind that function to the click event on a button. And now the app has the ability to create a file on the user's hard drive. After that, we may want to show a native dialogue, which we can accomplish with a single line of code from the Towery API. And access to any API method can be controlled from the allow list in the tau reconfig file. Now to compile and build the app, run the tau rebuild command. This will create an executable in the target directory. Congratulations. You just built a high performance native desktop app that can run on any platform. This has in Tauri in 100 seconds. If you wanna see a full tutorial, let me know in the comments. Thanks for watching, and I will see you in the next one.
In this video, Speaker 0 explains the use of the Taori toolkit for building native desktop apps with front end web technologies and a lightweight Rust back end. He highlights the advantages of Electron, including a secure approach to the app and a lightweight web view, and provides instructions on installing and building the app. He also mentions the use of native APIs and the ability to access any API method on any platform.

        [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 : Tauri in 100 Seconds 
        and a small summary : In this video, Speaker 0 explains the use of the Taori toolkit for building native desktop apps with front end web technologies and a lightweight Rust back end. He highlights the advantages of Electron, including a secure approach to the app and a lightweight web view, and provides instructions on installing and building the app. He also mentions the use of native APIs and the ability to access any API method on any platform.
        [/INST]
        
        Generate the video : Taori, a toolkit for building native desktop apps with front end web technologies and a lightweight Rust back end. It allows you to use your favorite Java script framework to design a UI, then package it for Mac OS, Windows, and Linux from a single code base. Since the dawn of time, JavaScript developers have been searching for the perfect way to build cross platform apps. For the last decade, Electron has been the leader in this space, which provides a back end in Node. Js and a front end with the Chromium browser. The main criticism of this approach is that it results in a very large executable file that consumes a lot of memory on the machine. Tauri takes a different approach by replacing Node. Js with and Chromium with libraries like TAO and RIE to provide a lightweight web view. The end result is a smaller bundle size and more efficient memory consumption. It so take security very seriously, and provides an isolation pattern to prevent untrusted scripts from accessing the back end from a web view. The Tauri API by its a secure way to access native functionality like the file system, HTTP, and system notifications. It's secure by default, and the only way for the front end to call back end and code is when the developer explicitly allows it. To get started, install Rust Node JS, then create a new Towery app. Choose your favorite JavaScript framework to build the front end. It looks identical to a web project, except for the source Towery directory. This is the back end for your native desktop app, inside of which you'll find icons ones that will be displayed when the app is installed. The icons are referenced in the tower config file, which also contains important information like as the bundle identifier, as well as build settings for macOS, Windows, and Linux. Now the entry point for your back end is in the main dot RS file. From here, we can customize the experience on the native operating system. By importing the menu types, we can create a custom native menu that will work seamlessly on all platforms. In addition, we can define code in Rust that can then be invoked from the JavaScript front end, and it has its own custom event system that allows complex message passing from the front end to the back end and vice versa. Now in the front end code, a variety of native APIs can be accessed with JavaScript. For example, We might import write file from the file system, then simply bind that function to the click event on a button. And now the app has the ability to create a file on the user's hard drive. After that, we may want to show a native dialogue, which we can accomplish with a single line of code from the Towery API. And access to any API method can be controlled from the allow list in the tau reconfig file. Now to compile and build the app, run the tau rebuild command. This will create an executable in the target directory. Congratulations. You just built a high performance native desktop app that can run on any platform. This has in Tauri in 100 seconds. If you wanna see a full tutorial, let me know in the comments. Thanks for watching, and I will see you in the next one.
        