The work focuses on a central maintenance problem in large software projects: build systems must turn source code into executable binaries and software packages, and those systems can become complex distributed systems that manage dependencies, coordinate resources and support build correctness. The research release cites prior evidence that build maintenance can consume as much as 27% of a developer’s time in large projects. It also reports that dependency-related errors account for more than 50% of build errors in large-scale software projects. Missing dependencies occur when a required dependency is not declared in the build manifest, potentially causing an incorrect build or a failure. Redundant dependencies are unnecessary declarations that can lead to avoidable rebuilds and lower build performance.

Existing approaches can detect these errors, but the researchers say that many impose substantial runtime overhead, making them difficult to use in continuous integration environments. One conventional method uses ptrace-based system-call tracing. The method can be accurate, but it operates in user space and requires frequent process suspensions and context switches for each system call. That cost is separate from the computation needed to analyze a project’s dependency structure. The study therefore addresses two bottlenecks: the overhead of observing a build while it runs and the computational expense of examining dependencies after tracing. Its goal was to lower both costs while preserving detection performance for absent and unnecessary dependencies.

To reduce tracing overhead, mkcheck2 uses eBPF-based system-call monitoring in its Build Tracer module. The eBPF program runs in kernel space, where it filters and processes system calls in real time without the repeated user-space transitions associated with ptrace-based tracing. Data collected by the kernel-level program are passed to a user-space tracer that maintains information about the hierarchy of processes involved in the build. In the paper’s reported comparison, this division of work allowed the system to observe file operations during builds while sharply reducing the overhead imposed on the traced process. The release does not characterize the underlying eBPF technology with an expanded name, and the reported results apply to the authors’ implementation and evaluated workload.

The second component, the dependency graph builder, turns the traced file operations into a representation of the dependencies actually used during a build. It maintains this graph, records historical dependency information and classifies dependencies according to their characteristics. The system’s developers describe this module as its central data processor because it connects the raw observations collected during tracing with the data structures used for error detection. It also supplies the historical information required for comparisons between builds. The approach is therefore not limited to listing files touched by a single build: it creates a maintained account of dependency relationships that can be used as the basis for subsequent verification.

The third component is an incremental analyzer, which detects dependency errors by comparing dependency graphs generated from different builds. Instead of analyzing the entire dependency structure after every change, the analyzer focuses on modified portions of the graph. This is intended to reduce the computational cost of verification by limiting detailed analysis to the parts of the dependency structure that have changed. Incremental analysis and eBPF tracing address different expenses in the workflow. The former reduces how much of the recorded dependency graph must be examined after tracing, while the latter reduces the cost of collecting the file-operation data during the build itself.

Across the 300-project evaluation, mkcheck2 produced the reported 99.7% reduction in build-time overhead relative to the existing ptrace-based method. Average overhead fell from 148.0% to 0.3%. The method also reduced mean dependency-analysis time per commit from 1,267.49 seconds to 23.56 seconds, a reduction by a factor of about 54. The experimental study assessed a system for identifying dependency errors rather than the long-term reliability or security of an entire software organization. Its findings concern the tested open-source projects, the comparison method and the authors’ implementation; they do not establish that every build environment would produce identical overhead or analysis times.

The two reported accuracy values apply to distinct forms of dependency error. The 100% figure concerns missing dependencies, in which a dependency needed for a build was not declared in the manifest. The 92% figure concerns redundant dependencies, where a declared dependency was unnecessary. The figures should not be combined into a single overall accuracy rate, and the release does not provide such a combined measure. In practical terms, the evaluation found that the system identified every missing dependency in the assessed cases while detecting most redundant dependencies. The performance advantage was therefore obtained alongside complete detection for one error category and high but incomplete detection for the other.

The study was published in the Proceedings of the 2026 IEEE/ACM 48th International Conference on Software Engineering, which was held in Rio de Janeiro, Brazil, from April 12 to 18, 2026, and the paper became available online on September 11. Its title is “Efficient Build Dependency Verification Using eBPF and Incremental Analysis.” The research team included Yuta Saito and Hironori Washizaki of Waseda University, together with Kazunori Sakamoto of Tokyo Online University, the National Institute of Informatics and WillBooster Inc. The research was an experimental software-engineering study of a build dependency verification system, with the 300 open-source projects providing the scope for its quantitative evaluation.

Washizaki said the technology could play an important role in large-scale software systems, including cloud and AI infrastructure, where rapid verification during continuous integration is essential. He also said that, over the long term, it may contribute to software reliability and security by helping maintain build-system correctness at scale. Those statements describe potential applications rather than measured outcomes from the 300-project evaluation. The demonstrated result is narrower: by replacing ptrace-heavy observation with eBPF monitoring and restricting graph analysis to changed regions, mkcheck2 sharply reduced both build-time overhead and per-commit analysis time while retaining high reported accuracy for the dependency errors it was designed to detect.

Subject of Research: Experimental evaluation of an eBPF and incremental-analysis system for verifying software build dependencies

Article Title: mkcheck2: A highly efficient and accurate approach for build dependency verification

Article References: mkcheck2: A highly efficient and accurate approach for build dependency verification. Original publication (Bibliographic details unavailable.)

Image Credits: AI Generated

DOI: Not provided

Keywords: software engineering, build systems, dependency verification, eBPF, incremental analysis, system-call tracing, continuous integration, open-source software, build performance, mkcheck2, highly, efficient