1. my_svn

Develop a revision control application. The application must implement the following equivalent functionalities from git:

  • being able to maintain multiple branches;
  • checkout between branches;
  • commits separate on each branches;
  • simple merges;
  • diff between branches and with the previous commit;
  • git status;
  • .gitignore functionality;

2. bit_serde

Write a serialization and deserialization library that will encode values in the smallest possible number of bits. The library will provide a macro similar to #[serde(Serialize, Deserialize)] that will generate the ser/de code. You are not allowed to use the serde crate or any other similar crate for this.

The library will serialize values at the bit level. For instance, a 2 bit value followed by a 3 bit value will be put in the same byte, not in different ones. A u32 value that follows will start whenever the last one left off in the bit stream.

Example code:

#[bit_serde(Serialize, Deserialize)]
struct Player {
    name: String,
    #[max = 100]
    level: u8,
    class: Class,
    race: Race,
    guild: String,
}
#[bit_serde(Serialize, Deserialize)]
enum Class {
    Warrior,
    Assassin,
    Archer,
    Wizard,
    Priest,
    Evocator,
}
#[bit_serde(Serialize, Deserialize)]
enum Race {
    Human,
    Beast,
    Fairy,
}

The String will be serialized as a variable integer (any way) + the utf8 bytes. The level field will be serialized as 7 bits (log2(100) = 6.64). The Class enum only needs 3 bits (log2(6) = 2.58), while Race only needs 2 (log2(3) = 1.58). A bool would only need one bit.

The lib must support all std number types (i8..=i128, u8..=128, bool, char, f32, f64), String, Vec<T> where T: Serialize/Deserialize. The lib will return an error if the fields annotated with #[max] have values that are out of bounds. Alternatively, the lib can provide a type for unusual sized numbers that's implemented using const generics.

3. vfs

Create a library that implements a virtual filesystem. All the data about the virtual files will be kept in a single big file on the real filesystem. The library must support directories and regular files. It must also keep track of the files metadata (size, creation time, last write time). The virtual filesystem must not get corrupted if the application unexpectedly stops.

Usage of SQLite or other libs is not allowed. The management of the real file must be done by hand.

The library must have exhaustive tests to show it's correct. The library must be usable with more than one file at a time. The library must be able to work with files/directories that are too big to be kept in memory all at once. It is ok to have the library only usable from a thread.

Example code:

let vfs = Vfs::open("realfile.vfs");

vfs.create_dir("rs")?;
{
    let mut f1 = vfs.create("rs/abc.txt");
    let mut f2 = vfs.create("rs/def.txt");

    f1.write_all(b"hello")?;
    f2.write_all(b"world")?;
}

let mut data = String::new();
for entry in vfs.read_dir("rs")? {
    let entry = entry?;
    data.clear()

    let mut file = vfs.open(entry)?;
    file.read_to_string(&mut data)?;

    print!("{}", data);
}
println!();

4. offline_messenger

Develop a client/server application that allows the exchange of messages between connected users and provides the functionality to send messages to offline users, with the latter receiving messages when they connect to the server. Additionally, users will have the ability to send a specific reply to certain received messages. The application will also provide conversation history for each user individually. The communication must be encrypted, with different keys for each connection.

5. mclient

Make a CLI chat client for a Minecraft server. The client must be able to:

  • do a status request and print the server status and save the server image to a file
  • connect to a server
  • read the chat in real time and write to it
  • survive the connection indefinitely
  • correctly display colored text and all the formatting that a regular supports
  • print the online players

Tip: Use a version earlier than 1.19.

Resources: protocol, login.

6. taskmanager (windows: unsafe)

Make an application that has a GUI and shows information about the processes currently running on the system. Needed information for each process:

  • process name
  • CPU used
  • memory used
  • path file
  • username of the user

Global information:

  • total cpu used
  • total memory used

There will be two ways to view processes: as a tree, or as list.

The tool must work on at least one of the mainstream OSes (Linux, Windows, Mac).

Resources: Linux, Windows.

7. advanced_rsync

At least two locations are received that need to be kept synchronized (more locations of the same type can be received at the same time). A location has the following format: <LOCATION_TYPE>:<Path_in_location>. Examples:

ftp:user:password@URL/a.b.c
zip:C:/abc/d.zip
folder:C:/aaa

The app runs continuously and keeps the two locations synchronized. Specifically:

  • If a file is created in one location, the file is duplicated in the other location.
  • If a file is deleted from one location, it is also deleted from the other location.
  • If a file is modified in one location, the modification is copied to the other location.

Upon initial startup, synchronization is performed as follows:

  • If a file exists only in one location, it is copied to the other location.
  • If the same file exists in both locations but there are differences, the newest version is copied.

zip archives can be treated as read only, only ftp and folders can change.

8. trap_the_mouse

Implement the Trap The Mouse game. The game will be split in two:

  • a server which hosts the game. The user can create rooms where they wait for other players. When another player joins, the game starts for both players.
  • a client which has a GUI where the user can connect to a room and play the game.

The client also has the possibility to play with the computer. In this case, it still has to connect to the server, and the server is the one that dictates the moves of the mouse.

Resources: wikipedia.

9. k9

Make a discord bot that implements a few commands:

  • quote: will send a random Doctor Who quote
  • doctor : will send a picture with the n-th doctor
  • episode : will search all the titles of all episodes for that text, and print the information about that episode (title, runtime, season/episode number)
  • points: prints a leaderboard with how many points every user has.

The bot will also post random questions about the show at regular intervals (only if the last one was correctly guess). The first user that replies with the correct answer gets a point.

10. tpaste

Make a tool that can be able to upload terminal output to a web service and get a web link that can be shared at the end.

Example usage:

> cat /proc/meminfo | tpaste
https://tpaste.fii/E2WtkyE9LZ

Components:

  • client: the tpaste command will receive the input and make a web request to a service that uploads the received text, and prints the link that it got
  • server: the web service that receives the requests, and resolve them. Additionally, the server hosts a web server so if you to the provided link, it will show the published result. There will also be a page for every user with links to all the pastes they uploaded along with timestamps.

The server also must enforce authentification. The client must have a command where a user can register with a new account and one where the user can login with an existing account. The server will give the client a token that will be kept in a file on the system, so authentication is only done one time. The token will expire after 60 days. The client will send the token at every request and the server will validate it.

11. chess

Implement a GUI Chess application where players interact by dragging and dropping pieces. All the following features must be implemented:

  • A visible sidebar displays the chronological history of all moves made
  • When selecting a piece, all available moves must be highlighted
  • It enforces all standard rules including castling, en passant, and checkmate detection
  • Each player has a total bank of 5 minutes for the entire match -> depleting this time results in an automatic loss
  • Prevents illegal moves and displays the state of the game ("White won", "Checkmate" etc.)

12. TODO list

Develop a GUI Rust application that allows users to manage tasks with clarity and time awareness. Each task should include:

  • title
  • notes
  • independent countdown timer
  • deadline & color-coded deadlines (e.g., red for overdue, yellow for due soon, etc.)
  • method that will prioritize a task

13. weather dashboard

Develop a GUI weather dashboard that allows users to fetch real-time weather from an API and display forecasts. The dashboard should have the following features:

  • display the current weather for a given location
  • display the forecast for the next 7 days
  • display the air pollution index for a given location
  • ability to add/remove a new location to the favorites list
  • a favorites list of locations where the user can quickly access the weather for those locations

14. anime timeline explorer

Develop a GUI anime timeline explorer that allows users to display the chronological order of episodes or arcs for popular series. The explorer should have the following features:

  • display the chronological order of episodes or arcs for a given series
  • display the title, description, and thumbnail for each episode or arc
  • a favorites list of series where the user can quickly access the timeline for those series (also adding/removing series from the favorites list)
  • search filters like title, genre etc. Resources: Jikan API (or another API)

15. tetris

Develop a GUI Tetris game. The following features must be implemented:

  • support keyboard navigation for piece rotation and movement
  • implement score multipliers for clearing multiple lines simultaneously
  • include a game loop with pause/resume functionality
  • include side panels displaying the next upcoming piece and current score