003 Name Skill D29f7170

---
name: polyglot-rust-c
description: Guidance for creating polyglot source files that compile and run correctly as both Rust and C or C++. This skill applies when tasks require writing code that is valid in multiple languages simultaneously, exploiting comment syntax differences or preprocessor directives to create dual-language source files. Use this skill for polyglot programming challenges, CTF tasks, or educational exercises involving multi-language source compatibility.
---

# Polyglot Rust/C Programming

This skill provides structured guidance for creating source files that compile and execute correctly as both Rust and C/C++ programs.

## Core Principle: Action Over Analysis

The most critical lesson for polyglot tasks: **start writing code immediately**. Polyglot programming requires empirical validation through actual compilation. Mental reasoning alone cannot account for all syntax edge cases across languages.

## Recommended Workflow

### Phase 1: Establish Working Environment

1. Create the required output directory and file immediately
2. Verify both compilers are available (`rustc --version`, `g++ --version` or `gcc --version`)
3. Set up a rapid iteration loop for testing

### Phase 2: Incremental Development Strategy

**Do not attempt to solve everything at once.** Follow this progression:

1. **Single-language baseline**: Write a working solution in one language first (typically C/C++ as it has more flexible syntax)
2. **Minimal polyglot shell**: Create the simplest possible file that compiles in both languages (even if it does nothing useful)
3. **Gradual feature addition**: Add functionality piece by piece, testing after each change

### Phase 3: Iterative Testing

After every code change:
```bash
# Test Rust compilation and execution
rustc source_file -o rust_binary && ./rust_binary [args]

# Test C++ compilation and execution
g++ source_file -o cpp_binary && ./cpp_binary [args]
```

## Key Polyglot Techniques

### Comment Syntax Exploitation

The fundamental approach exploits differences in comment handling:

| Pattern | Rust Interpretation | C/C++ Interpretation |
|---------|---------------------|----------------------|
| `//`    | Line comment        | Line comment         |
| `/* */` | Block comment       | Block comment        |
| `/*/`   | Starts block comment| Ends then starts comment |
| `//*/`  | Line comment        | Ends block comment   |

### Preprocessor Directive Hiding

C/C++ preprocessor directives can hide Rust code from C:
- `#if 0` ... `#endif` blocks are ignored by C preprocessor
- Rust sees `#if 0` as a compiler directive (usually errors) or can be hidden in comments

### Recommended Skeleton Structure

A common pattern:
1. Use C-style block comments to hide Rust-specific code from C
2. Use `#if 0` blocks to hide C-specific code from Rust
3. Share common logic where syntax overlaps

## Verification Checklist

Before considering the task complete:

- [ ] File exists at the required path
- [ ] `rustc` compiles without errors
- [ ] `g++` (or `gcc`) compiles without errors
- [ ] Rust binary produces correct output for all test cases
- [ ] C++ binary produces correct output for all test cases
- [ ] Edge cases tested (boundary values, error conditions)

## Common Pitfalls to Avoid

### 1. Analysis Paralysis
**Problem**: Spending excessive time reasoning about syntax without writing code.
**Solution**: Write code first, let compiler errors guide iteration.

### 2. No File Creation
**Problem**: Extensive planning but never creating the actual output file.
**Solution**: Create the file within the first few actions, even with placeholder content.

### 3. Ignoring Compiler Feedback
**Problem**: Trying to predict all syntax issues mentally.
**Solution**: Use compiler error messages as the primary debugging tool.

### 4. Over-Engineering Initial Attempt
**Problem**: Trying complex polyglot patterns before confirming basics work.
**Solution**: Start with the simplest possible valid program, then add complexity.

### 5. Not Testing Both Languages After Each Change
**Problem**: Making multiple changes then discovering which one broke compilation.
**Solution**: Test both compilers after every single modification.

### 6. Forgetting Functional Requirements
**Problem**: Focusing only on polyglot validity, forgetting the actual task (e.g., Fibonacci calculation).
**Solution**: Verify output correctness, not just compilation success.

## Progress Tracking Template

Maintain explicit progress markers:

```
[x] Directory created
[x] Initial file created
[ ] Compiles as Rust
[ ] Compiles as C++
[ ] Correct output (Rust): test case 1
[ ] Correct output (C++): test case 1
[ ] All test cases pass
```

## Debugging Strategy

When compilation fails:

1. **Read the error message carefully** - it usually points to the exact issue
2. **Test the failing language in isolation** - comment out polyglot tricks temporarily
3. **Simplify** - remove features until it compiles, then add back incrementally
4. **Document what works** - keep notes on patterns confirmed to work

## Time Management

If stuck in exploration for more than a few minutes:
1. Stop theorizing
2. Write the simplest possible attempt
3. Run both compilers
4. Iterate based on actual errors

The compiler is the oracle - use it frequently rather than reasoning through edge cases.