Releasing Rust SIMD binaries to GitHub, BioConda, and PyPI

Sun, 25 Jan 2026 00:00:00 +0100

Table of Contents

1 Testing
2 Releasing libraries
- 2.1 Changelog
- 2.2 cargo release
- 2.3 crates.io
3 Releasing binaries
- 3.1 Crates.io
- 3.2 The pain of AVX2
  - 3.2.1 ensure_simd
- 3.3 Profile selection
- 3.4 GitHub
- 3.5 cargo binstall
- 3.6 PyPI
- 3.7 Bioconda
4 Conclusion

This post collects the GitHub and BioConda CI configurations I use for maintaining and releasing Sassy. This includes releasing to:

crates.io (libraries, binaries)
GitHub releases
cargo binstall
PyPI
Bioconda

We also have some specific settings to ensure the distributed binaries use AVX2 SIMD instructions, as well as some configuration to distribute x86-64 binaries that transparently switch to a AVX-512 enabled implementation when possible. (TODO: Write on cargo-multivers for shipping AVX-512 compatible binaries.)

Intro to Rust

Tue, 16 Jan 2024 00:00:00 +0100

These are notes for a quick introduction to Rust.

Overview Link to heading

Statically typed & Compiled language.
Great developer experience:
- cargo build system
- rust-analyzer LSP

Rust features Link to heading

Basics Link to heading

C++	Rust
std::size_t	usize
std::pointerdiff_t	isize
int	i32
unsigned int	u32
long long	i64
unsigned long long	u64

string	String
string_view	&str
byte	u8
char	char

vector<T>	Vec<T>
array<int, 4>	[u32; 4]
int[]	&[u32]

T	T
const T&	&T
T&	&mut T
T*	unsafe { T* }
unique_ptr<T>	Box<T>

optional<T>	Option<T>
variant<T, E>	Result<T, E>

C++	Rust
for(int i = 0; i < n; ++i) {}	for i in 0..n {}
while(true) {}	loop {}
while(f()) {}	while f() {}
do { } while (f());	loop { if !f() { break; } }
switch x { case 1:; }	match x { 1 => {} }

C++	Rust
cout << “text” << endl;	println!(“text”);
cout << 1+1 << endl;	println!("{}", 1+1);
cout << n << endl;	println!("{n}");

Basic syntax Link to heading

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


// trailing return type
fn square(x: u32) -> u32 {
 // return on last line can be omitted
 x*x
}

// mutable reference
fn increment(x: &mut u32) {
 *x += 1;
}

fn main(){
 // Introduce variables with let.
 // Types are automatically inferred.
 let a = 1;
 // b is mutable.
 let mut b = 1;
 b += 1;
 // c, d, and e are usize:
 let c: usize = 1;
 let d = 1usize;
 let e = usize::MAX;

 // No parentheses needed.
 if a > b {
 // This shouldn't happen.
 panic!();
 }

 // 0..n is a `Range`.
 // Ranges are `IntoIterator` and converted into an iterator, which is looped over.
 for i in 0..n {
 // Print i to a line on stderr.
 eprintln!("{i}");
 }

 while b < 1000 {
 increment(b);
 }

 loop {
 b = square(b);
 if b > 1000000000 {
 break;
 }
 }

 // Pattern matching
 match 5 {
 0 => panic!(),
 1 => todo!(),
 2..3 => eprintln!("small"),
 x if x%2==0 => eprintln!("even {x}"),
 _ => eprintln!("odd");
 }
}

Expressions everywhere! Link to heading

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


let a = { 1 + 1 };
let b = if a > 10 { a } else { 10 };
let c = loop {
 break 3;
};
let d = {
 let mut x = 1;
 while x < 1000 {
 x *= 2;
 }
 x
};
let a = match Some(5) {
 None => 0,
 Some(x) => 2*x,
};

Closures Link to heading

1
2
3
4


let double = |x| 2*x;
let a = double(1);
let multiply = |x: usize, y: usize| -> usize { x * y };
let b = multiply(2, 3);

Pattern matching Link to heading

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


let a: Option<i32> = Some(1);
match a {
 Some(0) => eprintln!("I am 0"),
 Some(x) if x % 2 == 0 => eprintln!("I am even"),
 Some(x) => eprintln!("I am {x}"),
 None => eprintln!("I am none"),
}

if let Some(x) = a {
 eprintln!("a = Some({x})");
}

let Some(x) = a else {
 return;
};
eprintln!("{x}");

let x = a.unwrap();

References Link to heading

Ownership Link to heading

Containers Link to heading

1
2
3
4
5


// Create an array
let a: [usize; 10] = [1; 10];
// Create a vec
let v: Vec<usize> = vec![1usize; 10];
assert_eq!(&a, &v, "Slices are not equal!");

Traits Link to heading

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


trait MyTrait {
 fn my_fn(&self);
}

impl MyTrait for usize {
 fn my_fn(&self) {
 eprintln!("I am a usize!");
 }
}

impl MyTrait for i32 {
 fn my_fn(&self) {
 eprintln!("I am a i32!");
 }
}

fn f(t: impl MyTrait) {
 t.my_fn();
}

fn main() {
 let a = 1; // i32 by default
 a.my_fn();
 let b = 1usize;
 b.my_fn();
 f(a);
 f(b);
}

Iterators Link to heading

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


for i in 0..10 {
 eprintln!("i={}", i);
}

let v = (0..10).collect_vec();

for x in &v {
 eprintln!("x={}", x);
}

for (i, x) in v.iter().enumerate() {
 eprintln!("{i:>2} => {x}");
}

for x in v.iter().filter(|x| **x % 2 == 0) {
 eprintln!("x={}", x);
}

for x in v.iter().map(|x| x * x) {
 eprintln!("square: {}", x);
}

Common libraries Link to heading

See blessed.rs for a list of commonly used and recommended libraries.

One Year Of Rust

Thu, 17 Nov 2022 00:00:00 +0100