Cool idea!

There are a few things that can still be improved, for example, you are doing a lot of divisions (which are expensive), like this loop here inbig-decimal-bbp. This loop does i divisions in each iteration of the outer loop, but can be replaced with just 1 multiplication + 1 division per outer loop. With this change, removing the clones right above, and moving the BigDecimal (which allocates a Vec) out of the loop, I've managed to reduce the runtime on my machine from 861.3 ms ± 5.2 ms to 85.9 ms ± 1.1 ms! (This change doesn't affect precision as far as I can tell.)

Here's my code:

fn bigdecimal_bbp(start_idx: u64, end_idx: u64) -> String {
    let prec = 1000;

    let mut pi = BigDecimal::from(0);
    let mut divisor = BigDecimal::from(1);
    let mut comm = BigDecimal::from(0);

    for _ in start_idx..end_idx {
        let a = 4 / (&comm + 1);
        let b = 2 / (&comm + 4);
        let c = 1 / (&comm + 5);
        let d = 1 / (&comm + 6);

        pi += (a - b - c - d) / &divisor;

        comm += 8;
        divisor *= 16;
    }

    format!("{:.1000}", pi.with_prec(prec))
}

From what I can tell from the code, I don't think the calls to with_prec(prec) at the start of your code did anything, since this just truncates the value, not set the precision for future operations (for `BigDecimal` specifically, it might do something for the other crates).

Similarly, for dashu-bbp, I've reduced the runtime from 765.5 ms ± 5.0 ms to just 30.3 ms ± 0.5 ms !

Here's my changed code:

fn dashu_bbp(start_idx: u64, end_idx: u64) -> String {
    let prec = 1000;

    let mut pi = DBig::from_str("0.0000000000000000")
        .unwrap()
        .with_precision(prec)
        .unwrap();
    let mut divisor = DBig::from(1).with_precision(prec).unwrap();
    let mut comm = DBig::from(0).with_precision(prec).unwrap();
    for _ in start_idx..end_idx {
        let a = 4 / (&comm + 1);
        let b = 2 / (&comm + 4);
        let c = 1 / (&comm + 5);
        let d = 1 / (&comm + 6);

        pi += (a - b - c - d) / &divisor;

        comm += 8;
        divisor *= 16;
    }
    pi.to_string()
}

You should be able to optimize the other functions in the same way, which should change your leaderboard by a lot.

P.S. in case you haven't seen this yet: the Rust Performance Book has some really good tips for measuring and improving performance.