What would be a good project for teaching big program concepts?

I think you're onto the right track. I've had great luck teaching these sorts of concepts in Unity, where you are trying to get so many different systems to operate together that architecture really starts to demonstrate its value.

And that's the key; you can't push this much beyond where they can see the value in it.

When I work with middle school students, I only gently lean on students for clean code. I've found that most of what middle school students program is too small in scope for good practice to demonstrate its own value back to the students.

In high school, on the other hand, I have a different tact. I get my initial buy-in to the notion of clean(er) coding by having the kids try to interpret short bits of absolutely abysmal code. (These are very short, and purely meant to demonstrate how very hard code can get to interpret if you don't follow at least some norms. You can see an answer where I have discussed this practice here.)

I will later follow up with code interviews in which they explain code that they created months ago. By this point, they have mostly forgotten what they did, and we can establish the idea that clean code is usually self-explanatory, and that the person who will most likely be editing their old code is... them. And that the person who most benefits, then, from being able to read it is also them.

One huge advantage you have by tutoring (as opposed to a classroom environment) is that code reviews become the most natural way to work, so you get a chance to look over their code in great detail and clarify good practices in ways that feel genuine to the student and their experience. Take full advantage of this, but remember that you will not be able to get buy-in to cleaner coding until they can really feel the benefits.

Good luck!

Here is the set of mini-projects, I've designed but never took in class. So, completely untested, though most of this was either done by me or by my peers back in past.

---

Games:

• Nim game. Any variant
• Tic-Tac-Toe
• Checkers
• Tetris
• Breakout
• Asteroids

Bioinformatics:

• all sorts of algorithms on RNA/DNA:
  • nucleotide frequency analysis
  • comparing genomes, finding best matches (nice one -- check which of coronaviridae RNAs are most similar to NCov-SARS-2019)
  • search most common substrings in RNA (those must be interesting by defintion, especially if they are long)
  • search substrings with N-mutations
  • search for palindromic substrings
  • more alogorithm examples and inspiration at http://rosalind.info/problems/tree-view/ and https://www.bioinformaticsalgorithms.org/bioinformatics-chapter-1
• visualize RNA self-assembly. Build either terminal or arc views. This is real world usage of palindrome algorithm
• visualize DNA replication, create simulation "soup" of nucleotides (A, T, C, G) and enzymes (polymerase, primase, ligase, and others), which all move randomly, and when primase "randomly" finds out primer DNA combination, the replication process starts. There are tons of youtube videos on how this is done, but still nice to see this "soup" in own implementation

Physics:

• simulate ideal billiard -- balls hit balls or walls using Newtonian physics
• simulate ideal gas (similar to above), show pressure as total impulse of balls on walls, and temperature as average kinetic energy of balls. Simulate "volume" change, or "wall temperature" and energy transfer
• car moves on 2D, simulate proper steering, sudden brakes, drift behavior on high speeds, car track and window scrolling when car rides
• gravitation simulator. Either Solar system, or just plenty of bodies all entangled with gravity force

Math:

• implement: all sorts of averages, factorial, integer power, combination count, etc...
• implement: all sorts of irrational functions and computations (sin, cos, sqrt, arctan, arcsin, exp, ln, pi, e, power through exp and ln)
• implement: all sorts of operations with vectors and matrices
• implement: long arithmetics (yeah, I know Python has Decimal, still nice to know how is it done)
• implement: numeric integration (several kinds)

Robo stuff:

• cellular automata (actually, I'll point to this topic here: https://natureofcode.com/book/chapter-7-cellular-automata/)
• labyrinth creation and solving
• implement A* and visualize

Coding theory:

• all sorts of encodings: number bases, UTF-8 encoding, msgpack integers, etc...
• encoding with error detection and correction: random bit errors, duplication as anti-error technique, Hamming code, CRC32
• entropy encoding (Shannon-Fano)
• math expression parser (with parens and operator priority)
• Brainf*ck interpreter
• implement x86_64 assembler, which can compile directly to machine codes. Macros support is optional, but of special interest!

Graphics. All of these should be done using two primitives: putpixel() and getpixel():

• simples: horizontal line, vertical line, rectangle, filled rectangle, thick line
• harder: line between two points, line by one point and angle, circle and filled circle, anti-aliasing drawing for line and circle, draw polygon by it's vertices, flood-fill, rotate square
• complicated: duplicate part of screen with support of alpha channel and color key, mirror part of screen, rotate texture (with arbitrary center), scale texture, pixel blurring after scaling, mirror using guiding line

Psychology:

• implement SRS tool like Anki or Memrise
• implement Schulte test
• implement "Organization of Dot" training puzzle generator
• implement Corsi block test
• implement N-Back

---

Though you wanted some large project, so you can combine several of above into one big project. You may also add topics like "databases" to some of those (the psychology ones -- store all the data in shared DB). The "visualize" are pretty hard projects too.

The big idea for these projects is to ignite more ideas after implementation done.

There are some very good ideas in the answers but have you considered asking your learners to perform a simple task on a very large piece of code? For example, adding a new item to the GIMP about menu or changing the error messages the AWK compiler to include the date of compilation using __DATE__.

I feel that learners are too often presented with exemplar code and rarely with real world code that, for example, contain large sections of Fortran 77 mixed that call libraries of routines written in assembler commented in German.

Many of our lessons concentrate on the need to have well structured and documented code with helpful comments. It is only when confronted with modifying code that the importance of this becomes evident. There are practical difficulties with large software objects for which tools such as grep and sed are very handy, again the importance of this only comes from maintaining code not from writing it.

[ As an adjunct you could introduce your learners to the obfuscated C competition https://www.ioccc.org/ and ask them if they fancy maintaining some of that! ]

I find students really like this approach as they start with something that works e.g. an alpha-beta pruning draughts playing program written in pascal, over which they have rights to augment and modify. This gives the learners a sense of empowerment rather than a feeling that after 10 hours of work they can sort six numbers into order having written a program they know nobody will ever use.

I have also some specially written code for exercises which I have deliberately written to reflect some poor programming practices or code problems which illustrate why techniques for large software projects exist. I have variously, commented out large parts of the code; used #define statements in slightly misleading ways; used inconsistent interfaces etc. The aim then is to get the learners to form criticisms of the code.