# Supercharge Your Python Apps with Rust

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:

```sh
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`](http://lib.rs) file and replace its contents with the following code, which defines a simple function to add two numbers:

```rust
#[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:

```toml
[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:

```sh
cargo build --release
```

After the build completes, you'll find the dynamic library in `target/release` (e.g., `librust_`[`library.so`](http://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`](http://rust.py)) and write the following code:

```python
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:

```sh
python call_rust.py
```

You should see the output:

```xml
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](https://github.com/theArjun/learning-rust/tree/main/rust_adder)