Crate presenceforge 

PresenceForge

A cross-platform Rust library for Discord Rich Presence (IPC) integration.

Supports both Unix-like systems (Linux, macOS) using Unix domain sockets and Windows using named pipes.

Features

• Synchronous and asynchronous API
• Unified async API - Write once, run on any async runtime
• Runtime-agnostic async design (supports tokio, async-std, and smol)
• Activity builder pattern
• Cross-platform support (Linux, macOS, Windows)

Synchronous Example

use presenceforge::ActivityBuilder;
use presenceforge::sync::DiscordIpcClient;
let mut client = DiscordIpcClient::new("your_client_id")?;
client.connect()?;

let activity = ActivityBuilder::new()
    .state("Playing a game")
    .details("In the menu")
    .start_timestamp_now()?
    .large_image("game_logo")
    .large_text("My Awesome Game")
    .build();

client.set_activity(&activity)?;

// Keep the activity for some time...
std::thread::sleep(std::time::Duration::from_secs(10));

client.clear_activity()?;

Unified Async API

The library provides a single AsyncDiscordIpcClient type that automatically adapts to your chosen async runtime through feature flags. No need for runtime-specific imports!

With Tokio

Enable the tokio-runtime feature in your Cargo.toml:

[dependencies]
presenceforge = { version = "0.1.0", features = ["tokio-runtime"] }
tokio = { version = "1", features = ["rt-multi-thread", "macros"] }

use presenceforge::{AsyncDiscordIpcClient, ActivityBuilder, Result};

async fn main() -> Result {
    let mut client = AsyncDiscordIpcClient::new("your_client_id").await?;
    client.connect().await?;

    let activity = ActivityBuilder::new()
        .state("Playing a game")
        .details("In the menu")
        .start_timestamp_now()?
        .large_image("game_logo")
        .large_text("My Awesome Game")
        .build();

    client.set_activity(&activity).await?;
    Ok(())
}

With async-std

Enable the async-std-runtime feature:

[dependencies]
presenceforge = { version = "0.1.0", features = ["async-std-runtime"] }
async-std = { version = "1", features = ["attributes"] }

use presenceforge::{AsyncDiscordIpcClient, ActivityBuilder, Result};

async fn main() -> Result {
    let mut client = AsyncDiscordIpcClient::new("your_client_id").await?;
    client.connect().await?;

    let activity = ActivityBuilder::new()
        .state("Playing a game")
        .details("In the menu")
        .start_timestamp_now()?
        .large_image("game_logo")
        .large_text("My Awesome Game")
        .build();

    client.set_activity(&activity).await?;
    Ok(())
}

With smol

Enable the smol-runtime feature:

[dependencies]
presenceforge = { version = "0.1.0", features = ["smol-runtime"] }
smol = "2"

use presenceforge::{AsyncDiscordIpcClient, ActivityBuilder, Result};

fn main() -> Result {
    smol::block_on(async {
        let mut client = AsyncDiscordIpcClient::new("your_client_id").await?;
        client.connect().await?;

        let activity = ActivityBuilder::new()
            .state("Playing a game")
            .details("In the menu")
            .start_timestamp_now()?
            .large_image("game_logo")
            .large_text("My Awesome Game")
            .build();

        client.set_activity(&activity).await?;
        smol::Timer::after(std::time::Duration::from_secs(10)).await;
        client.clear_activity().await?;
        Ok(())
    })
}

Runtime-Specific APIs (Advanced)

For advanced use cases, you can still import runtime-specific clients directly:

// Tokio-specific client
use presenceforge::async_io::tokio::TokioDiscordIpcClient;

// async-std-specific client
use presenceforge::async_io::async_std::AsyncStdDiscordIpcClient;

// smol-specific client
use presenceforge::async_io::smol::SmolDiscordIpcClient;

Re-exports

pub use activity::ActivitySecrets;

pub use activity::Activity;

pub use activity::ActivityAssets;

pub use activity::ActivityBuilder;

pub use activity::ActivityButton;

pub use activity::ActivityParty;

pub use activity::ActivityTimestamps;

pub use error::DiscordIpcError;

pub use error::ProtocolContext;

pub use error::Result;

pub use ipc::protocol::IpcConfig;

pub use ipc::Command;

pub use ipc::DiscoveredPipe;

pub use ipc::IpcConnection;

pub use ipc::Opcode;

pub use ipc::PipeConfig;

pub use macros::is_debug_enabled;

pub use sync::client::DiscordIpcClient;

pub use async_io::tokio::TokioDiscordIpcClient as AsyncDiscordIpcClient;

Modules

activity

async_io

Async implementation of Discord Rich Presence client

error

ipc

macros

nonce

retry

Connection retry utilities

sync

Synchronous implementation of Discord Rich Presence client

Macros

debug_println

Macro for conditional debug printing