# Keleusma Research Spike: Blocking Frequency as the Ordering Principle for Instruction-Set Coverage

DevFeed: [Keleusma Research Spike: Blocking Frequency as the Ordering Principle for Instruction-Set Coverage](<https://devfeed.tech/articles/keleusma-research-spike-blocking-frequency-as-the-ordering-principle-for-instruction-set-coverage-39752.md>)

Original publisher: [Read original article](<https://sgeos.github.io/engineering/compilers/verification/2026/08/06/native_lowering_coverage.html>)

Author: Brendan Sechter

Published: 2026-08-06T09:00:00Z

Content type: article

Language: en

Sources: [Brendan A R Sechter's Development Blog](<https://devfeed.tech/sources/brendan-a-r-sechter-s-development-blog.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [Code generation](<https://devfeed.tech/topics/code-generation.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [measurement](<https://devfeed.tech/tags/measurement.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [research](<https://devfeed.tech/tags/research.md>), [verification](<https://devfeed.tech/tags/verification.md>)

## AI overview

This case study examines how blocking frequency can guide the order of instruction implementation in Keleusma's compiler backend. It contrasts instruction-level coverage with whole-program compilability and describes a small measurement tool that exposed a flawed implementation plan.

## Source excerpt

A compiler was 87 percent finished. It could not compile two thirds of the programs it was for. Both numbers are correct. The first counts individual instructions the compiler knew how to translate. The second counts whole programs that would actually go through. The gap between them is what this article is about, and the reason it exists is simple enough to state in one sentence. A program needs every instruction it uses, not most of them. One missing instruction out of a hundred stops the whole thing, exactly as one missing link stops a chain. That gap then destroyed a carefully reasoned plan. One working session before the measurement was taken, the author of this article had formally recommended what the next piece of work should be. The reasoning had no invalid step in it. The measurement showed the recommendation to be worth nothing at all, because the thing it would have unblocked does not occur even once in any program the compiler is meant to serve. The instrument that established this took about twenty minutes to build and two seconds to run. The article reports that, and then reports four errors made while writing it, all four of which ran in the direction of a more striking result, and one of which was committed inside the paragraph warning against the other three. What this is a case study of The setting is compiler engineering, and a reader who has never written a compiler can follow the argument, because the shape of the problem is not specific to compilers. The concrete project is Keleusma, whose compiler until now has emitted bytecode for a virtual machine, as described in the self-hosting strategy and its getting-started article. Native code generation is the step after that one, and it is where the ordering question first became expensive enough to measure. The lineage of the design sits in the stream-based compilers series and in the self-hosted silicon compiler. None of that background is needed to follow what follows, and the measurement stands