jffi-0.1.3 is not a library.

JFFI

A cross-platform framework for building native applications with Rust business logic and platform-native UIs.

Philosophy

Write your business logic once in Rust. Build native UIs for each platform.

Write business logic once in Rust
Use native UI frameworks (SwiftUI, Jetpack Compose, WinUI, etc.)
Get truly native performance and platform feel
Maintain type safety end-to-end via UniFFI

Quick Start

Installation

# Install JFFI CLI
cargo install --path cli

Create Your First App

# Create a new app with platform support
jffi new my-app --platforms ios,macos,android,linux,windows

# Navigate and run
cd my-app
jffi run --platform ios      # iOS Simulator
jffi run --platform macos    # macOS app
jffi run --platform android  # Android Emulator
jffi run --platform linux    # Linux GTK app
jffi run --platform windows  # Windows app
# jffi run --platform web    # Web browser (🚧 In Progress)

That's it! The app builds, compiles Rust, generates platform bindings, and launches automatically.

Note: Web platform support is currently in progress. The frontend templates are created but the ffi-web integration is incomplete.

📱 Supported Platforms

Platform	Status	UI Framework	Language
iOS	✅ Ready	SwiftUI	Swift
macOS	✅ Ready	SwiftUI	Swift
Android	✅ Ready	Jetpack Compose	Kotlin
Linux	✅ Ready	GTK 4 + Libadwaita	Python
Web	🚧 In Progress	Vanilla JS + WASM	JavaScript
Windows	✅ Ready	WinUI 3	C#

🏗️ Project Structure

my-app/
├── core/                    # Pure Rust business logic
│   ├── src/lib.rs          # Your app logic here
│   └── Cargo.toml
│
├── ffi/                     # FFI layer (auto-scaffolded)
│   ├── src/lib.rs          # UniFFI exports
│   └── Cargo.toml
│
├── platforms/
│   └── ios/                # iOS SwiftUI app
│       ├── *App.swift
│       ├── AppState.swift
│       ├── ContentView.swift
│       └── *.xcodeproj     # Auto-generated
│
└── jffi.toml               # Framework configuration

Development Workflow

1. Write Business Logic (Once)

core/src/lib.rs:

pub struct App {
    items: Vec<Item>,
}

impl App {
    pub fn add_item(&mut self, id: String, title: String) {
        self.items.push(Item { id, title, completed: false });
    }
}

2. Expose via FFI (Auto-scaffolded)

ffi/src/lib.rs:

#[derive(uniffi::Object)]
pub struct FfiApp {
    app: Mutex<App>,
}

#[uniffi::export]
impl FfiApp {
    pub fn add_item(&self, id: String, title: String) -> Vec<ItemViewModel> {
        let mut app = self.app.lock().unwrap();
        app.add_item(id, title);
        app.get_items().iter().map(ItemViewModel::from).collect()
    }
}

3. Build & Run

For iOS:

jffi run --platform ios              # Simulator
jffi run --platform ios --device     # Physical device

For Android:

jffi run --platform android          # Emulator (auto-starts)

For macOS:

jffi run --platform macos

For Linux:

jffi run --platform linux

For Web:

jffi run --platform web

For Windows:

jffi run --platform windows

This automatically:

iOS/macOS: Compiles Rust, generates Swift bindings, creates Xcode project, builds and launches
Android: Compiles Rust for 3 architectures, generates Kotlin bindings, starts emulator, builds APK, installs and launches app
Linux: Compiles Rust, generates Python bindings, installs dependencies (GTK 4, build tools), builds and launches GTK app
Web: Compiles Rust to WASM, generates JavaScript bindings, installs npm dependencies, starts Vite dev server
Windows: Compiles Rust, generates C# bindings with uniffi-bindgen-cs, builds with MSBuild/dotnet, launches WinUI 3 app

4. Use in Native UI

platforms/ios/ContentView.swift:

Button("Add Item") {
    appState.addItem(id: UUID().uuidString, title: newItem)
}

The generated bindings make Rust functions available in Swift!

⚡ Hot Reload

JFFI works seamlessly with native IDE hot reload plus automatic Rust rebuilding.

iOS/macOS Workflow

# Start Rust file watcher
jffi dev --platform ios

# In Xcode:
# 1. Open platforms/ios/*.xcodeproj in Xcode
# 2. Run the app (Cmd+R)
# 3. Edit Swift files → Xcode hot reloads automatically ⚡
# 4. Edit Rust files → Watcher rebuilds dylib → Press Cmd+B in Xcode

Android Workflow

# Start Rust file watcher + Android Studio
jffi dev --platform android

# In Android Studio:
# 1. Press ▶️ to run the app
# 2. Edit Kotlin files → Compose hot reloads automatically ⚡
# 3. Edit Rust files → Watcher rebuilds .so → Rebuild in Android Studio

Linux Workflow

# Start Rust file watcher
jffi dev --platform linux

# The app will auto-restart when Rust code changes
# 1. Edit Python/GTK files → Save and re-run
# 2. Edit Rust files → Watcher rebuilds .so → App auto-restarts ⚡

Web Workflow

# Start Rust file watcher + Vite dev server
jffi dev --platform web

# Vite provides hot reload for JS/CSS changes
# 1. Edit HTML/JS/CSS → Vite hot reloads instantly ⚡
# 2. Edit Rust files → Watcher rebuilds WASM → Refresh browser

How It Works

Native UI Changes:

iOS/macOS: Edit .swift files → Xcode hot reloads instantly
Android: Edit .kt files → Compose hot reloads automatically
Web: Edit .js/.css files → Vite hot reloads instantly
Use native IDE features (SwiftUI previews, Compose previews, etc.)
Full debugging support

Rust Changes:

Edit any .rs file in core/ or ffi/
File watcher rebuilds Rust library automatically
Rebuild in native IDE to use new Rust code
App updates with new business logic

Best of Both Worlds

✅ Native IDE experience - Use all platform IDE features ✅ Native UI previews - SwiftUI/Compose previews work ✅ Native hot reload - Instant UI updates ✅ Rust auto-rebuild - No manual cargo commands ✅ Full debugging - Native debuggers work normally

CLI Commands

# Create new project
jffi new <name> --platforms <platforms>

# Build for platform
jffi build --platform <platform>
jffi build --platform ios --device          # Build for physical device

# Run on platform (builds automatically)
jffi run --platform <platform>
jffi run --platform ios --device            # Run on physical device

# Development mode (auto-rebuild on changes)
jffi dev --platform <platform>

# Add platform to existing project
jffi add <platform>

# List available platforms
jffi platforms

How It Works

┌─────────────────────────────────────────┐
│     Your Rust Business Logic           │
│     (core/src/lib.rs)                   │
└─────────────────────────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│     UniFFI FFI Layer                    │
│     (ffi/src/lib.rs)                    │
└─────────────────────────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│     Auto-Generated Bindings             │
│     (Swift, Kotlin, C#, etc.)           │
└─────────────────────────────────────────┘
                  ↓
┌─────────────────────────────────────────┐
│     Native Platform UI                  │
│     (SwiftUI, Compose, WinUI, etc.)     │
└─────────────────────────────────────────┘

Configuration

jffi.toml:

[package]
name = "my-app"
version = "0.1.0"

[platforms]
enabled = ["ios"]

[platforms.ios]
deployment_target = "16.0"
bundle_id = "com.example.myapp"

Why JFFI?

Feature	JFFI	Flutter	React Native
Business Logic	Rust	Dart	JavaScript
UI	Native	Cross-platform	Near-native
Performance	Native	Good	Good
Platform Feel	Native	Consistent	Near-native
Type Safety	End-to-end	Strong	Weak

Use JFFI when:

You want truly native UI and performance
You have platform-specific design requirements
You want to leverage native UI libraries
You need Rust for business logic (performance, safety)

🛠️ Development

Prerequisites

Rust toolchain
iOS: Xcode, iOS Simulator
Android: Android Studio, Android SDK, Android Emulator (auto-configured)
macOS: Xcode
Linux: GTK 4, Libadwaita, Python 3 (auto-installed by setup script)
Web: Node.js, npm (for Vite dev server)
Windows: .NET SDK 8.0+, Visual Studio Build Tools or MSBuild

Building the CLI

cargo build --package jffi
cargo run --package jffi -- --help

Roadmap

CLI tool foundation
iOS support with SwiftUI
macOS support with SwiftUI
Android support with Jetpack Compose
Linux support with GTK 4 + Python
Web support with Vanilla JS + WASM (frontend templates created, ffi-web integration incomplete)
Windows support with WinUI 3 + C#
Automatic Xcode project generation
Automatic Android project generation
One-command build and run (iOS, macOS, Android, Linux, Windows)
Hot reload for iOS (Xcode-native workflow)
Hot reload for Android (Android Studio-native workflow)
Hot reload for Linux (auto-restart workflow)
Hot reload for Web (Vite hot reload - pending ffi-web completion)
Automatic emulator/simulator management
Auto-install build dependencies (targets, NDK, GTK, WASM, wasm-bindgen, uniffi-bindgen-cs, etc.)

🤝 Contributing

Early-stage framework. Contributions welcome!

High priority:

Complete web platform support (create ffi-web crate with wasm-bindgen integration)
Additional platform features and improvements
State persistence (SQLite/local storage)
Advanced UI components and patterns
Hot reload for Windows (file watcher workflow)

📄 License

MIT

Acknowledgments

UniFFI - FFI bindings generator
The Rust community

Built with and Rust

jffi 0.1.3

JFFI

Philosophy

Quick Start

Installation

Create Your First App

📱 Supported Platforms

🏗️ Project Structure

Development Workflow

1. Write Business Logic (Once)

2. Expose via FFI (Auto-scaffolded)

3. Build & Run

4. Use in Native UI

⚡ Hot Reload

iOS/macOS Workflow

Android Workflow

Linux Workflow

Web Workflow

How It Works

Best of Both Worlds

CLI Commands

How It Works

Configuration

Why JFFI?

🛠️ Development

Prerequisites

Building the CLI

Roadmap

🤝 Contributing

📄 License

Acknowledgments