micromanager-rs

A pure-Rust port of MicroManager (mmCoreAndDevices). No C FFI, no Java bindings — Rust API only.

The port is based on https://github.com/micro-manager/mmCoreAndDevices, hash 67fe60267bc8d95554369d7fa42912775588e538

The license follows from the original code. To simplify Rust integration, the core code will be replaced, and also made to be less monolithic while at it.

Structure

claude-micromanager/
├── mm-device/          # Trait definitions (replaces MMDevice/)
├── mm-core/            # Engine: device manager, config, circular buffer (replaces MMCore/)
└── adapters/           # Hardware adapters, one crate per device family

mm-device

Defines the core abstractions:

• Traits — Device, Camera, Stage, XYStage, Shutter, StateDevice, VolumetricPump, Hub, and more
• PropertyMap — typed property storage with allowed-value constraints
• Transport — serial communication abstraction (send_recv, send_bytes, receive_bytes) + MockTransport for unit tests
• Error types, PropertyValue, DeviceType, FocusDirection

Demo

mm-demo is a live-preview app that uses CMMCore with the simulated DemoCamera. It opens a window and continuously snaps frames at ~30 fps.

cargo run -p mm-demo

The demo shows the minimal setup needed to drive a camera through the Rust API:

let mut core = CMMCore::new();
core.register_adapter(Box::new(DemoAdapter));
core.load_device("Camera", "demo", "DCamera").unwrap();
core.initialize_device("Camera").unwrap();
core.set_camera_device("Camera").unwrap();
core.set_exposure(25.0).unwrap();

core.snap_image().unwrap();
let frame = core.get_image().unwrap();
// frame.data is &[u8] (GRAY8), frame.width / frame.height are pixel dimensions

The window renders GRAY8 pixels as RGB and closes on Esc.

mm-core

The CMMCore engine:

• DeviceManager — load/unload/dispatch to typed device handles
• AdapterRegistry — static registration via the inventory crate
• CircularBuffer — fixed-size ring buffer for image sequence acquisition
• Config / config-file load/save

Adapters

W = Windows, M = macOS, L = Linux. SDK-wrapped adapters are feature-gated; all others are pure serial with no vendor dependencies.

Implemented (113 crates)

Pending — vendor SDK required

These adapters need proprietary SDKs or closed hardware interfaces not available as pure serial. Contributions welcome if you have access to the SDK.

Building

cargo build --workspace

Testing

cargo test --workspace

All adapters have unit tests that run against a MockTransport — no hardware required.

Adding an Adapter

1. Create adapters/mm-adapter-<name>/ with a Cargo.toml depending on mm-device.
2. Implement Device (and the appropriate device-type trait) for your struct.
3. Embed a PropertyMap and Option<Box<dyn Transport>>.
4. Add the crate to the workspace Cargo.toml.
5. Write tests using MockTransport.

Minimal example (Cargo.toml):

[package]
name = "mm-adapter-mydevice"
version = "0.1.0"
edition = "2021"

[dependencies]
mm-device = { path = "../../mm-device" }

Minimal struct pattern:

use mm_device::{error::MmResult, property::PropertyMap, traits::Device,
                transport::Transport, types::{DeviceType, PropertyValue}};

pub struct MyDevice {
    props: PropertyMap,
    transport: Option<Box<dyn Transport>>,
}

impl MyDevice {
    pub fn new() -> Self { /* define properties */ todo!() }
    pub fn with_transport(mut self, t: Box<dyn Transport>) -> Self {
        self.transport = Some(t); self
    }
}

impl Device for MyDevice {
    fn name(&self) -> &str { "MyDevice" }
    fn description(&self) -> &str { "My serial device" }
    fn initialize(&mut self) -> MmResult<()> { todo!() }
    fn shutdown(&mut self) -> MmResult<()> { Ok(()) }
    fn get_property(&self, name: &str) -> MmResult<PropertyValue> { self.props.get(name).cloned() }
    fn set_property(&mut self, name: &str, val: PropertyValue) -> MmResult<()> { self.props.set(name, val) }
    fn property_names(&self) -> Vec<String> { self.props.property_names().to_vec() }
    fn has_property(&self, name: &str) -> bool { self.props.has_property(name) }
    fn is_property_read_only(&self, name: &str) -> bool { false }
    fn device_type(&self) -> DeviceType { DeviceType::Generic }
    fn busy(&self) -> bool { false }
}