StickUp

🚀 Update: v0.2.1 is here!
StickUp v0.2.1 adds per-frame input snapshots, intuitive binding resolution ("joy0.axis1"), and cleaner device control with DeviceManager.
Built to scale with sim rigs, overlays, game engines, and beyond.

📈 Already over 1,000 downloads in under 48 hours — huge thanks to everyone testing, sharing, and supporting the launch!

🎮 What is StickUp?

StickUp is a modular, high-performance input framework for Rust.
It supports both real HID devices and virtual inputs with clarity, precision, and stability.

Part of the CelerisTech stack by Belegrade Studio

🔐 Security Note

The name stickup was previously used in 2023 for a malicious crate that has since been removed from crates.io.

This version — authored by Belegrade Studio — is a clean and fully rewritten project, unrelated to the original.

✅ No build.rs
✅ No network activity
✅ 100% open and auditable

Transparency matters. Feel free to inspect the source or reach out directly.

✨ Features

• 🔌 Plug-and-play device management via DeviceManager
• 🎮 Unified Device trait for axis + button input
• 🧠 Persistent device identity (hardware fingerprinting)
• 🧰 Binding resolution like "joy0.axis1" → Option<f32>
• 🔁 Snapshot-based polling and input state tracking
• 🔧 Hotplug-friendly and fully extendable
• 🛠 Supports hid and virtual backends via optional features
• 💡 Zero magic — minimal, intentional design

🧭 Philosophy

StickUp is about presence, clarity, and persistence.
It doesn’t guess. It doesn’t simulate. It reflects exactly what your device is doing — no more, no less.

📦 Installation

stickup = { version = "0.2.1", features = ["hid", "virtual"] }

use stickup::DeviceManager;

fn main() {
    let mut input = DeviceManager::new();
    input.snapshot(); // poll + build snapshot

    if let Some(throttle) = input.get_axis("joy0.throttle") {
        println!("Throttle: {:.2}", throttle);
    }

    if input.is_pressed("joy1.trigger") {
        println!("Trigger is pressed!");
    }

    // Full snapshot usage
    let state = input.snapshot();

    for (id, device_state) in state.iter() {
        println!("Device: {id}");

        for (axis, value) in &device_state.axes {
            println!("  Axis {axis}: {value:.2}");
        }

        for (button, pressed) in &device_state.buttons {
            println!("  Button {button}: {}", if *pressed { "Pressed" } else { "Released" });
        }
    }
}

🧬 Device Identity

StickUp assigns a stable, persistent ID to each device:

vendor_id:product_id:serial_number
# Example: 044f:0402:ABCD1234

This allows for consistent bindings across reboots and USB port changes.

🔍 Examples

Run any with:

cargo run --example <name>

• poll – Print a full snapshot of all input state
• virtual_demo – Feed input into a simulated virtual device

🛠️ Optional Features

🔮 Coming Next: Event Listeners

StickUp currently uses snapshot-based polling for simplicity and determinism.

Next release will introduce event listener support:
Low-latency, per-device events that let you respond to input as it happens — perfect for overlays, sim triggers, and reactive UIs.

Example:

device.add_listener(Arc::new(MyEventHandler));

This will coexist with polling — giving you full control and flexibility.

📜 License

This project is licensed under the Pact of the Amaranth Rite.
See LICENSE for details.

Third-Party Dependencies

• hidapi — MIT/Apache-2.0 (HID support)
• serde — MIT/Apache-2.0 (serialization)
• serde_json — MIT/Apache-2.0 (layout/config IO)
• toml — MIT/Apache-2.0 (if config parsing used)

💬 Connect

• ✉️ Email: belegrade@belegrades.gg
• 💬 Discord: Join the Chat
• 🎮 Sim pilots & devs: I’d love to hear how you’re using StickUp.