Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/husamettinarabaci/rustexam

🦀 A question-based Rust learning project to master Rust through practice and repetition.
https://github.com/husamettinarabaci/rustexam

coding-challenges exam exercises learning programming questions rust tutorial

Last synced: 9 months ago
JSON representation

🦀 A question-based Rust learning project to master Rust through practice and repetition.

Awesome Lists containing this project

README 

          
# Rust Exam



🚀 **Access all Rust questions and answers live at [www.rustexam.com](https://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](https://www.rustexam.com)



---



# 🦀 Rust Full Mastery Path



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.



## Levels and Sections Overview



Below are all levels and their section titles. For full details and questions, see the `en/QUESTIONS.md` file.



---



## 1. Rustling Initiate

**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:**



1. Getting Started

2. Variables, Constants, and Types

3. Control Flow

4. I/O Basics

5. Functions I

6. Functions II

7. Ownership and Borrowing I

8. Lifetimes I

9. Structs I

10. Structs II

11. Enums I

12. Enums II

13. Modules I

14. Modules II

15. Crates and External Packages

16. Collections: Vectors

17. Advanced Patterns

18. Collections: HashMap

19. Option and Result Types

20. Error Handling

21. Traits I

22. Generics I

23. Generics II

24. Closures and Iterator Basics

25. Closures and Ownership



---



## 2. Certified Rustacean

**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:**



26. Ownership in Complex Structures

27. Lifetimes and Borrowing Semantics

28. Smart Pointers and Interior Mutability

29. Pattern Matching and Control Flow

30. Modules and Crate Structure

31. Enums, Variants, and Algebraic Data Types

32. Traits and Trait Bounds

33. Error Handling with Result and Option

34. Collections and Iterators

35. Testing and Debugging

36. Closures and Functional Techniques

37. Modules and Visibility

38. Ownership Across Function Boundaries

39. Advanced Pattern Matching

40. Working with Strings and Text

41. File I/O and the Filesystem

42. Collections: Vec, HashMap, HashSet

43. Enums and Data Modeling

44. Smart Pointers and Resource Management

45. Lifetimes and Borrowing in Practice

46. Testing and Debugging

47. Workspace and Package Organization

48. CLI Applications with Clap

49. Web Development with Axum

50. Project Design and Refactoring



---



## 3. Builder of Rust Realms

**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:**



51. Async Rust in Depth

52. Embedded Rust Foundations

53. Game Development with Bevy

54. WebAssembly and Frontend with Leptos/Yew

55. Systems-Level Design with Rust

56. Advanced Async Patterns

57. Low-Level Embedded Systems

58. Game Engine Architecture

59. Frontend Framework Deep Dive

60. Systems Programming Mastery

61. FFI and Foreign Interfacing

62. Procedural Macros and Code Generation

63. Advanced Trait Design and Usage

64. Async Patterns and Runtime Internals

65. Performance Optimization and Profiling

66. Unsafe Code Patterns and Safety

67. Domain-Driven Design in Rust

68. Advanced Error Handling and Recovery

69. Macro Rules and Declarative Macros

70. Full-Stack Rust Integration

71. Advanced Ownership: Graphs, Cycles, and Interior Mutability

72. Lifetime System and HRTB Mastery

73. Advanced Trait System and Coherence

74. Trait Objects and VTable Mechanics

75. Pinning and Self-Referential Types



---



## 4. Master of Rust Internals

**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:**



76. Advanced Concurrency and Synchronization

77. Embedded Systems Advanced Topics

78. Advanced Game Development

79. WebAssembly Advanced Topics

80. Systems Programming Advanced Topics

81. Unsafe Abstractions and APIs

82. Advanced Macro Design

83. Compiler Plugins and Custom Lints

84. Cross-Crate API Design and Versioning

85. Advanced Testing and Fuzzing

86. Memory Safety and Static Analysis

87. Async Runtime Implementations

88. Advanced Networking with Rust

89. Embedded Concurrency and Real-Time Systems

90. Domain-Specific Languages (DSLs) in Rust

91. Advanced Parallelism and SIMD

92. Systems Security and Hardening

93. Embedded OS and RTOS Development

94. Rust in Cloud and Distributed Systems

95. Metaprogramming and Reflection

96. Advanced Testing and Formal Verification

97. Compiler Internals and Language Design

98. Profiling and Performance Tuning

99. Language Interoperability

100. Future Rust and Experimental Features



---



## 5. Async Commander

**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:**



101. Async Runtime and Task Management

102. Channels and Message Passing

103. Shared State and Synchronization

104. Actor Model and Message Systems

105. Futures and Async Primitives

106. Async Error Handling

107. Concurrency Patterns and Idioms

108. Tokio Ecosystem Deep Dive

109. Parallelism and Data-Parallel APIs

110. Async Networking and IO

111. Channel Patterns and Advanced Messaging

112. Async Resource Management

113. Actor Frameworks in Rust

114. Synchronization Primitives Deep Dive

115. Testing and Debugging Concurrent Code

116. Async Patterns in Practice

117. Thread Management and Scheduling

118. Lock-Free Data Structures

119. Actor Model Advanced Topics

120. Concurrency Design Patterns

121. Advanced Async I/O and Networking

122. Distributed Systems Fundamentals

123. High-Performance Serialization and Deserialization

124. Microservice Architecture with Rust

125. Rust for High-Assurance Systems



---



## 6. Architect of Rustverse

**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:**



126. Plugin Architectures

127. Embedded Domain-Specific Languages (DSLs)

128. Compile-Time Engines and Metaprogramming

129. Fullstack WASM Applications

130. Microservices and Service Meshes

131. Plugin Systems Advanced Topics

132. Embedded DSLs: Parsing and Compilation

133. Compile-Time Programming Patterns

134. Fullstack WASM UI Frameworks

135. Microservices Architecture Patterns

136. Plugin Security and Isolation

137. DSL Optimization and Code Generation

138. WASM Performance and Debugging

139. Microservices Observability

140. Architectural Refactoring and Evolution

141. Plugin System Testing and Maintenance

142. DSL User Experience and Tooling

143. Compile-Time Performance Optimization

144. WASM Tooling and Ecosystem

145. Microservices Security and Compliance

146. Advanced Plugin Architectures

147. DSLs for Complex Domains

148. Compile-Time Reflection and Introspection

149. Fullstack WASM Application Scaling

150. Future-Proofing Rust Architectures



---



For details on file formats and contribution guidelines, see the `en/FORMAT.md` and `tr/FORMAT.md` files.



# rustExam



Learn Rust by solving progressively harder questions, from beginner syntax to advanced concurrency.



## 🚀 What is this?



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



---



## 🧠 Goal



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._