Linus Torvalds Slams Google Engineer’s RISC-V Code as “Garbage,” Citing Quality and Submission Lapses
The world of open-source development, particularly within the Linux kernel community, thrives on rigorous review and contributions that uphold the project’s renowned quality. Recently, this high standard was starkly emphasized when Linus Torvalds, the creator of Linux and its principal architect, delivered a scathing public critique of a RISC-V code submission originating from a Google engineer. Torvalds did not mince words, describing the code as “garbage” and asserting that it “makes the world actively a worse place to live.” This strong condemnation, coupled with observations about late submissions, has sent ripples throughout the developer community, underscoring the critical importance of meticulous code quality and adherence to project timelines, even for contributions from prominent tech giants like Google.
A Scathing Verdict: Torvalds’ Judgment on the RISC-V Code
The pronouncements from Linus Torvalds are rarely understated, and in this instance, his assessment of the Google engineer’s RISC-V code was particularly blunt. The Linux kernel’s development process is characterized by an extensive peer-review system, where proposed changes are scrutinized by a multitude of experienced developers. Torvalds, as the ultimate gatekeeper, holds a position of immense authority in this process. His declaration that the submitted code was “garbage” signifies a profound failure to meet the fundamental requirements of the Linux kernel. This is not merely a matter of minor stylistic differences or conceptual disagreements; it suggests fundamental flaws in the code’s design, implementation, or both.
When code is deemed “garbage” in this context, it implies that it is not merely suboptimal but actively detrimental. It could contain significant bugs, introduce security vulnerabilities, compromise system stability, or simply be unmaintainable and poorly structured. The assertion that such code “makes the world actively a worse place to live” elevates the critique beyond technical inadequacy to a moral or ethical dimension. This suggests that the submitted code, if merged, would not only fail to improve the Linux ecosystem but would actively degrade it, potentially causing frustration, instability, and security risks for users worldwide. Such a strong statement from Torvalds highlights the immense responsibility developers bear when contributing to critical open-source projects that underpin a vast array of technologies.
The RISC-V architecture itself is a significant development in the computing landscape, offering an open and extensible instruction set architecture that promises greater flexibility and innovation. Contributions to RISC-V support within the Linux kernel are therefore vital for its broader adoption and integration. However, this recent incident serves as a powerful reminder that the open-source ethos does not equate to accepting subpar code. Instead, it relies on a shared commitment to excellence, collaboration, and the collective improvement of the software. Torvalds’ harsh assessment serves as a potent signal that even for developers from well-established companies like Google, the bar for entry into the Linux kernel is exceptionally high and non-negotiable.
Beyond the Code: Concerns Over Late Submissions
Adding another layer to the public criticism, Linus Torvalds also highlighted issues with the timeliness of submissions. This aspect of the feedback is equally important and speaks to the operational discipline required within large-scale, collaborative software development. The Linux kernel development cycle has specific release schedules and merge windows. For contributions to be effectively integrated and tested, they must arrive within these designated periods. Late submissions can disrupt the established workflow, potentially delaying releases or forcing the kernel development team to rush through reviews, which can compromise quality.
When Torvalds points out late submissions, it suggests a breakdown in the expected process. This could stem from various factors, including internal project management issues at Google, unforeseen complexities in the development work, or perhaps a misunderstanding of the kernel’s development cadence. Regardless of the cause, the impact is the same: it creates friction and inefficiency for the kernel maintainers. In an environment where thousands of patches are reviewed and integrated regularly, punctuality and adherence to process are as crucial as the technical merit of the code itself.
This dual criticism—of code quality and submission timeliness—indicates that the Google engineer’s contribution fell short on multiple fronts. It underscores that being part of the Linux kernel development community requires not only technical prowess but also professionalism, discipline, and a commitment to collaborative best practices. For a company of Google’s stature, which relies heavily on open-source software and contributes significantly to various projects, adherence to these standards is paramount. Torvalds’ public statement serves as a notice, not just to the individual engineer but potentially to Google as an organization, about the expectations for their contributions.
Implications for Google and the RISC-V Ecosystem
The public nature of Linus Torvalds’ criticism of Google’s RISC-V code carries significant implications for both the company and the broader RISC-V ecosystem. For Google, a company deeply invested in Linux and a major player in the development of RISC-V hardware and software, this incident presents an opportunity for introspection and improvement in their contribution workflows. It highlights potential gaps in their internal review processes or communication channels when interacting with critical open-source projects.
Enhancing internal quality gates before submitting code to the Linux kernel is likely a key takeaway for Google. This could involve more stringent internal code reviews, better tooling for identifying potential issues, and closer collaboration between the engineers working on RISC-V and the Linux kernel community liaisons within Google. Furthermore, the feedback on late submissions suggests a need to improve project management and scheduling for open-source contributions, ensuring that Google’s internal timelines align with the external requirements of projects like the Linux kernel.
The incident also has broader implications for the RISC-V ecosystem. As RISC-V gains momentum as a viable alternative to established architectures like ARM and x86, its successful integration into major software platforms like Linux is crucial. High-quality, timely contributions are essential for this integration to be seamless and robust. When contributions are perceived as lacking in quality or adherence to process, it can inadvertently create skepticism about the readiness of RISC-V for mainstream adoption or cast a shadow on the capabilities of companies heavily involved in its development.
Conversely, this feedback can serve as a catalyst for improvement. By openly addressing these issues, Torvalds is reinforcing the high standards necessary for open-source collaboration. This can encourage Google and other major players to invest further in ensuring their contributions to RISC-V and the Linux kernel are of the highest caliber. The ultimate goal is to foster a healthy and productive collaborative environment where RISC-V can be fully realized as a powerful and widely adopted architecture, supported by robust and well-maintained software.
The Linus Torvalds Standard: Uncompromising Quality
Linus Torvalds’ reputation is built, in large part, on his uncompromising stance on code quality. For over three decades, he has meticulously guided the development of the Linux kernel, transforming it into one of the most stable, reliable, and performant operating systems in the world. This success is not accidental; it is the direct result of a development process that prioritizes correctness, efficiency, and maintainability above all else. His critiques, while often sharp, are fundamentally aimed at preserving the integrity and robustness of the kernel.
When Torvalds labels code as “garbage,” it’s a signal that the code fails to meet a fundamental threshold of acceptability. This isn’t about subjective aesthetic preferences; it’s about objective criteria that ensure the long-term health and viability of the project. Code that is difficult to understand, hard to modify, or prone to errors can quickly become a liability rather than an asset. In a project as vast and complex as the Linux kernel, which forms the backbone of countless systems from smartphones to supercomputers, the consequences of merging low-quality code can be far-reaching and severe.
The “makes the world actively a worse place to live” comment is particularly telling. It reflects Torvalds’ understanding of the Linux kernel’s pervasive influence. If the kernel itself is compromised by poor code, then the systems that rely on it are also compromised. This includes everything from critical infrastructure and enterprise servers to everyday personal computers and mobile devices. Therefore, maintaining the highest possible standards is not just a technical imperative; it’s a responsibility to the global community of users who depend on Linux.
This incident serves as a stark reminder that the open-source model, while collaborative, is not a free-for-all. It operates under a meritocratic system where contributions are judged on their technical merit and adherence to established standards. For developers aiming to contribute to projects like the Linux kernel, understanding and respecting these standards, including the rigorous review process and punctuality, is paramount. It’s about being a good steward of a shared resource, ensuring that every contribution strengthens, rather than weakens, the collective work.
Navigating the Open-Source Contribution Landscape
The incident involving the Google engineer’s RISC-V code offers valuable insights for any developer looking to contribute to large-scale, impactful open-source projects like the Linux kernel. Navigating this landscape successfully requires more than just coding ability; it demands a deep understanding of the project’s culture, processes, and expectations.
Thorough preparation and understanding are the bedrock of effective open-source contributions. Before submitting any code, developers should immerse themselves in the project’s documentation, mailing lists, and existing codebase. For the Linux kernel, this means understanding the kernel development workflow, coding style guidelines, and the review process. Familiarizing oneself with the history of accepted patches and the types of changes that are typically merged can provide invaluable context.
Quality assurance is paramount. The Linux kernel has a notoriously high bar for code quality. This includes not only functional correctness but also adherence to strict coding styles, robust error handling, efficient memory management, and comprehensive documentation. Thorough self-testing, utilizing static analysis tools, and engaging with the community for early feedback on proposed changes can help identify and rectify potential issues before a formal submission. The harsh criticism from Torvalds underscores that simply “getting it to work” is insufficient; the code must be elegant, maintainable, and demonstrably superior to existing solutions.
Adherence to timelines and processes is equally critical. Open-source projects, especially those with established release cycles like the Linux kernel, rely on predictable workflows. Understanding merge windows, submission deadlines, and the expectations around patch series management is vital. Late submissions can disrupt the maintainers’ work, introduce complexities into the integration process, and potentially lead to the rejection of otherwise good contributions. Proactive communication about potential delays or challenges can often mitigate these issues.
Respectful and effective communication is the final, crucial element. The open-source community thrives on collaborative communication. Engaging with reviewers respectfully, responding constructively to feedback, and being willing to iterate on code based on community input are essential. While Torvalds’ comments were blunt, they are often born from a deep commitment to the project’s well-being. Learning to interpret and act upon such feedback is a key skill for successful open-source developers. By embracing these principles, developers can increase their chances of making meaningful and accepted contributions to vital open-source projects, ensuring they contribute positively to the technological landscape.