Any Rustaceans out there?

[johnallen3d]

Hello fellow SketchyBar enthusiasts! For a while now I've been playing around with the idea of writing Rust plugins for SketchyBar. This is almost entirely an excuse to practice and write more Rust code. I haven't ever noticed a plugin that was consuming a high number of resources or was particularly slow.

Initially I was playing around with the idea of integrating SketchyBar directly into a custom crate. For example I created a weather CLI tool for the purposes of integrating with SketchyBar. The initial integration still used a Bash script that called the CLI tool, parsed the results and updated SketchyBar. Then I played around with making a Rust library that wrapped the SketchyBarHelper. Well first, I tried reproducing SketchyBarHelper in pure Rust, but I totally flopped on that effort!

Ultimately I was able to integrate my helper library into the conditions binary so that my Rust code was directly updating SketchyBar. This worked and cut out the need to parse output from the CLI command, however a couple of things were still bothering me.

1. I was still using a Bash script to call the Rust binary
2. SketchyBar widgets are highly customizable and I couldn't see a clean way to integrate that into a Rust library

Enter cargo-script. This is a tool that allows you to write Rust scripts that can be run directly from the command line. It also allows you to specify dependencies in the script itself. This is perfect for SketchyBar! I can write a Rust script that calls my library and have it update SketchyBar directly. This script is automatically compiled into a binary after each change to the script and that binary is cached (~/.cargo/target/).

---

Here's an example, using the before mentioned conditions crate:

#!/usr/bin/env -S cargo +nightly --quiet -Zscript
---cargo
[dependencies]
conditions = "0.3.0"
sketchybar-rs = "0.2.0"
tokio = { version = "1.33", features = ["macros"] }
---

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let config = conditions::Config::load().unwrap();
    let cache_path = conditions::Config::cache_path().unwrap();
    let mut cache = conditions::Cache::new(Some(cache_path)).await.unwrap();

    let conditions = conditions::Conditions::new(config, None)
        .fetch(&mut cache)
        .await
        .unwrap();

    let message = format!(
        "--set weather_logo icon=\"{}\" --set weather label=\"{}°F\"",
        conditions.icon, conditions.temp
    );

    sketchybar_rs::message(&message, Some("sketchybar")).unwrap();
}

NOTE: The font-matter in the script should be denoted with fence blocks (```) but I couldn't get it to render correctly in the post so I used hyphens (---).

---

For completeness, here is my weather specific SketchyBar configuration

sketchybar \
	--add item weather right \
	--set weather \
	update_freq=1800 \
	icon.drawing=off \
	script="~/.config/sketchybar/plugins/weather" \
	background.color=$transparent_color

sketchybar \
	--add item weather_logo right \
	--set weather_logo icon= \
	icon.font="Hack Nerd Font:Regular:14.0" \
	icon.color=$current_app_color \
	label.drawing=off \
	background.color=$weather_highlight

which results in this:

---

Hopefully there are other Rustaceans out there who will find this useful or roast me on my implementation! 😂

[johnallen3d]

I also have a plugin for mpd. This one is rendered in a secondary bar (for me symlinked as bottombar) so incorporates that in the script/helper.

[FelixKratz]

I have played with direct both-way communication here as well: https://github.com/FelixKratz/SbarLua
The helper is able to register itself as a mach_helper for any item, such that the events are transmitted directly to the helper binary, without calling a script or launching an executable. This is the most optimal both-way communication and allows also to define lua functions as event handlers, which are triggered not by a fork-exec chain but directly via a mach message sent from sketchybar to the lua helper process.

By utilizing this functionality we are able to circumvent the fork-exec overhead of spawing a new process. This is especially noticeable when switching spaces with disabled space change animations or other "reactive" operations, where the response latency drops by orders of magnitude and is faster than the screen refresh time and thus quasi-instantaneous.
Maybe something like this would also be possible using rust?

[johnallen3d]

Yes, it seems to me like this would be imminently possible in Rust as well as it has a strong C Interop. There's also a Mach crate (mach2) though, admittedly, my knowledge of the macOS API's are non-existent.

[johnallen3d]

Looking at your cpu example got me thinking. In my (most?) use cases I don't need two way communication. Take for example my mpd widget. I can just fire that up along side my bar and have it update my bar on whatever frequency I prefer. Just to prove this out, with the Lua API:

#!/usr/bin/env lua

-- Add the sketchybar module to the package cpath (the module could be
-- installed into the default search path then this would not be needed)
package.cpath = package.cpath
	.. ";/Users/"
	.. os.getenv("USER")
	.. "/.local/share/sketchybar_lua/?.so"

-- Require the sketchybar module
Sbar = require("sketchybar")

-- Specify which bar
Sbar.set_bar_name("bottombar")

-- Load the init.lua file
require("init")

Sbar.hotload(true)

-- Load helper scripts
os.execute("killall mpd-updater")
os.execute(os.getenv("HOME") .. "/.config/bottombar/plugins/mpd-updater &")

-- Run the event loop of the sketchybar module (without this there will be no
-- bi-directional communication between the lua module and sketchybar)
Sbar.event_loop()

and a simple loop in my Rust script:

#!/usr/bin/env -S cargo +nightly --quiet -Zscript -Zgc
---cargo
[dependencies]
mpd-easy = "0.1.5"
sketchybar-rs = "0.2.0"
---
use std::thread;
use std::time::Duration;


fn main() {
    let format = mpd_easy::OutputFormat::Json;
    let mut client = mpd_easy::Client::new("localhost", "6600", format).unwrap();

    loop {
        let status = client.status().unwrap();

        let mut label = String::new();

        let icon = match status.state {
            mpd_easy::State::Play => "".to_string(),
            mpd_easy::State::Pause => "".to_string(),
            mpd_easy::State::Stop => "".to_string(),
        };

        if status.state != mpd_easy::State::Stop {
            label = format!(
                "{} • {} • {} [{}/{}]",
                status.title,
                status.artist,
                status.album,
                status.elapsed,
                status.track_length,
            );
        }

        let message = format!("--set mpd icon=\"{icon}\" label=\"{label}\"");

        sketchybar_rs::message(&message, Some("bottombar")).unwrap();

        thread::sleep(Duration::from_secs(1));
    }
}

NOTE: The font-matter in the script should be denoted with fence blocks (```) but I couldn't get it to render correctly in the post so I used hyphens (---).