iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
A shell looks simple until you try to make its commands behave like a shell’s. Reading a line and starting a process is only the beginning: built-in commands need different handling, executables must be found, and quoted text must become the right arguments. In separate project accounts, Mouad Benali describes discovering that quoting and variable expansion made his parser unexpectedly complex, while Leon Long’s Rust project shows how a small shell can grow one feature at a time.
What a small shell needs to do
A useful first version can be divided into a few distinct jobs: read a command line, interpret it, handle shell-specific commands, find an external executable, and launch that program. Keeping those jobs separate makes it easier to tell whether a bug comes from parsing, command classification, lookup, or process execution.
Leon Long’s July 27, 2026 project account describes a REPL with exit, echo, type, executable lookup through PATH, cd, and pwd. These are features of Long’s project, not a feature list for Mouad Benali’s separate attempt. Long also reports beginning single-quote parsing, while noting that double-quote support was still in progress. Long’s project account
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Built-ins are not ordinary processes
Commands such as cd and exit are handled by the shell itself. For example, changing the working directory in a child process would not change the shell’s own directory after that process ends. By contrast, an external command is located and run as a separate process. Long’s implementation makes this distinction visible in the project’s command handling.
#1 Best Overall
Executable lookup is only one stage
For an external command, the shell needs to resolve the command name—Long’s project searches directories in PATH—and then invoke the program with its arguments. That is meaningful progress, but it does not settle how the command line should be divided into those arguments. That question belongs to parsing.
Why splitting on spaces fails
Consider echo blah blah "string in quotes". Splitting the line wherever there is a space produces separate pieces for the words inside the quoted phrase, even though the user intends them to form one argument. T.J. Telan used this kind of example to show the failure of a simple space split in a 2017 shell-building tutorial. Telan’s tutorial
Rank #2
Quotes are not merely characters to remove after splitting. The parser has to recognize when spaces separate arguments and when they are part of an argument. Benali describes a further complication: quoted and unquoted text can sit next to each other and still form one argument. Once that behavior matters, a line is no longer just a list of words.
Free tools Windows power users keep installed
One-click scans. No signup required.
How quoting turns parsing into language design
Benali’s separate DEV Community account focuses on how the parser grew more complicated than expected. In particular, double-quoted text can include variables that need to be resolved without necessarily splitting the resulting text into multiple arguments. That means parsing and expansion interact: the implementation must preserve which parts of the input were quoted, determine where argument boundaries belong, and apply the relevant expansion behavior.
Rank #3
This is why adding a few quote checks to a whitespace split tends not to be a durable solution. A parser needs explicit rules for how input becomes tokens and arguments. Each supported feature adds cases to those rules, and the interactions—not just the individual features—are where mistakes appear. Benali describes repeated rewrites while learning Rust and shell behavior together. The DEV page displayed September 25 without establishing a year, so no year can be attached to that account. Benali’s account
Choose a parser approach that fits the goal
For a learning project, writing a small parser directly can make the rules tangible: you decide what counts as an argument, what quotes do, and which features to support. The trade-off is that every rule and edge case becomes your responsibility. Long’s account describes considering a parsing library after writing a basic parser; the project accounts do not provide a controlled comparison of speed or correctness, so there is no basis for a performance verdict.
A parsing library can reduce implementation work, but it is only a fit if its behavior matches the shell syntax your project intends to support. A library that handles one subset of syntax does not automatically reproduce every shell’s rules. Before choosing, define the scope: for example, whether the project needs single quotes, double quotes, adjacent quoted and unquoted segments, or variable expansion. The accounts do not establish one universally best library or a complete syntax target.
Long describes CodeCrafters as a step-by-step guide and testing platform used in the context of building the project. A guided challenge can supply structure and tests, but passing a test does not replace understanding the behavior being implemented. Current challenge availability and pricing are not established here.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.A practical order for building and testing
- Start with the command loop. Read a line, display a prompt, and handle the decision to continue or exit. Telan’s 2017 tutorial points out a small but important terminal detail: flush standard output after writing a prompt so it appears before the program waits for input.
- Add built-ins separately. Implement shell-owned behavior such as exiting and changing directories before routing other command names to external execution.
- Resolve and launch external commands. Add executable lookup through
PATHand pass the parsed arguments to the child process. - Define parsing behavior before expanding it. Test ordinary words and quoted phrases first; then add adjacent quoted and unquoted text and variable expansion only if they are in scope.
- Keep edge cases explicit. Use tests to distinguish a single argument containing spaces from multiple arguments, and to verify what happens when quoted and unquoted segments touch. Rust’s ownership model also affects how a parser represents and passes command data; Telan discusses this as part of the implementation challenge, though his 2017 tutorial is a learning example rather than current Rust documentation.
What the project teaches
The central lesson in both accounts is not that launching a process is unusually difficult. It is that a shell defines rules for interpreting text before a process ever starts. A modest command loop is a useful milestone, but quoting reveals that the shell is also a language interface with tokenization and expansion semantics. Keeping those responsibilities visible—and limiting syntax to a clearly stated target—makes the project easier to reason about than treating the whole command line as a string to split.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
