Dependable C: Advocating a High-Reliability Subset of the C Programming Language

The evolution of the C programming language is at a crossroads. While the ISO/IEC JTC1 committee continues to develop the C standard, moving from C23 to the upcoming C2Y, a new project has emerged to challenge this trend. Enter “Dependable C.” This initiative, which has garnered significant discussion on platforms like Lobsters, seeks to define a “reliable subset of C” rather than pursuing the latest specifications, with the goal of ensuring code portability and long-term maintainability.

A Subset Focused on Reliability

Dependable C represents an effort to document a simple and widely compatible way to write C code, eliminating reliance on specific compiler extensions or version dependencies. The project’s philosophy is succinctly captured in its mission statement:

“Imagine you are using a high-level language (e.g., Python, Java, C#) and you need a utility library to handle basic functions like complex mathematical computations or file parsing. What language would you want that library to be written in?”

Dependable C boldly asserts that the answer is “C.” The language is fast, simple, operates on virtually all platforms, and its code is widely readable by developers. However, the critical question is, “What kind of C?” The answer lies in writing the most plain and portable C code, devoid of extensions, specific compiler settings, or locked-in build procedures. Dependable C is defined as code that is independent of platform toolchains, specific implementations, or version dependencies.

Questioning the Latest Standards

The emergence of Dependable C is rooted in concerns over the evolution of the ISO C standards. The project critiques C23 and the forthcoming C2Y standard as follows:

“C23, and the upcoming C2Y, represent increasingly complex language versions with a plethora of new keywords, control flow mechanisms, and a revised charter that diverges from ‘classic C.’”

Furthermore, the project highlights a crucial issue: only two out of the hundreds of existing C compilers support the latest C standards. According to the project, the differences between ANSI C (C89/C90) and C2Y are now greater than those between ANSI C and the earliest versions of C++. This underscores how the latest ISO standards may fail to meet the needs of developers seeking broad portability.

Reassessing the Value of Classic C

Dependable C promotes an approach that reevaluates the value of so-called “Classic C.” Instead of chasing after the latest language features, it encourages focusing on the stable feature set that has existed since the 1990s. This allows developers to write code that can operate reliably over the long term without requiring frequent updates to accommodate new compiler versions or special build configurations.

The project covers topics such as “Dependable UB (Undefined Behavior),” “Memory Debuggers,” and “Effective Types.” Notable insights include recommendations on using flexible array members and critiques of the shortcomings of Variable Length Arrays (VLA), which are particularly practical for developers working with C in real-world applications.

Who Is This Subset For?

One of the intriguing aspects of Dependable C is its candid self-awareness. The project notes:

“Very few people want to write in Dependable C. However, everyone wishes that others would write their code in Dependable C.”

In essence, Dependable C isn’t designed to be “fun to write” for developers. Instead, it aims to be “reliable to use” for end-users. This trade-off resonates with the development community, particularly for third-party library creators, embedded systems developers, and those providing cross-platform utilities. Dependable C offers a robust framework for these use cases.

Specific Elements of the Subset

From the information provided, some of the topics targeted by Dependable C have been outlined. These include:

• Handling Undefined Behavior (UB)
• Rules for endianness and floating-point initialization
• Recommended keywords and flow control structures
• Differences among C99, C11, C17, and C23 versions
• Memory models and concurrency
• Effective type handling and aliasing issues
• Safe utilization of flexible array members

These areas serve as guidelines to avoid pitfalls in C while achieving maximum portability. Particular sections like “Dependable UB Extra” and “Memory Debugger Tweets” provide practical expertise for developers.

Implications for the Industry

The introduction of Dependable C raises several questions for the software industry. First, it highlights the disconnect between the evolution of language standards and real-world demands. Second, it underscores the difficulty of balancing cutting-edge features with long-term maintainability. Finally, it demonstrates that even for a language as widespread as C, efforts to define “correct usage” remain necessary.

In an era of modern system programming languages like Rust, Go, and Zig, Dependable C reaffirms the ongoing role of C as a “universal glue.” Rather than advocating for a shift to newer languages, Dependable C provides a pragmatic prescription for making existing C codebases safer and more portable.

Editorial Opinion

In the short term, Dependable C’s impact is likely to be limited. It is improbable that large-scale projects will rewrite their code to conform to this subset. However, more developers may reference these guidelines when developing new libraries or embedded system code. If the open-source community begins to adopt “Dependable C compliance” as a quality metric, its adoption could see steady growth.

From a long-term perspective, Dependable C could serve as a counterpoint to the increasing complexity of ISO C standards, potentially inspiring “conservative subset” movements in other programming languages. While C++ already has initiatives like the “C++ Core Guidelines” and “JSF C++ Coding Standards,” Dependable C is unique in challenging the very evolution of the standard itself. If the ISO committee responds by incorporating a “stable subset” into future C standards, it could influence the overall philosophy of language design across the software industry.

The editorial team poses the following questions for consideration:

References

• “Dependable C”, by dependablec.org via jado — Lobsters, 2026-07-19T19:45:09.000Z (ARR)
• Source URL: https://dependablec.org/