C programmers attribute considerable value to its syntax and semantics. New features should integrate seamlessly with the existing language. Attention should be paid to the ideas behind design principles, common idioms and habits, and the effect new features might have on the language's economy of expression.

Features, and the concepts behind them, should be easy to explain in a clear and concise manner. Language issues should be resolved using minimal new machinery. Ideally, only one way of doing something should be sufficient. Avoid additions with narrow use-cases that require specialized expertise from implementers, when such features could be provided externally. Simplicity enables both programmers and tools to reason about code, allows for diverse implementations, keeps compilation times short, and helps to achieve other principles.

C has been implemented on a wide variety of computers and operating systems, including cross-compilation of code for embedded systems. The language itself, together with the standard library, should be as widely implementable as possible, while meeting its core objectives. The size and complexity of the language and library should not place an undue burden on constrained hardware.

Undefined behaviors, unspecified behaviors, implementation-defined behaviors, and other portability issues enumerated in Annex J of the Standard should be eliminated or reduced.
These issues might lead to application vulnerabilities.

The potential for efficient code generation is one of the most important strengths of C. To help ensure that no code explosion occurs for what appears to be a very simple operation, many operations are defined to be how the target implementation does it rather than by a general abstract rule.

It is essential to let the programmer take control, as not every task can be accomplished within a sound set of bounds. C should offer flexibility to do what needs to be done. Code can be non-portable to allow such situations as direct interaction with the hardware, using features unique to an implementation, or specific optimizations. Bypassing safety checks should be possible when necessity arises. However, the need for such divergences should be minimized.

Prior art may come from other languages, although C implementations are naturally more compelling. Unless a new feature addresses a significant deficiency, no new inventions should be entertained. Avoid standardizing workarounds instead of long-term solutions.

C is a language with a wide variety of individual dialects. No single implementation is the exemplar by which C is defined; it is assumed that all existing implementations must change somewhat to conform to the Standard. However, it should be possible for existing implementations to gradually migrate to future conformance.

Incremental change towards a full solution is a common approach to introducing new features. However, care should be taken that features are not left in a state which could reduce their overall usefulness, hindering adoption and further development.

Developers should be able to mix and match code from different language editions. The bulk of existing codebases should be largely accepted by a translator conforming to a newer language revisions, and the programmer's burden to change code just to have it accepted by a conforming translator must be limited.

Changes that alter the meaning of existing code cause problems. Breaking changes that require diagnostic messages are easily detected. Avoid silent changes that cause a working program to behave differently without requiring a diagnostic message. Where this principle is violated, informative notes should be added to the Standard.

The language should take into account that programmers need the ability to check their work. While not guaranteeing program correctness, properties such as portability, unambiguity, memory safety, type safety, thread safety, etc. are prerequisite to reasoning about security and reliability. Software interfaces should be analyzable and verifiable. The language should allow programmers to write concise, understandable, and readable code.

C is frequently used in the development of safety-critical systems. Functional safety is the systematic process used to analyze that a fault does not prevent a program from performing its required function. An analyzable subset of the language is used to create a safety argument; this subset should be enlarged. Unbounded undefined behaviors (that represent a single point of failure) should be eliminated.

Fundamental language features should be operational without the standard library and library functionalities should be implementable without relying on compiler extensions. Supplying the library, or its parts, independently from the compiler vendor, may serve needs such as safety, efficiency, decreased size, or compatibility with multiple compilers on diverse architectures. The burden and difficulty of matching implementation details for such use-cases should be minimal.

C serves an important role as the lingua franca of the programming world. It is a primary target for foreign function interfaces and other languages often expose bindings for C interactions. Such communicative design allows C to exist as a part of larger systems, often providing the means for improving performance, being a gateway to the underlying platform, or translating between components written in different languages.

Software written in C is used worldwide. Beside information technology standards, related international and industry norms for processing natural language, date and time, units, numerical formats and so forth should be taken into account. C should provide facilities for handling both human and machine input and output, often given in various scripts and tongues.