@curious_coding

PhD on high troughput bioinformatics @ ETH Zurich; IMO, ICPC, Xoogler, Rust, road-cycling, hiking, wild camping, photography https://xitter.cf/t.co/wBv2zN4F80

 Zurich
curiouscoding.nl
Joined October 2021
  • Tweets1.9K
  • Following81
  • Followers1.2K
188Media
Ragnar {Groot Koerkamp} 🦋 retweeted
Rust for Bioinformatics@rust4bioAug 29
SIMD + Rust + pattern matching = Sassy, a small, sharp tool from @curious_coding et al., for fast sequence search. Proof that you don't need a giant framework to move the needle, sometimes you just need really well-written low-level code. 🔍🦀 academic.oup.com/bioinformat…

Sassy: fuzzy searching DNA sequences using SIMD

AbstractMotivation. Approximate string matching (ASM) is the problem of finding all occurrences of a pattern in a text while allowing up to k errors. Many

academic.oup.com
10
19
1,156
Ragnar {Groot Koerkamp} 🦋 retweeted
antisense.@razoralignMay 26
Sassy: Fuzzy Searching DNA Sequences using SIMD academic.oup.com/bioinformat…
1
6
20
1,398
Ragnar {Groot Koerkamp} 🦋 retweeted
Samuel Lampa - Also: smllmp.bsky.social@smllmpJun 5
As said before, this is a super useful (and *fast*) tool, that we've already been using quite a bit for troubleshooting spurious primer matching and the like. Warmly recommended!
Ragnar {Groot Koerkamp} 🦋@curious_codingJun 4
To all folks dealing with biological data: do you ever need to check if your reads contain barcodes/adapters/primers/...? Or off-target matches? Sassy is the tool to use! A super fast implementation of "approximate string matching" with a grep-like CLI. curiouscoding.nl/posts/sassy…
1
2
437
SimdQuickHeap: The QuickHeap Reconsidered Johannes Breitling, Ragnar Groot Koerkamp, Marvin Williams arxiv.org/abs/2604.25681 [𝚌𝚜.𝙳𝚂]
Priority queues are data structures that maintain a dynamic collection of elements and allow inserting new elements and removing the smallest element. The most widely known and used priority queue is likely the implicit binary heap, even though it is has frequent cache misses and is hard to optimize using e.g. SIMD instructions. We introduce the SimdQuickHeap, a variant of the QuickHeap that was introduced by Navarro and Paredes in 2010. As suggested by the name, the data structure bears some similarity to QuickSort. We modify the data layout of the original QuickHeap to have all pivots adjacent in memory, with elements between consecutive pivots stored in dedicated buckets. This allows efficient SIMD implementations for both partitioning of buckets and scanning the list of pivots to find the bucket to append newly inserted elements to. The SimdQuickHeap has amortized expected complexity O(log n) per operation, which improves to O(frac 1Wlog n) in non-degenerate cases, where W is the n

ALT Priority queues are data structures that maintain a dynamic collection of elements and allow inserting new elements and removing the smallest element. The most widely known and used priority queue is likely the implicit binary heap, even though it is has frequent cache misses and is hard to optimize using e.g. SIMD instructions. We introduce the SimdQuickHeap, a variant of the QuickHeap that was introduced by Navarro and Paredes in 2010. As suggested by the name, the data structure bears some similarity to QuickSort. We modify the data layout of the original QuickHeap to have all pivots adjacent in memory, with elements between consecutive pivots stored in dedicated buckets. This allows efficient SIMD implementations for both partitioning of buckets and scanning the list of pivots to find the bucket to append newly inserted elements to. The SimdQuickHeap has amortized expected complexity O(log n) per operation, which improves to O(frac 1Wlog n) in non-degenerate cases, where W is the n

1
1
6
1,391
Ragnar {Groot Koerkamp} 🦋 retweeted
Geoff Langdale
@geofflangdaleMar 26
Replying to @valigo
Getting good at GPU programming will make you a better coder on modern CPUs. A throughput-oriented mentality, while critical on GPUs, is also a way better way of coaxing better performance out of the wide, deeply-pipelined, SIMD-enabled monstrosities that are modern CPUs.
1
3
37
1,775
Ragnar {Groot Koerkamp} 🦋 retweeted
Jennifer Doleac
@jenniferdoleac22 Dec 2025
Me 15 years ago, as a PhD student: “It seems like all the interesting questions have been answered & there are no useful studies left to do.” Me now, as a funder focused on evidence-based criminal justice policy: “The biggest constraint we face is finding researchers with time to engage in important new projects.” Truly, this is the most pressing problem I have. I need an army of scholars who understand causal methods & who would jump at an opportunity to study a program or policy. Would you like to help? Email me. 🙏
25
71
5
659
111,788
Ragnar {Groot Koerkamp} 🦋 retweeted
The Lunduke Journal
@LundukeJournal23 Dec 2025
Microsoft has set a goal to “eliminate every line of C and C++ from Microsoft by 2030.” What are they going to try to replace that C & C++ code with? You guessed it. Rust. And they’re going to use AI to do the “Rust re-write” at an insane speed. “Our strategy is to combine AI *and* Algorithms to rewrite Microsoft’s largest codebases. Our North Star is “1 engineer, 1 month, 1 million lines of code”. You read that right. One million lines of code, per engineer, per month. Pure insanity. This kind of decision making is common among those with a deeply held, delusional faith in the Cult of Rust. Take battle tested code, and re-write it (without a clear benefit to the end user) at a recklessly rapid rate. Then force others to adopt that rewritten code before it is ready or properly tested. All while holding a delusional belief that your new Rust code is superior in all ways, and is inherently bug free thanks to the divine nature of Rust. We learned this from a post by Galen Hunt, Distinguished Engineer at Microsoft Research. linkedin.com/posts/galenh_pr…
1,156
967
881
8,823
1,884,237
Ragnar {Groot Koerkamp} 🦋 retweeted
Geoff Langdale
@geofflangdale22 Dec 2025
The experience of having some muddy mess of a hundred line function with goofy "do things one way here, then do almost the same thing somewhere else, then ..." become clear and turn into a 20-line clean "computer science" type function with nice clean data structures is bliss.
2
16
2,084
Ragnar {Groot Koerkamp} 🦋 retweeted
𝕐@nomad42120 Dec 2025
If you really want to search quickly, use @curious_coding’s approach curiouscoding.nl/posts/stati…!

Static search trees: 40x faster than binary search

In this post, we will implement a static search tree (S+ tree) for high-throughput searching of sorted data, as introduced on Algorithmica. We’ll mostly take the code presented there as a starting...

curiouscoding.nl
Dmitrii Kovanikov
@ChShersh20 Dec 2025
One of my favourite tricks of CS algorithms Theory vs Practice is binary search optimisation for cache-friendliness. The standard algorithm looks at the middle of array and jumps back and forth. This destroys cache. Instead, store a pre-order traversal of a sorted array represented as a tree. This way you always hit the first elements of the array, and they can be safely cached.
1
4
536
Ragnar {Groot Koerkamp} 🦋 retweeted
Geoff Langdale
@geofflangdale18 Nov 2025
Replying to @lemire
I think we should have a new runtime option where stack, heap, bss, and tls are all in zones where it is guaranteed that any load of any legally addressable byte is guaranteed not to be <64 bytes from a page boundary or anything that will cause a disaster if loaded. ...
1
1
5
1,157
Ragnar {Groot Koerkamp} 🦋 retweeted
Geoff Langdale
@geofflangdale9 Nov 2025
Contemplating a type system where the bit sizes required are 1, 2, 4, 8, 9, 16, 17, 32, 33, 64, 65, 128, 256, 512. Disgusting stuff, I should be ashamed of myself.
3
2
8
1,682
Ragnar {Groot Koerkamp} 🦋 retweeted
Forrest Smith@ForrestTheWoods30 Oct 2025
I abhor that computer programmers still use the term “word”. > Size=2 means a word (2 bytes) Just say it’s 2-bytes. Word and Dword and Qword are stupid terms that should never be used by anyone in 2025. Just say how many bytes and be done with it!
110
10
11
489
106,404
Ragnar {Groot Koerkamp} 🦋 retweeted
James Ferguson@Psy_Fer_24 Oct 2025
I made reddit.com/r/bioinformaticsd… I did this because the r/bioinformatics channel doesn't like talking about tools, especially if you wrote it yourself. If you build bioinformatic tools or want to learn more about it, join the subreddit and start posting :)

r/bioinformaticsdev

A community for building better bioinformatics tools. Share your open-source bioinformatics tools at any stage of development - from early ideas to stable releases. Get feedback on CLI design, code...

reddit.com
4
14
1,090
Ragnar {Groot Koerkamp} 🦋 retweeted
Yining Karl Li@yiningkarlli23 Oct 2025
And still probably 95% of programmers are like "don't worry about the low level details, the compiler will take care of it"
Elan Ruskin@despair23 Oct 2025
I was curious whether compilers would convert a naive loop implementation of "set range of bits in u64 to 1" into O(1) bitwise ops. Answer: MSVC compiles the loop into a loop. Clang's output is bonkers: 418 bytes long, branches everywhere, 256-bit SIMD operations get involved?!
Screenshot of some C++ code: ``` // returns a mask with bits [ n , n + size ) set to 1, eg // MakeMaskRange( 4, 2 ) -> 0x030ull uint64_t MakeMaskRangeLoop( unsigned lowest, unsigned size ) { uint64_t mask = 0; for ( unsigned i_bit = lowest; i_bit < lowest + size; ++i_bit ) { mask |= 1 << i_bit; } return mask; // OBVIOUSLY THIS IS NOT HOW ANYONE WOULD ACTUALLY IMPLEMENT THIS, // IT'S JUST TO TEST THE COMPILER, DON'T @ ME } ```

ALT Screenshot of some C++ code: ``` // returns a mask with bits [ n , n + size ) set to 1, eg // MakeMaskRange( 4, 2 ) -> 0x030ull uint64_t MakeMaskRangeLoop( unsigned lowest, unsigned size ) { uint64_t mask = 0; for ( unsigned i_bit = lowest; i_bit < lowest + size; ++i_bit ) { mask |= 1 << i_bit; } return mask; // OBVIOUSLY THIS IS NOT HOW ANYONE WOULD ACTUALLY IMPLEMENT THIS, // IT'S JUST TO TEST THE COMPILER, DON'T @ ME } ```

lowest$ = 8 size$ = 16 unsigned __int64 MakeMaskRangeLoop(unsigned int,unsigned int) PROC ; MakeMaskRangeLoop, COMDAT xor r9d, r9d lea eax, DWORD PTR [rcx+rdx] cmp ecx, eax jae SHORT $LN10@MakeMaskRa mov r8d, 1 mov eax, edx rol r8d, cl npad 11 $LL4@MakeMaskRa: mov ecx, r8d or r9, rcx rol r8d, 1 sub rax, 1 jne SHORT $LL4@MakeMaskRa $LN10@MakeMaskRa: mov rax, r9 ret 0 unsigned __int64 MakeMaskRangeLoop(unsigned int,unsigned int) ENDP ; MakeMaskRangeLoop

ALT lowest$ = 8 size$ = 16 unsigned __int64 MakeMaskRangeLoop(unsigned int,unsigned int) PROC ; MakeMaskRangeLoop, COMDAT xor r9d, r9d lea eax, DWORD PTR [rcx+rdx] cmp ecx, eax jae SHORT $LN10@MakeMaskRa mov r8d, 1 mov eax, edx rol r8d, cl npad 11 $LL4@MakeMaskRa: mov ecx, r8d or r9, rcx rol r8d, 1 sub rax, 1 jne SHORT $LL4@MakeMaskRa $LN10@MakeMaskRa: mov rax, r9 ret 0 unsigned __int64 MakeMaskRangeLoop(unsigned int,unsigned int) ENDP ; MakeMaskRangeLoop

screenshot of a very large disassembly stream full of insane things like .LBB1_12: vmovd xmm0, edi vpbroadcastd xmm2, dword ptr [rip + .LCPI1_1] vpbroadcastd xmm3, dword ptr [rip + .LCPI1_2] vpbroadcastd xmm4, dword ptr [rip + .LCPI1_3] vpbroadcastd xmm5, dword ptr [rip + .LCPI1_4] vpbroadcastd xmm6, dword ptr [rip + .LCPI1_5] mov esi, edx vpxor xmm7, xmm7, xmm7 vpxor xmm8, xmm8, xmm8 vpxor xmm9, xmm9, xmm9 and esi, 48 lea r8d, [rdi + rsi] mov eax, esi vpbroadcastd xmm0, xmm0 vpaddd xmm1, xmm0, xmmword ptr [rip + .LCPI1_0] vpxor xmm0, xmm0, xmm0 .LBB1_13: vpsllvd xmm13, xmm5, xmm1 vpaddd xmm10, xmm1, xmm2 vpaddd xmm11, xmm1, xmm3 vpaddd xmm12, xmm1, xmm4 vpaddd xmm1, xmm1, xmm6 add eax, -16 vpsllvd xmm10, xmm5, xmm10 vpsllvd xmm11, xmm5, xmm11

ALT screenshot of a very large disassembly stream full of insane things like .LBB1_12: vmovd xmm0, edi vpbroadcastd xmm2, dword ptr [rip + .LCPI1_1] vpbroadcastd xmm3, dword ptr [rip + .LCPI1_2] vpbroadcastd xmm4, dword ptr [rip + .LCPI1_3] vpbroadcastd xmm5, dword ptr [rip + .LCPI1_4] vpbroadcastd xmm6, dword ptr [rip + .LCPI1_5] mov esi, edx vpxor xmm7, xmm7, xmm7 vpxor xmm8, xmm8, xmm8 vpxor xmm9, xmm9, xmm9 and esi, 48 lea r8d, [rdi + rsi] mov eax, esi vpbroadcastd xmm0, xmm0 vpaddd xmm1, xmm0, xmmword ptr [rip + .LCPI1_0] vpxor xmm0, xmm0, xmm0 .LBB1_13: vpsllvd xmm13, xmm5, xmm1 vpaddd xmm10, xmm1, xmm2 vpaddd xmm11, xmm1, xmm3 vpaddd xmm12, xmm1, xmm4 vpaddd xmm1, xmm1, xmm6 add eax, -16 vpsllvd xmm10, xmm5, xmm10 vpsllvd xmm11, xmm5, xmm11

30
34
6
841
83,036
Ragnar {Groot Koerkamp} 🦋 retweeted
P99CONF
@P99CONF22 Oct 2025
How can you gain a 40x increase in throughput over the #Rustlang standard library implementation? In 15 minutes, @curious_coding will show how to exploit what modern CPUs offer so you can achieve faster binary search. Join here > ow.ly/l8pl50XgfYT #ScyllaDB #P99CONF
3
7
661
Ragnar {Groot Koerkamp} 🦋 retweeted
quite quiet
@babarganesh19 Oct 2025
Replying to @ChShersh
i want knowledge to be passed by reference not by value
1
1
67
6,542
Ragnar {Groot Koerkamp} 🦋 retweeted
P99CONF
@P99CONF14 Oct 2025
How can you achieve 40x faster binary search? @curious_coding's #P99CONF talk will dive into everything that modern CPUs have to offer in order to gain 40x increased throughput over the Rust standard library implementation. Save your spot here > ow.ly/oT8X50XbeTo #ScyllaDB
3
8
589
It’s a bit easier to just explain how we got here. In the old days, memory and CPU ran at the same speed. The laws of physics make it incredibly hard to ramp up the MHz of the CPU while keeping physically separated memory chips in sync. The distance is just too far for the electricity to travel in time available. The solution was to manufacture a small amount of memory on the chip that is in sync with the chip. Then access the rest of the memory as an external device. Sort of like a linear hard drive. That on-chip memory became the L1 cache and the external chips became DRAM main memory as we know it today. The second problem was the sheer size of RAM was making it hard to keep the CPU fed. The amount of RAM in the L1 cache was too small. And making it bigger wasn’t a very good option from a price and scaling perspective. So a faster bit of RAM that was physically closer to the CPU was invented. Slower than L1, but faster than main memory. This sped up operations that were too large to fit in the L1. Thus L2 was born and eventually moved onto the CPU die rather than being a separate chip on the motherboard. The final piece of the puzzle isn’t about individual CPU performance at all. As CPUs became multi-core, the cores would fight over which one was accessing main memory. A bit of a “dining philosopher’s” problem. Even worse, if data was moved between cores, the first core had to send it all the way back to main memory before the second core could read it. The solution was to create a large chunk of fast memory that was shared between the cores. This acted as a staging point to share memory, and also acted as a place to buffer copies from main memory. The staging point could request a bit more than needed from main memory under the theory that reads would stream from main memory. That way data was available before the core even needed it. This space became the L3 cache. The only singular cache in today’s CPUs. Each core has their own L1 and L2 caches, meaning there are as many copies of L1 and L2 as there are cores. And that’s how we got to today’s 3-level cache.
Vivek Galatage
@vivekgalatage10 Oct 2025
The question: "Why do CPUs have multiple cache levels?" often gets many CS students and professionals thinking and researching. This article from Fabian Giesen narrates a "cache story" in a relatable way, only to delve into the details - a must-read! fgiesen.wordpress.com/2016/0…
46
382
17
3,789
272,560
Ragnar {Groot Koerkamp} 🦋 retweeted
Peter Schmidt-Nielsen
@ptrschmdtnlsn5 Oct 2025
Asymptotically, O(n^(1/3)) isn't quite achievable in this universe for a variety of reasons, and you have to be pretty clever to even get O(n^(1/2)). If you fill space with memory cells that don't collapse into a black hole then memory access actually takes O(n) time!
vitalik.eth
@VitalikButerin5 Oct 2025
Memory access is O(N^[1/3]) vitalik.eth.limo/general/202…

Memory access is O(N^[1/3])

vitalik.eth.limo
13
21
1
477
87,994
Ragnar {Groot Koerkamp} 🦋 retweeted
vitalik.eth
@VitalikButerin5 Oct 2025
Memory access is O(N^[1/3]) vitalik.eth.limo/general/202…

Memory access is O(N^[1/3])

vitalik.eth.limo
388
222
46
2,028
517,571
Load more