How to Install Rust in Termux

how to install rust in termux

Learn how to install Rust in Termux. This step-by-step guide will help you get started with Rust development on your Android device.


Rust is a modern systems programming language that has quickly grown in popularity in recent years. It offers a unique combination of performance, reliability, and productivity that appeals to many developers working in fields like embedded devices, web services, and scientific computing.

One of the great benefits of Rust is that it can target a wide variety of platforms, including mobile devices and browsers. This is made possible by compiling Rust to WebAssembly, as well as cross-compiling for multiple architectures.

Termux is an Android terminal emulator and Linux environment app that allows you to run many Linux programs and utilities on Android devices. By installing the Rust toolchain in Termux, you can develop Rust applications directly on your Android smartphone or tablet.

In this comprehensive guide, we will cover everything you need to know to get up and running with Rust on Termux. We will explain what Termux is, why you may want to install Rust in Termux, list the prerequisites, provide step-by-step installation instructions, demonstrate project creation, and offer advanced usage tips and real-world examples.

By the end, you will have Rust ready to use within the Termux environment on your Android device for building exciting Rust projects. Let's get started!

A brief explanation of Rust programming language

Rust is a programming language focused on safety, speed, and concurrency. It accomplishes these goals through numerous innovative language features.

Rust's safety comes from its strict compiler that enforces rules to prevent common bugs like race conditions, null pointer exceptions, and use-after-free errors. The compiler uses concepts like ownership and borrowing to manage memory at compile-time instead of at runtime.

For speed, Rust combines low-level control like C and C++ with zero-cost abstractions. It provides low overhead and control over memory layout while avoiding dangers like buffer overflows. The compiler optimizes well and provides helpful profiling tools.

Concurrency is first-class in Rust. The language provides threads, channels, and atomics that make it easy to write reliable concurrent code. Rust avoids data races at compile-time and enforces thread safety.

By combining these strengths, Rust aims to empower programmers to build fast, reliable software without sacrificing productivity.

Importance of installing Rust on Termux

There are several key reasons why installing Rust on Termux is useful:
  • Cross-platform development - You can develop Rust programs for Android, Linux, WebAssembly, and more all from your Android device.
  • Leverage device capabilities - Access Android features like sensors and camera directly from Rust.
  • Quick prototyping - Test Rust code quickly during development without needing to transfer to a PC.
  • Mobile use cases - Build mobile apps, games, emulators, and tools using Rust and Termux.
  • Access Linux tools - Take advantage of Termux's Linux environment and tools from within Rust.
  • Learning and experimenting - Excellent for learning Rust with a hands-on approach directly on your mobile device.
By unlocking the capabilities of Rust on Android via Termux, you open many exciting possibilities for mobile development and beyond.

Overview of the article's content

In this article, we will first introduce Termux and discuss why running Rust in Termux is useful for development.

We will then outline the prerequisites including required packages and setting up Termux. Next, we will go step-by-step through installing the Rust toolchain in Termux.

After verifying the installation was successful, we'll see how to create a Rust project in Termux as an example. We'll also cover additional details like updating, uninstalling, and working with Rust's package manager Cargo in Termux.

In the final sections, we'll provide advanced tips and tricks for integrating Rust and Termux into your workflows. We'll look at real-world examples of projects leveraging Rust on Termux. Finally, we'll conclude by summarizing everything covered about using Rust on Termux.

By the end of the article, you'll be fully equipped to harness the power of Rust on your Android device using Termux for your own projects!

What is Termux?

Before we dive into using Rust with Termux, let's take a moment to understand what Termux is and why it is useful.

Introduction to Termux

Termux is an open-source terminal emulator and Linux environment app for Android. It provides a terminal interface and Linux command line tools without needing root access.

Termux runs a minimal Debian Linux environment on top of Android using the proot compatibility layer. This allows many Linux packages and programs to run seamlessly on Android.

Some of the core features of Termux include:
  • A fast terminal emulator with Bash shell access
  • Linux command line tools like coreutils, grep, git, python, etc.
  • Ability to install additional Linux packages using the APT package manager
  • Development environments for programming languages
  • Access to Android resources like storage and sensors
  • No root required
Termux combines the flexibility and tools of a Linux environment with Android's portability and touch interface. It brings the Linux command line experience right on your mobile device.

Key features of Termux

Let's highlight some of the main capabilities Termux provides:
  • Terminal access - Use the Termux terminal with Bash shell and core Linux command line utilities.
  • Linux packages - Install common Linux packages for development like languages, editors, utilities via APT.
  • Android resources - Access Android functionality like storage, camera, sensors from the Linux environment.
  • Add-on apps - Extend Termux functionality with add-on apps like a GUI/window manager.
  • Programming environment - Use development languages like Python, C/C++, Rust, Go and build apps in Termux.
  • No root required - Take advantage of Linux environment on Android without needing root access.
  • Open source - Termux and core utilities are open source and hosted on Github.
  • Customization - Customize your Termux environment with dotfiles, themes, shortcuts, plugins and more.
These powerful features make Termux an ideal environment for programming, system administration, and Linux customization directly on an Android device.

Use cases for Termux

Termux empowers developers, ethical hackers, and Linux/Android enthusiasts through providing a flexible terminal environment and tools. Here are some of the popular use cases for Termux:
  • Learn Linux and Bash shell basics right on your Android device.
  • Develop mobile apps with languages like Python, C/C++, Rust, Go and more.
  • Remotely access devices using ssh and tools like nmap.
  • Run Linux GUI apps using VNC.
  • Program Arduino and other microcontrollers using Termux tools over USB.
  • Create custom terminal environments using dotfiles, themes and plugins.
  • Automate tasks on your Android device using cron jobs and scripts.
  • Use Git and GitHub to manage projects and code.
  • Compile and experiment with Android apps without a full SDK setup.
  • Launch penetration testing and security auditing tasks.
  • Emulate games and tools using packages like gnugo, sl, etc.
This range of possibilities has spawned a thriving community around Termux of developers, hackers, makers, and open source enthusiasts.

Why Install Rust on Termux?

Now that we've got an overview of Termux, let's discuss the benefits of installing Rust specifically in the Termux environment.

Benefits of using Rust on Termux

Here are some of the main advantages of running Rust within Termux:
  • Cross-compile code - Compile Rust to target Android and other platforms from one environment.
  • Access Android features - Call Android APIs natively from Rust code like camera, sensors, storage, etc.
  • Quick testing - Compile and run Rust programs directly on your Android device.
  • Leverage Linux tools - Use Linux utilities while developing Rust projects in Termux.
  • Mobile development - Create Rust-based mobile apps, games, emulators, etc.
  • No desktop required - Develop anywhere using just your Android mobile device.
  • Open source modules - Take advantage of Rust's huge ecosystem of packages.
  • Fun and easy learning - Excellent for learning Rust interactively on a mobile device.
Rust is an ideal language for Termux given its focus on performance critical applications, multi-platform support, small runtime, and safety guarantees.

Use cases for Rust programming language

Let's discuss some of the most common and emerging use cases where Rust delivers excellent value:
  • Systems programming - OS, firmware, embedded, and driver development.
  • Web development - Web servers, web assembly, APIs, services.
  • Network programming - Low level TCP/IP, asynchronous IO, networking tools.
  • Mobile apps - Android/iOS apps with Rust and cross-compiling.
  • CLI applications - Productivity tools, utilities, devops programs.
  • Games - 2D, 3D, simulations, and retro gaming.
  • Scientific computing - High performance computing applications.
  • WebAssembly - Running Rust code efficiently in web browsers.
  • Blockchain - Cryptocurrency, finance, and consensus technologies.
Rust's combination of performance, safety, concurrency, and productivity make it a versatile language for many domains and use cases.

Examples of projects that can be built with Rust on Termux

To showcase the possibilities, here are examples of fun projects that can be built with Rust within the Termux environment on Android:
  • Mobile games using ggez or nannou
  • Emulators for retro consoles and arcade machines
  • Android automation and scripting apps
  • 2D OpenGL based rendering and visualization
  • Scientific and technical computing programs
  • Tools for microcontroller programming and IoT
  • Terminal based productivity apps and utilities
  • Mods and extensions for classic games
  • WebAssembly modules for client-side web apps
  • Networking and HTTP services
  • Machine learning model deployment
This diversity of project ideas highlights the flexibility of using Rust on Termux for mobile development and beyond. Your imagination is the limit!


Before we can install Rust, we need to make sure we have Termux setup and ready on our Android device. Let's go over the prerequisites.

List of items required for the installation

To follow along and install Rust on Termux, you will need:
  • An Android device running Android 5.0 or newer
  • Termux app installed from F-Droid
  • Minimum 200MB of free storage space
  • Stable internet connection on device
  • Patience and ability to troubleshoot issues
That's it! The beauty of Termux is needing minimal prerequisites. Now let's setup the Termux app.

Setting up Termux on your Android device

Once you have Termux installed, launch it and go through these one-time setup steps:
  1. Accept the Termux disclaimer notice.
  2. Optionally enable Temperature Notifications to prevent overheating.
  3. Grant Termux all requested Android permissions.
  4. The Terminal will start with the first run message. Tap Enter to access the Bash prompt.
  5. Optionally customize the visual theme and fonts.
  6. Configure the soft keyboard to show special keys and shortcuts.
  7. Get familiar with moving around the CLI and Linux basics like ls, cd, etc by learning Termux commands.
After finishing this initial configuration, Termux will be ready to use. We can now move on to installing packages and Rust.

Explaining why prerequisites are necessary

It's important to have the right software environment setup before installing programming language toolchains like Rust. Here's why the prerequisites matter:
  • Android 5.0 - Minimum Android version required by Termux.
  • Termux - Provides the terminal and Linux environment to run Rust.
  • Storage space - Downloading Rust and its tools takes up disk space.
  • Stable internet - Needed for package downloads during installation.
  • Troubleshooting skills - Potentially resolve errors during the install process.
By ensuring these prerequisites are met, we reduce the chance of getting blocked by technical issues when installing Rust in Termux. We want the installation to proceed smoothly so we can start developing apps as fast as possible.

Now that our system is ready, let's get to the good part - installing Rust!

Installing Rust on Termux

We'll be using Termux's APT package manager to install Rust. This takes care of downloading the Rust binaries and tools for the ARM architecture used on Android.

Step 1: Update and upgrade Termux

First, we'll update the local APT package index and upgrade any existing packages:

apt update && apt upgrade -y

This prepares Termux with information on the latest package versions before installing Rust and its dependencies.

Update and upgrade Termux

Step 2: Install the Rust package

With the update done, we can now install the Rust package:

apt install rust -y

The installation will take a few minutes to download and extract the Rust toolchain into Termux. All the components like rustc, cargo, rustup will be installed.

Once complete, Rust is ready to use within Termux!

Install the Rust package

Step 3: Verifying the Rust installation

To verify Rust installed correctly, let's check the version:

rustc --version

This should print out details on the Rust compiler version, which at the time of writing is:

rustc 1.73.0 (cc66ad468 2023-10-03) (built from a source tarball)

Where 1.73.0 is the installed Rust toolchain version.

Note: In your case, the version and the date might be different.

Verifying the Rust installation

We can also check Cargo, the Rust package manager:

cargo --version

Which will output the version:

cargo 1.73.0

With rustc and cargo present, our Rust installation is successful!

Checking cargo version

Troubleshooting common installation issues

Sometimes the installation may fail. Here are some common issues and solutions:
  • Connection issues - Check your device has a stable internet connection.
  • Storage full - Free up space on device storage to install Rust's tools.
  • Old Android OS - Ensure you meet the minimum Android version requirement.
  • APT issues - Run apt update and apt upgrade again before re-installing.
  • Permissions - Double check Termux has storage and network access permissions.
  • Manual install - Download Rust deb package manually and install with dpkg.
With these troubleshooting tips, you can resolve most Rust installation problems on Termux.

Managing Rust on Termux

Now that we have Rust installed on Termux, let's go over some details on maintaining and managing the Rust toolchain.

Updating Rust to the latest version

The Rust project frequently releases updated versions of the rustc compiler and cargo tool.

To update Rust to the latest version in Termux, simply run:

apt update
apt upgrade

This will fetch the most recent Rust packages and upgrade to the newer version.

Check it worked with rustc --version and cargo --version to see the new versions.

Uninstalling Rust from Termux

If you need to uninstall Rust from Termux, it's a simple 2-step process:
  • Uninstall Rust package:
apt uninstall rust
  • Purge remaining Rust files:
apt purge rust

This will completely remove the Rust toolchain and all components from Termux.

Of course, you can always reinstall it later using the apt install command.

Working with Rust's package manager, Cargo

Cargo is Rust's built-in package manager included with rustc. It lets you easily add dependencies and modules to your Rust projects.

On Termux, you can use cargo commands like:
  • cargo init - Initialize a new Rust project
  • cargo build - Compile the current project
  • cargo run - Build and execute project
  • cargo test - Run unit tests
  • cargo doc - Generate documentation
Cargo downloads dependencies, compiles projects, creates executables, and more. It's an indispensable tool for managing Rust projects.

Now let's see this by creating a sample project with Cargo in Termux.

Creating a Rust Project on Termux

Let's walk through creating and running a simple Rust "Hello World" program within the Termux environment.

Setting up a new Rust project

In your Termux home directory, run:

cargo init hello-termux

This initializes a new cargo project folder named hello-termux.

Navigate into the project folder:

cd hello-termux

This project is ready for us to write Rust code.

Writing and building a simple Rust program

Using an editor like Vim or nano, create a src/ file with:

fn main() {
  println!("Hello from Rust on Termux!");

This basic program prints a message.

To build it, run:

cargo build --release

Cargo will compile our program into an executable.

Running the Rust program on Termux

With our program built, we can now run it:


This will execute the Rust program directly within the Termux environment and print:

Hello from Rust on Termux!

We've now created, built, and run our first Rust program completely on an Android device using Termux!

Advanced Tips and Tricks

Let's go through some pro techniques for integrating Rust and Termux into advanced workflows.

Using Rust for cross-compilation

A major benefit of Rust in Termux is cross-compiling code for multiple target platforms.

For example, you can cross-compile a Rust program for Android ARM, Linux x86_64, WebAssembly, and more from the same environment using custom toolchain targets.

Here are some examples for different targets:

# Android ARM
rustup target add armv7-linux-androideabi

# Linux x86_64  
rustup target add x86_64-unknown-linux-gnu

# WebAssembly
rustup target add wasm32-unknown-unknown

With multi-target support, you can efficiently build for desktop, mobile, web, and embedded devices using Rust in Termux.

Leveraging Rust's package ecosystem

Rust has a thriving ecosystem of packages on to accelerate development.

You can leverage these easily in Termux via Cargo by adding them to your Cargo.toml manifest:

reqwest = "0.11"
serde = { version = "1.0", features = ["derive"] }

This allows you to build on powerful Rust libraries for your Termux projects.

Integrating Termux and Rust into your workflow

Here are tips for seamlessly using Termux and Rust in your mobile development flow:
  • Use Termux: API Rust crate to access Android functionality.
  • Build and compile projects in Termux, edit code on PC.
  • Test Rust code on device quickly with cargo run.
  • Compile final builds for release with cargo build --release.
  • Develop modules for WebAssembly to integrate with JavaScript.
  • Sync Termux home folder with cloud drives for backup.
  • Use CI services to build projects on a remote server.
Termux and Rust together enable you to build mobile apps right from your pocket!

Real-World Examples

Let's look at real open-source apps that demonstrate using Rust and Termux.

Real-world projects that use Rust on Termux

  • TabWasher - Terminal tool to close browser tabs.
  • termplay - Terminal music player.
  • imgcat - Display images in terminal.
  • pxe - Colorful visual pixel editor.
  • sui - Terminal UI toolkit.
  • neatvnc - VNC client.
These demonstrate the diversity of utilities and applications that can be built with Rust on Termux.

The impact of Rust and Termux in different domains

Rust and Termux are making an impact across multiple domains:
  • Mobile Apps - Building Android apps natively with Rust improves performance.
  • CLI Tools - Rust's speed empowers developers to build blazing fast command line tools.
  • System Utilities - For system level applications, Rust provides safety and low overhead.
  • WebAssembly - Running Rust code compiled to WASM unlocks web app potential.
  • General Programming - Termux enables easily testing and learning Rust interactively.
Rust and Termux will continue growing together as programmers recognize their complementary strengths.


Let's wrap up everything we've discussed about using Rust with Termux.

key points of the article

The major takeaways from this guide on installing Rust on Termux are:
  • Termux provides a flexible Linux environment on Android without root.
  • Rust's performance and multi-platform support makes it ideal for Termux.
  • Installing Rust in Termux enables cross-compilation and mobile development.
  • Cargo and Rust packages integrate seamlessly within Termux.
  • Developing Rust programs directly on Android is easy and fun.
  • Rust and Termux together empower building mobile apps, CLI tools, emulators, WebAssembly, and more.
For programmers looking to unlock Rust's potential on mobile, explore installing Rust on Termux.

It's wonderful for learning Rust interactively as well as building creative projects on Android. Rust and Termux complement each other beautifully.

Additional resources for further learning

For more details on Rust and Termux:
Check out these resources to take your Rust and Termux skills to advanced levels.

Thank you for reading this comprehensive guide on installing and using Rust on Termux. I hope you found it helpful for effectively using Rust for mobile development and other use cases. Feel free to provide any feedback for improving this article. Keep learning and building great things with Rust and Termux!

Post a Comment

Previous Post Next Post