This document discusses auto-generating language-specific wrappers for Rust libraries. It describes how common libraries use wrapper layers to relay function calls and convert parameters between languages. It then provides more details on Uniffi, an open-source project that automatically generates foreign language bindings for Rust libraries. Uniffi consolidates business logic into a portable Rust library and builds wrappers for languages like Kotlin, Swift, Python and C++. It works by having developers create a Rust library and UDL representation of its API, then Uniffi generates scaffolding and language-specific implementation layers to interface with the library from other languages.

1. Auto-Generating Language-Specific
Wrappers for Rust Libraries
Steve McCown
22 April 2021

2. Common Libraries with Language Wrappers
Common Library (e.g., Rust)
Swift Python Java C/C++
Swift
App
Python
App
Java
App
C/C++
App
Wrapper Layer
• Relay function calls
• Convert parameters
• Memory management
• ‘UnsafeMutablePointer’

3. App: Calling from C to a Rust Library
Library function prototype
(normally in .h file)
Call into library

4. Create Cargo.toml for Building a Library
Wrapper
Library

5. Create a Rust Library / Wrapper
Function &
parameters
conform to C
Conversions:
unsafe & necessary
Convert to usable
Rust types
Finally!

6. Rust Library Testing - More Complex
Convert to
a C String
Get a
pointer

7. Uniffi by Mozilla
• Automatically generates foreign-
language bindings for Rust libraries
• Consolidates business logic into a
portable library
• Builds wrappers for
• Kotlin
• Swift
• Python
• C++
• https://github.com/mozilla/uniffi-rs

8. Uniffi: How it works
1. Create custom Rust library
• Expose API functions (all top-level)
• Build crate as linkable library (in Cargo.toml; static or dynamic)
2. Create a UDL representation of API functions
• Similar to Interface Definition Language (IDL)
3. Create a “Scaffolding” layer
• Helper code to make foreign-language bindings (calls, memory conversions, etc.)
4. Create language-specific implementation layer
• Makes FFI calls look & feel like native code (e.g., Swift FFI feels like native Swift)
5. Import generated code & library into native application

9. Create Rust Library
Cargo.toml
lib.rs
Snake
Case

10. Create UDL for API Functions
library.uniffi.udl
Functions, structures, errors,
enums, etc. are defined in
an independent format

11. Generate Scaffolding Layer
(for more details, see: library.uniffi.uniffi.rs)
Run this
To generate this

12. Generate a Swift Interface
Run this
Generate
library.swift
Camel Case

13. Run this
Generate Python Interface
Generate
library.py

14. MacOS Swift App
Add
Add
Add
Call the library
function

15. Python Test App
Add
Call the library
function

17. Expanded UDL File
Uniffi supports the main data types, errors,
structures, etc.

18. Tutorial and Source Code
https://github.com/sudoplatform-labs/ffi-tutorials

19. Questions?
Tutorial and code repo:
https://github.com/sudoplatform-labs/ffi-tutorials