feat: support stream

Cargo.toml

@@ -1,6 +1,6 @@
 [workspace]
 resolver = "2"
-members = ["crates/mlx-sys", "crates/mlx"]
+members = ["crates/mlxcore-sys", "crates/mlxcore"]
 
 [workspace.package]
 edition = "2024"
@@ -9,4 +9,4 @@ repository = "https://github.com/InftyAI/mlx"
 authors = ["kerthcet"]
 
 [workspace.dependencies]
-mlx-sys = { path = "crates/mlx-sys", version = "0.0.0" }
+mlxcore-sys = { path = "crates/mlxcore-sys", version = "0.0.0" }

README.md

@@ -9,10 +9,10 @@ Rust bindings for Apple's [MLX](https://github.com/ml-explore/mlx) framework.
 The bindings are layered, the same way as [MLX Swift](https://github.com/ml-explore/mlx-swift):
 
 ```
-mlx      (safe, idiomatic Rust API)   <- crates/mlx
-mlx-sys  (raw unsafe FFI bindings)    <- crates/mlx-sys, generated by bindgen
-mlx-c    (Apple's C API for MLX)      <- third_party/mlx-c (git submodule)
-mlx      (Apple's C++ framework)      <- fetched by mlx-c's CMake build
+mlxcore      (safe, idiomatic Rust API)   <- crates/mlxcore
+mlxcore-sys  (raw unsafe FFI bindings)    <- crates/mlxcore-sys, generated by bindgen
+mlx-c     (Apple's C API for MLX)      <- third_party/mlx-c (git submodule)
+mlx       (Apple's C++ framework)      <- fetched by mlx-c's CMake build
 ```
 
 MLX itself is C++, which Rust cannot bind to directly. We bind against
@@ -32,7 +32,7 @@ The first build compiles MLX from source and takes several minutes.
 
 ## Examples
 
-Runnable examples live in `crates/mlx/examples`:
+Runnable examples live in `crates/mlxcore/examples`:
 
 ```sh
 cargo run --example hello

crates/mlx-sys/Cargo.toml → crates/mlxcore-sys/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
-name = "mlx-sys"
+name = "mlxcore-sys"
 version = "0.0.0"
 # Edition 2021: bindgen 0.70 emits plain `extern "C"` blocks, which edition
-# 2024 rejects (it requires `unsafe extern`). The safe `mlx` crate stays 2024.
+# 2024 rejects (it requires `unsafe extern`). The safe `mlxcore` crate stays 2024.
 edition = "2021"
 license.workspace = true
 repository.workspace = true

crates/mlx-sys/build.rs → crates/mlxcore-sys/build.rs

@@ -1,4 +1,4 @@
-//! Build script for `mlx-sys`.
+//! Build script for `mlxcore-sys`.
 //!
 //! 1. Builds the vendored `mlx-c` C API with CMake. `mlx-c` uses CMake
 //!    `FetchContent` to download and build MLX itself, so both `libmlxc` and
@@ -13,11 +13,11 @@ use std::path::PathBuf;
 
 fn main() {
     if !cfg!(target_os = "macos") {
-        panic!("mlx-sys currently only supports macOS on Apple Silicon");
+        panic!("mlxcore-sys currently only supports macOS on Apple Silicon");
     }
 
     let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
-    // Workspace layout: <root>/crates/mlx-sys -> <root>/third_party/mlx-c
+    // Workspace layout: <root>/crates/mlxcore-sys -> <root>/third_party/mlx-c
     let mlx_c_dir = manifest_dir
         .join("../../third_party/mlx-c")
         .canonicalize()
@@ -39,12 +39,12 @@ fn main() {
     }
 
     // Build into a fixed dir under `target/<profile>/` rather than the default
-    // per-fingerprint `OUT_DIR`. `cargo clippy` fingerprints `mlx-sys`
+    // per-fingerprint `OUT_DIR`. `cargo clippy` fingerprints `mlxcore-sys`
     // differently from `cargo build`/`cargo test`, so an `OUT_DIR`-based build
     // would recompile MLX from scratch for each (~2.5 min of C++). A shared dir
     // lets them all reuse the same CMake build.
     //
-    // OUT_DIR = <target>/<profile>/build/mlx-sys-<hash>/out; three parents up is
+    // OUT_DIR = <target>/<profile>/build/mlxcore-sys-<hash>/out; three parents up is
     // <target>/<profile>.
     let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
     let profile_dir = out_dir

crates/mlx-sys/src/lib.rs → crates/mlxcore-sys/src/lib.rs

@@ -3,7 +3,7 @@
 //!
 //! These bindings are generated at build time by `bindgen` from the pinned
 //! `third_party/mlx-c` submodule. This crate is not meant to be used directly;
-//! prefer the safe `mlx` crate that wraps it.
+//! prefer the safe `mlxcore` crate that wraps it.
 #![allow(non_upper_case_globals)]
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]

crates/mlx/Cargo.toml → crates/mlxcore/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "mlx"
+name = "mlxcore"
 version = "0.0.0"
 edition.workspace = true
 license.workspace = true
@@ -9,8 +9,8 @@ description = "Safe, idiomatic Rust bindings for Apple's MLX array framework."
 
 [features]
 default = ["metal", "accelerate"]
-metal = ["mlx-sys/metal"]
-accelerate = ["mlx-sys/accelerate"]
+metal = ["mlxcore-sys/metal"]
+accelerate = ["mlxcore-sys/accelerate"]
 
 [dependencies]
-mlx-sys.workspace = true
+mlxcore-sys.workspace = true

crates/mlxcore/examples/hello.rs

@@ -0,0 +1,34 @@
+//! A minimal MLX example.
+//!
+//! Run with:
+//! ```sh
+//! cargo run --example hello
+//! ```
+
+use mlxcore::{Array, Stream};
+
+fn main() -> mlxcore::Result<()> {
+    println!("MLX version: {}", mlxcore::version());
+
+    let a = Array::from_slice(&[1.0f32, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3]);
+    println!("shape: {:?}", a.shape());
+    println!("size:  {}", a.size());
+    println!("ndim:  {}", a.ndim());
+    println!("array:\n{a:?}");
+
+    let b = Array::from_slice(&[6.0f32, 5.0, 4.0, 3.0, 2.0, 1.0], &[2, 3]);
+
+    // Operators use the default stream and panic on error.
+    println!("a + b:\n{:?}", &a + &b);
+
+    // Or steer the default onto a specific device once, up front.
+    Stream::cpu().set_as_default();
+    let total = a.sum(false, &Stream::default())?;
+    println!("sum(a) on CPU: {}", total.item::<f32>());
+
+    // Explicit stream control is still available per-op; `?` propagates errors.
+    let product = a.multiply(&b, &Stream::gpu())?;
+    println!("a * b (GPU):\n{product:?}");
+
+    Ok(())
+}