IOCCC 2025 Winners: Mastering Obfuscated C Techniques

IOCCC 2025 Winners Announced: A Look at Obfuscated C Mastery

The International Obfuscated C Code Contest (IOCCC) has announced its winners for 2025. This year’s entries continue a tradition stretching back to 1984: writing C code that is deliberately hard to read, yet passes the compiler and produces correct output. The contest is not about writing bad code. It is about showing deep knowledge of the C language, the preprocessor, and the compiler’s optimization passes, all while meeting strict size constraints.

How the Contest Works

Entries are short C programs, typically under a few kilobytes of source. The code must compile and run correctly on a modern system. The challenge is to make the source code as confusing as possible while keeping the behavior deterministic. Judges evaluate entries on creativity, rule compliance, and the gap between how the code looks and what it actually does. Some entries use the C preprocessor to rename keywords, others exploit undefined behavior in creative ways, and a few embed entire algorithms inside macro expansions. The Introduction to Ethereum Scaling Problems in 2025 covers similar themes of creative constraint, though in a different technical domain.

Notable Winners in 2025

Several entries stood out this year. One winner submitted a program that implements a small HTTP server using only recursive macros and a single loop. The server parses requests by expanding and re-expanding macros until the response is built. Another winner wrote a program that draws a Mandelbrot set using only the characters {, }, ;, and whitespace, with no numbers or letters in the source. A third entry implements a bubble sort whose control flow is hidden inside the ternary operator, making the sort’s logic nearly impossible to follow by inspection.

These entries share a common technique: they push the C preprocessor and the compiler’s optimizer to their limits. The preprocessor can expand macros recursively, and the optimizer can eliminate dead code and fold constants. By exploiting these passes, contestants produce source that looks nothing like the final machine code. For example, the HTTP server entry uses #define to create a stack of nested function calls that the optimizer flattens into a single loop at compile time. The judges look for this kind of tension between source appearance and compiled behavior.

What Makes a Winning Entry

The IOCCC has published guidelines for entries over the years. Winning entries typically satisfy three criteria. First, they are short enough to fit in a single screen or a few hundred lines. Second, they produce surprising output, such as a game, a network service, or a graphical effect. Third, the obfuscation technique is novel, not a reuse of a known trick. A program that simply renames all identifiers to single letters is not interesting. A program that uses the preprocessor to build a state machine, where each macro invocation advances the state, is interesting.

One 2025 winner shows a technique called “token soup.” The source is a series of #define directives that reorder tokens from a fixed pool. The actual algorithm is encoded in the order of the defines, not in the code that follows. Another winner uses the sizeof operator on incomplete types to compute offsets at compile time, then uses those offsets to index into a single large array that stores all data. Both entries require the reader to understand how the compiler resolves types and evaluates constant expressions.

Impact on Programming Culture

The IOCCC influences how programmers think about code. It shows that readability is not a fixed property of the text, but a relationship between the text and the reader’s mental model. A program that is unreadable to one person may be clear to another who understands the trick. The contest also pushes compiler writers to consider edge cases. When the IOCCC finds a program that compiles on one compiler but not another, it often reveals a bug or a missing feature in the standard.

The contest has a long history of surfacing obscure language features. For example, the 2020 winner used the _Generic keyword from C11 to dispatch on type at compile time, a feature few C programmers use in practice. The 2025 entries continue this trend. One entry uses the _Alignas specifier to control memory layout, then relies on the resulting alignment to trigger undefined behavior that the optimizer exploits. This kind of exploration keeps the C language alive as a research subject, even as newer languages gain popularity.

Comparison of Obfuscation Techniques

The table below summarizes the main obfuscation techniques used by the 2025 winners and their trade-offs.

Technique	How It Works	Strengths	Weaknesses
Recursive macro expansion	Define macros that expand to other macros, creating a chain that builds code at compile time.	Produces very short source; hides control flow completely.	Compiler must support deep macro recursion; debugging is nearly impossible.
Token soup	Reorder tokens via `#define` so that the algorithm is encoded in the order of definitions.	Source appears random; the algorithm is invisible without tracing macro expansion.	Hard to write; requires careful planning of token order.
Undefined behavior exploitation	Use constructs that the standard does not define, relying on a specific compiler’s behavior.	Can produce very compact code; forces the optimizer to do the heavy lifting.	Non-portable; may break with compiler updates.
Type-based obfuscation	Use `sizeof`, `_Generic`, or `_Alignas` to compute offsets and dispatch at compile time.	Leverages modern C features; often produces correct code on first compile.	Requires deep knowledge of the C standard; limited to C11 and later.

How to Get Started with Obfuscated C

If you want to try writing obfuscated C, start with the IOCCC’s own guidelines. The contest publishes a list of rules and a set of winning entries from previous years. Read the source of past winners and trace the macro expansions manually. You can also use the -E flag in GCC or Clang to see the preprocessor output, which reveals the expanded code. A good first exercise is to write a program that prints “Hello, World!” without using any letters in the source. Use #define to assign letters to numbers, then build the string from those definitions.

The Understanding the lost+found Directory in Linux: Filesystem Recovery After Crashes post discusses another kind of system-level debugging that shares the same spirit of understanding how tools work under the hood. Both the IOCCC and filesystem recovery require reading source code or disk structures that were not designed for human readability.

The IOCCC 2025 winners show that C remains a language where creativity and deep technical knowledge can produce surprising results. The contest will open for submissions again in 2026, with the same challenge: write the most confusing, creative, and correct C program you can.

Sources and References

This article was researched using a combination of primary and supplementary sources:

Supplementary References

These sources provide additional context, definitions, and background information to help clarify concepts mentioned in the primary source.