Disclaimer: ChatGPT generated document.
In C++, project “size” can be measured in various ways — but typically it refers to the complexity, codebase size, team size, and tooling needs.
There's no strict standard, but here’s a practical breakdown to help you categorize a C++ project as small, medium, or large — based on industry norms and engineering experience.
The following factors are usually considered:
| Factor | Description |
|---|---|
| Lines of Code (LOC) | Total source lines (not including blank lines or comments) |
| Number of files | .cpp + .h + related resource/config files |
| Number of modules | Logical components, libraries, or services |
| Team size | Number of developers actively working on it |
| Build system complexity | Simple Makefile vs. multi-target CMake, cross-platform, or Conan integration |
| External dependencies | 3rd-party libs (e.g. Boost, Qt, OpenCV, etc.) |
| Tooling | Static analysis, CI/CD, unit testing, code coverage, deployment |
| Domain complexity | Algorithms, real-time constraints, security, concurrency, UI, etc. |
Characteristics:
- ≤ 5,000 LOC
- 1–2 developers
- 1–10 source files
- May use STL only, no external libraries
- Basic build system (e.g. single Makefile or CMakeLists.txt)
- Little or no testing, CI, or documentation
Examples:
- CLI tool (file renamer, math utility)
- Coding challenge projects
- Small school or demo projects
- A single-feature GUI or game prototype
Characteristics:
- 5,000 – 100,000 LOC
- 2–8 developers
- 10–100+ source files
- Modular code structure
- CMake, possibly Conan or vcpkg
- Uses external libs (Boost, Qt, SFML, etc.)
- Unit tests (GoogleTest, Catch2)
- CI pipeline (e.g. GitHub Actions, GitLab CI)
- Moderate domain logic (state machines, networking, etc.)
Examples:
- Game engine prototype
- GUI app with plugins
- Networked server-client system
- Medium-scale open-source tools or developer libraries
- Commercial desktop software
Characteristics:
- 100,000+ LOC
- 8+ developers (possibly dozens across multiple teams)
- Hundreds or thousands of files, multiple modules
- Cross-platform support, large CMake tree, automated builds
- Heavy use of 3rd-party and internal libraries
- Strong CI/CD, extensive testing (unit, integration, coverage)
- Documentation, Doxygen, AsciiDoc, UML
- Complex architecture (real-time, multithreaded, embedded, high-security)
Examples:
- Operating system components (kernel modules, drivers)
- Full-featured game engine (e.g. Unreal Engine)
- Automotive software stack (AUTOSAR, embedded systems)
- Financial trading systems
- Large-scale simulation frameworks (physics, robotics, AI)
- Complexity can be high even in small codebases (e.g. cryptography, compiler frontends)
- Tooling makes a big difference — even medium projects can feel large without good structure
- Code quality > quantity — large projects with messy code are harder to maintain than small, clean ones
| Size | LOC Range | Files | Devs | Notes |
|---|---|---|---|---|
| Small | < 5,000 | < 10 | 1–2 | Simple, minimal tooling, fast iteration |
| Medium | 5k – 100k | 10–100+ | 2–8 | Modular, some libs/tools, some complexity |
| Large | > 100k | 100s–1000s | 8+ | Complex architecture, advanced tooling required |