42_examshell: a shell-driven practice environment for 42 school exams

A menu shell around a directory of exercises

42_examshell is an interactive practice environment for 42 school exams covering ranks 02 to 06, and it is worth being precise about what it is: a set of Bash scripts that present a menu and drive a workspace, not a simulator of the exam platform itself.

The repository description calls it a practice exam shell to simulate the official exam environment, updated with a new subject and exercises through rank 02, rank 03 and rank 04. The readme frames the same idea as an interactive practice environment, offering interactive menus and practice exercises for different exam ranks, and says the shell simulates the actual exam environment and helps students prepare effectively.

The top-level entries are five: a .resources/ directory, a Makefile, a README.md, exam.sh and update.sh. The layout of the resources directory is the part that explains the design.

.
├── exam.sh           # Main entry point
├── Makefile          # Build configuration
├── README.md         # This file
└── .resources/       # Practice materials
    ├── main/         # Main menu and interface
    ├── rank02/       # Rank 02 exam exercises
    ├── rank03/       # Rank 03 exam exercises
    ├── rank04/       # Rank 04 exam exercises
    ├── rank05/       # Rank 05 exam exercises
    └── rank06/       # Rank 06 exam exercises

So the menu and the interface live in .resources/main/, and each rank has its own directory of exercises alongside it. That split is the architecture in one listing: a dispatcher in exam.sh, a menu under main/, and the exercise content partitioned by rank so that adding a rank means adding a directory rather than editing the entry point.

The primary language is Shell, the default branch is main, and the last push was on 2026-08-14. The repository has no GitHub releases, and the recorded licence is unknown, which for a shell script collection that students copy into their own workspace is worth a glance before you redistribute it.

The readme says contributions and improvements are welcome to enhance the learning experience, and the target audience is 42 school students preparing for exams, anyone practicing C programming and system administration, and students wanting to simulate exam conditions.

Running it, and the Makefile that is one line long

Installation is a clone and a run, with no package manager and no build step in the usual sense.

   git clone https://github.com/terminal-42s/42_examshell
   cd 42_examshell

Then either make or a direct invocation of the script.

   make

   bash exam.sh

The Makefile in the repository confirms there is nothing else to it. The whole file is a single target.

all:
	@bash exam.sh

That is worth noting for what it tells you about the project's shape. There is no compilation, no dependency resolution and no configuration file. The Makefile exists so that a student types one word and gets the shell, and the tab-prefixed at sign means the command runs silently, so the terminal shows the menu rather than a make banner.

The requirements are equally short: a Bash shell, a Unix-like operating system on Linux or macOS, and a terminal with colour support, which the readme marks as recommended rather than required. The colour matters more than the word recommended suggests, because the interface is described as a clean, colourful terminal interface, and on a terminal without colour the same scripts will still run but the menu loses the visual separation between options.

The readme also notes that there is a complete example in the repository so you can preview the library on your device, and points at a Quick Start page in the wiki for adding it to your own project. The wiki is where a fuller walkthrough lives, since the readme itself is a short orientation rather than a manual.

Two behaviours are worth planning for before you start. The first is that the shell creates a rendu folder for you, which is where you write and test your solutions. The second is that the shell can update itself, which is convenient and is also the one thing to think about before you have started an exercise.

The eight menu options and what each one does

The main menu is a numbered list, and reading it tells you what the tool is trying to be.

Option 1 is Commands, giving access to a command reference and practice. Options 2 through 6 are the exam ranks: Exam Rank 02, Rank 03, Rank 04, Rank 05 and Rank 06. Option 7 opens the Rendu Folder, the submission workspace. Option 8 is Update Shell, which keeps the exam shell up to date with the latest features.

The structure of that menu mirrors the exam itself. You pick a rank, you are given exercises, you work in a directory that is laid out like the real submission folder, and the shell has helpers for the Unix commands you are expected to know. Option 7 exists because the rendu folder is where your work lives and being able to open it directly from the menu is the difference between practising and merely reading.

Option 8 is the interesting one from a design point of view. The readme describes an automatic update mechanism, reachable either from the main menu or manually.

# From the main menu, select option 8: Update Shell
# Or manually run:
bash update.sh

The update script will check for latest changes from the repository, display available updates before pulling, download and apply all updates automatically, update file permissions for test scripts, and return you to the main menu when complete.

Two details there are worth attention. The script shows what is available before pulling, so it is not a blind overwrite, and it fixes permissions on the test scripts after applying the update, which is necessary because an update that loses the executable bit on the testers would break the exercises silently.

The auto-return to the main menu is a small thing that makes the tool feel like one program rather than a sequence of scripts, and it is the kind of detail you only notice when it is missing.

The readme closes that section by saying to stay tuned for new exam ranks, improved testers and additional features, which tells you the exercise content is expected to change as the school updates its exams.

What is covered, and what the practice exercises actually are

The readme lists what each rank is meant to cover, and it maps directly onto the 42 school curriculum.

Rank 02 is fundamental C programming concepts. Rank 03 is advanced C programming and system calls. Rank 04 is complex algorithms and data structures. Rank 05 is advanced C++ programming and object-oriented design. Rank 06 is advanced system programming, with mini_db and mini_serv named as the exercises.

That progression is the pedagogical point of the tool. A 42 school student moves through ranks in order, and the exercises here follow the same progression, so practising rank 02 is practising the C basics that rank 03 assumes.

What the tool does not contain is worth being clear about, because it is the most likely misunderstanding. The repository provides practice material and testers, not the graded exam subjects. The real exams at 42 school are timed, held on the school's own platform, and use exam questions the school keeps private. A practice shell can reproduce the environment, the file layout and the exercise subjects, and it cannot reproduce the actual graded questions.

So the honest framing is that this is a rehearsal space. It gives you a place with the right folder structure, the right tooling, and exercises of the right shape, so that when you sit the real thing the mechanics are not what surprises you.

The readme is also clear about the audience and the practice environment's limits. It is a practice tool to sharpen skills before the real exam, it is designed for 42 school students, and for anyone practicing C programming and system administration, and for students wanting to simulate exam conditions.

The workspace is where the exercises happen. The shell automatically creates a rendu folder where you can write your solutions, test your code and practise exam submissions. The readme's numbered how-to-use sequence is the whole workflow: launch with make or bash exam.sh, select a rank or the practice option, follow the on-screen instructions, complete exercises in the automatically created rendu folder, and use the practice environment to simulate real exam conditions.

What this tool is, and where a different approach fits better

Two limits are clear and one alternative is worth naming.

The first limit is the environment. Bash on a Unix-like system with a colour-capable terminal, and nothing else. There is no Windows path, no web version and no container image mentioned in the readme. For a student on Linux or macOS, which is the normal case at 42 school, that is a non-issue. For anyone else it is a wall.

The second limit is the scope of the simulation. The shell reproduces the menu flow, the rank structure, the workspace and the command reference. It does not reproduce the exam platform's timing, its subject generation, its submission checking or its scoring. Practising here builds familiarity with the routine; it does not tell you whether you are ready.

The alternative that deserves the comparison is doing the exercises yourself without a shell. The 42 school exercises are public in the sense that the subjects and the subjects' subjects are handed out in the piscine, so a student can already work through them in a plain directory with a Makefile and the school's testers. The shell's value on top of that is the ergonomics: the menu removes the need to remember where each rank's exercises live, the command reference covers the Unix basics that the ranks assume, and the auto-created rendu folder means you do not have to reconstruct the expected layout.

For a student who already knows the layout and has the testers, the shell is optional. For a student who has just started and does not yet know what a rank 04 submission is supposed to look like on disk, it removes a whole class of confusion.

There is also the question of self-updating code, which option 8 makes explicit. A shell that pulls updates over the network and applies them is convenient for a student whose school updates the exam requirements, and it is worth being aware that the update path is a network fetch followed by file replacement and a permission fix. Read what option 8 pulls before you run it on a machine with anything else on it.

The last thing to say about this project is that it is small and legible by design. Five top-level entries, a directory per rank, and a Makefile with one target. A student can read the whole thing, and a contributor can add a rank without a build system in the way.

Editorial conclusion

42_examshell fits a 42 school student who wants a local, offline environment that mirrors the exam flow, with the exercise files and the submission workspace laid out the way the real thing expects. It does not fit a student who needs the actual exam questions, because the repository provides practice material and testers rather than the graded subjects, and it needs Bash on a Unix-like system with a colour-capable terminal. Before running it, look at the .resources/rank02 through rank06 directories and the Makefile, whose single target is bash exam.sh, so you know what the shell will launch and where it will write.

Frequently asked questions

Official sources

1. Issues
2. README
3. terminal-42s/42_examshell on GitHub