Supercharge Your Python Apps with Rust

Supercharge Your Python Apps with Rust

Arjun Adhikari's photo
Arjun Adhikari
·

3 min read

Welcome to our latest exploration, where we dive into the thrilling world of combining the raw power of Rust with the versatility of Python to elevate your programming projects to unprecedented levels of efficiency and performance. In "Supercharge Your Python Apps with Rust," we embark on a journey designed to transform beginners into adept users of these two formidable languages.

Whether you're looking to boost your Python application's speed, ensure memory safety, or simply be curious about integrating Rust into your workflow, this blog is your first step towards mastering the art of leveraging Rust's capabilities within your Python projects. Dive in now to discover a step-by-step guide that demystifies the process, making it accessible and straightforward for developers of all skill levels. Don't miss out on unlocking the full potential of your applications; join us in this exciting adventure!

Creating a dynamic library in Rust and calling it from Python using Foreign Function Interface (FFI) is an exciting way to leverage Rust's performance and safety in Python applications. This tutorial will guide you through the process step-by-step, with clear examples and explanations tailored for developers.

Creating a Rust Dynamic Library

Step 1: Setting Up Your Rust Project

First, you'll need to create a new Rust library project. Open a terminal and run the following command:

cargo new --lib rust_library
cd rust_library

This command creates a new Rust library project called rust_library and moves it into the project directory.

Step 2: Writing Your Rust Function

Open the src/lib.rs file and replace its contents with the following code, which defines a simple function to add two numbers:

#[no_mangle]
pub extern "C" fn add_numbers(a: i32, b: i32) -> i32 {
    a + b
}

  • #[no_mangle] prevents Rust from changing the name of the function during compilation, making it easier to link from Python.

  • pub extern "C" makes this function adhere to the C calling convention, a requirement for FFI.

Step 3: Configuring Cargo.toml

Open the Cargo.toml file and add the following lines to create a dynamic library:

[lib]
crate-type = ["cdylib"]

This configuration tells Rust to compile the library as a C-compatible dynamic library (cdylib).

Step 4: Building the Dynamic Library

Run the following command in your terminal:

cargo build --release

After the build completes, you'll find the dynamic library in target/release (e.g., librust_library.so on Linux, rust_library.dll on Windows, or librust_library.dylib on macOS).

Calling Rust from Python

Step 1: Installing ctypes in Python

Ensure you have ctypes available in your Python environment. It's included in the standard library, so you should be all set.

Step 2: Writing Python Code to Call Rust Function

Create a new Python file (e.g., call_rust.py) and write the following code:

from ctypes import cdll, c_int

# Load the shared library. Adjust the path as necessary.
lib = cdll.LoadLibrary("target/release/librust_library.so")

# Set the argument and return types
lib.add_numbers.argtypes = (c_int, c_int)
lib.add_numbers.restype = c_int

# Call the Rust function
result = lib.add_numbers(5, 7)
print(f"The result is: {result}")

  • Adjust the path to LoadLibrary based on your dynamic library's location and name.

  • argtypes and restype ensure Python correctly converts types between Python and Rust.

Step 3: Running Your Python Code

Run your Python script:

python call_rust.py

You should see the output:

The result is: 12

Conclusion

You've now successfully created a Rust dynamic library and called it from Python using FFI! This approach enables you to combine Rust's performance and reliability with Python's ease of use, creating powerful and efficient applications.

This tutorial serves as a basic introduction to FFI and inter-language communication. As you dive deeper, you'll encounter more complex scenarios, such as passing strings or complex data structures between Rust and Python. Each step has been designed to be as developer-friendly as possible, providing you with a solid foundation for integrating Rust and Python in your projects.

The examples for the above tutorial is referenced from : https://github.com/theArjun/learning-rust/tree/main/rust_adder

PythonRustFFI