polyglot-rust-c

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 Create the required output directory and file immediately Verify both compilers are available ( rustc --version , g++ --version or gcc --version ) Set up a rapid iteration loop for testing Phase 2: Incremental Development Strategy Do not attempt to solve everything at once. Follow this progression: Single-language baseline : Write a working solution in one language first (typically C/C++ as it has more flexible syntax) Minimal polyglot shell : Create the simplest possible file that compiles in both languages (even if it does nothing useful) Gradual feature addition : Add functionality piece by piece, testing after each change Phase 3: Iterative Testing After every code change: # 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: Use C-style block comments to hide Rust-specific code from C Use #if 0 blocks to hide C-specific code from Rust 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: Read the error message carefully - it usually points to the exact issue Test the failing language in isolation - comment out polyglot tricks temporarily Simplify - remove features until it compiles, then add back incrementally Document what works - keep notes on patterns confirmed to work Time Management If stuck in exploration for more than a few minutes: Stop theorizing Write the simplest possible attempt Run both compilers Iterate based on actual errors The compiler is the oracle - use it frequently rather than reasoning through edge cases.