🚀 Access all Rust questions and answers live at www.rustexam.com!
- The platform supports both Turkish and English.
- You can browse, search, and practice all questions and answers online.
- Visit now: www.rustexam.com
This repository contains a comprehensive set of 1500 Rust programming questions and answers, organized into 6 levels. Each level contains 25 sections, and each section contains 10 questions, with both Turkish and English support.
Below are all levels and their section titles. For full details and questions, see the en/QUESTIONS.md file.
Foundations: Variables, Functions, Control Flow, Ownership
Build the essential foundation in Rust. Learn type system, ownership and borrowing, match statements, and how the compiler helps you write safe code.
Sections:
- Getting Started
- Variables, Constants, and Types
- Control Flow
- I/O Basics
- Functions I
- Functions II
- Ownership and Borrowing I
- Lifetimes I
- Structs I
- Structs II
- Enums I
- Enums II
- Modules I
- Modules II
- Crates and External Packages
- Collections: Vectors
- Advanced Patterns
- Collections: HashMap
- Option and Result Types
- Error Handling
- Traits I
- Generics I
- Generics II
- Closures and Iterator Basics
- Closures and Ownership
Intermediate Rust: Structs, Enums, Error Handling, Modules, Crates
Learn to design reusable types, organize your code in modules and crates, manage errors idiomatically, and use Rust’s standard collections effectively.
Sections:
- Ownership in Complex Structures
- Lifetimes and Borrowing Semantics
- Smart Pointers and Interior Mutability
- Pattern Matching and Control Flow
- Modules and Crate Structure
- Enums, Variants, and Algebraic Data Types
- Traits and Trait Bounds
- Error Handling with Result and Option
- Collections and Iterators
- Testing and Debugging
- Closures and Functional Techniques
- Modules and Visibility
- Ownership Across Function Boundaries
- Advanced Pattern Matching
- Working with Strings and Text
- File I/O and the Filesystem
- Collections: Vec, HashMap, HashSet
- Enums and Data Modeling
- Smart Pointers and Resource Management
- Lifetimes and Borrowing in Practice
- Testing and Debugging
- Workspace and Package Organization
- CLI Applications with Clap
- Web Development with Axum
- Project Design and Refactoring
Applied Rust: Web, CLI, Game Development, Embedded, and WASM
Use Rust in real-world applications: write REST APIs with Axum, build interactive CLIs with Clap, develop games using Bevy, program embedded devices, and compile Rust to WebAssembly.
Sections:
- Async Rust in Depth
- Embedded Rust Foundations
- Game Development with Bevy
- WebAssembly and Frontend with Leptos/Yew
- Systems-Level Design with Rust
- Advanced Async Patterns
- Low-Level Embedded Systems
- Game Engine Architecture
- Frontend Framework Deep Dive
- Systems Programming Mastery
- FFI and Foreign Interfacing
- Procedural Macros and Code Generation
- Advanced Trait Design and Usage
- Async Patterns and Runtime Internals
- Performance Optimization and Profiling
- Unsafe Code Patterns and Safety
- Domain-Driven Design in Rust
- Advanced Error Handling and Recovery
- Macro Rules and Declarative Macros
- Full-Stack Rust Integration
- Advanced Ownership: Graphs, Cycles, and Interior Mutability
- Lifetime System and HRTB Mastery
- Advanced Trait System and Coherence
- Trait Objects and VTable Mechanics
- Pinning and Self-Referential Types
Systems-Level Rust: Unsafe Code, FFI, Macros, Trait Objects, and Compiler Control
Dive into low-level capabilities: use unsafe blocks, interface with C code, build macros (macro_rules! and procedural), understand trait objects, and learn about MIR and monomorphization.
Sections:
- Advanced Concurrency and Synchronization
- Embedded Systems Advanced Topics
- Advanced Game Development
- WebAssembly Advanced Topics
- Systems Programming Advanced Topics
- Unsafe Abstractions and APIs
- Advanced Macro Design
- Compiler Plugins and Custom Lints
- Cross-Crate API Design and Versioning
- Advanced Testing and Fuzzing
- Memory Safety and Static Analysis
- Async Runtime Implementations
- Advanced Networking with Rust
- Embedded Concurrency and Real-Time Systems
- Domain-Specific Languages (DSLs) in Rust
- Advanced Parallelism and SIMD
- Systems Security and Hardening
- Embedded OS and RTOS Development
- Rust in Cloud and Distributed Systems
- Metaprogramming and Reflection
- Advanced Testing and Formal Verification
- Compiler Internals and Language Design
- Profiling and Performance Tuning
- Language Interoperability
- Future Rust and Experimental Features
Advanced Concurrency: Async Programming, Tokio, Channels, Actor Models
Master Rust's concurrency tools: work with async/await, spawn tasks with Tokio, coordinate with channels, implement actor-based systems, and use thread-safe containers and lock-free structures.
Sections:
- Async Runtime and Task Management
- Channels and Message Passing
- Shared State and Synchronization
- Actor Model and Message Systems
- Futures and Async Primitives
- Async Error Handling
- Concurrency Patterns and Idioms
- Tokio Ecosystem Deep Dive
- Parallelism and Data-Parallel APIs
- Async Networking and IO
- Channel Patterns and Advanced Messaging
- Async Resource Management
- Actor Frameworks in Rust
- Synchronization Primitives Deep Dive
- Testing and Debugging Concurrent Code
- Async Patterns in Practice
- Thread Management and Scheduling
- Lock-Free Data Structures
- Actor Model Advanced Topics
- Concurrency Design Patterns
- Advanced Async I/O and Networking
- Distributed Systems Fundamentals
- High-Performance Serialization and Deserialization
- Microservice Architecture with Rust
- Rust for High-Assurance Systems
Architectural Rust: Plugins, DSLs, Compile-Time Engines, Fullstack WASM
Design scalable and elegant Rust software: implement plugin systems, build embedded DSLs, perform compile-time checks, create fullstack WASM-backed applications, and microservice-based systems.
Sections:
- Plugin Architectures
- Embedded Domain-Specific Languages (DSLs)
- Compile-Time Engines and Metaprogramming
- Fullstack WASM Applications
- Microservices and Service Meshes
- Plugin Systems Advanced Topics
- Embedded DSLs: Parsing and Compilation
- Compile-Time Programming Patterns
- Fullstack WASM UI Frameworks
- Microservices Architecture Patterns
- Plugin Security and Isolation
- DSL Optimization and Code Generation
- WASM Performance and Debugging
- Microservices Observability
- Architectural Refactoring and Evolution
- Plugin System Testing and Maintenance
- DSL User Experience and Tooling
- Compile-Time Performance Optimization
- WASM Tooling and Ecosystem
- Microservices Security and Compliance
- Advanced Plugin Architectures
- DSLs for Complex Domains
- Compile-Time Reflection and Introspection
- Fullstack WASM Application Scaling
- Future-Proofing Rust Architectures
For details on file formats and contribution guidelines, see the en/FORMAT.md and tr/FORMAT.md files.
Learn Rust by solving progressively harder questions, from beginner syntax to advanced concurrency.
This is a structured, open-source Rust challenge that helps you master Rust through practice – one question at a time.
Each question includes:
- Topic-based sections
- Real code snippets
- Markdown-exportable Q&A blocks
Create a high-quality, community-driven educational repository to help Rust learners grow through real code.
💡 Contributions welcome! Fork the repo and help build the ultimate Rust challenge platform.