I'm taking a software design class where I should choose an open source software to analyze from the Software Design point of view.

It has to be a big project: not less then 100,000 lines of code.

I would really like to choose a software that is very well designed and architected to have good insights on good software design.

By good design I mean things like meaningful classes and architecture, good use of (design) patterns, good use of abstraction, good organization of components, high cohesion and low coupling between components, etc...

Do you have any software to suggest me?

Note that the software just need to have a good design, the design does not need to be documented! :)

It does not need to be an application for the end user... It can also be a library, a tool, etc...

  • 3
    Why ask us? What interests you? If I suggested an accounting package and you find accounting boring, it wouldn't be a good answer would it? What kind of package interests you? Look at those first, then ask us about specific packages you looked at.
    – S.Lott
    Mar 31, 2011 at 10:08
  • Thanks for pointing it out. I have to say that software development tools would be of interest to me. Mar 31, 2011 at 10:18
  • Any particular platform you'd like to use?
    – user1249
    Aug 7, 2011 at 18:05
  • 3
    Take a look at The Architecture of Open Source Applications which describes a number of well designed open source applications.
    – Richard
    Aug 8, 2011 at 7:14
  • The lines of code measure is ambiguous. The size of the executable and all the dlls that it depends on might tell you something. if there is a good library out there, it only makes sense to use it. Then, do I count the lines of the library as part of my total LOC count or not? I would say that many of the frameworks (libraries, APIs, SDKs, or whichever name you prefer) tend to be very good (they get hit a lot from every angle, so bug are quick to find and should be quick to fix) . Since good coders will leverage other good libs, the actial LOC need not be large for a complex application.
    – Job
    Aug 28, 2011 at 17:59

11 Answers 11


By good design I mean things like meaningful classes and architecture, good use of design patterns, good use of abstraction, good organization of components, high cohesion and low coupling between components

First, a software, good or bad, doesn't live in solitude – it models a real world scenario which humans conceive of as a problem and thus is always associated closely with something called an "application domain". So, whenever you talk about software, first know and study the domain – for only then you can attain the discretion of good and bad.

  • git – not just good, but an amazing design. It is not a version control at its core, just a file system. A thin veneer of functionality on top of the core makes it a version control system. Get to know the internals of git, and your sense of software design will be enlightened.

  • jQuery – not a very well (internally) documented library, but an inspiring source demonstrating how client side JavaScript code can do wonders.

  • NodeJS – if you're into making servers this project has refreshingly new ideas and patterns to offer.

  • v8 – very good C++ code, fantastic library to learn/study virtual machine implementations.

  • NoSQL projects – Couch, Mongo, Redis, Cassandra – these projects demonstrate smart ways to solve persistence problems. Also they embrace the idea of polyglot persistence.

  • Boost libraries – good dose of C++.

  • OpenStack – very good projects on cloud computing and virtualization.

  • The Apache Software Foundation – Choose any of their projects and study it. HTTPd's modular structure is a great source if you want to see how components come together. APR (apache portable runtime) – a really good lib also.

  • mod_wsgi – one of the best C programs I've come across.

"good use of design patterns" – it is NOT important for the code to correspond to a well known design pattern – it is more important that it solve the problem "smartly" – that it is maintainable, reusable and readable. If code is crammed into a particular "shape" – just to adhere to a design pattern – it can be bad code.

"not less then 100,000 lines of code" – since when did the number of lines become a metric of good quality – getting a taste of "well designed/architectured software" doesn't require it to be BIG.

Again, remember to study the nature and nuances of the problem domain first, and then delve into reading the code.

UPDATE: Oct. 2015

InfluxDB -- https://influxdb.com/ This Go project is under active development, and is still NOT very complex. So you can get started with digging into code relatively easily than something like OpenStack.


Toss a coin. All large Open Source projects have to be brilliant to survive. Apache, Linux, GNU projects are all brilliant.

  • 4
    All large community-run OSS projects have to be at least decent to survive. Wouldn't say brilliant. For things that are mostly say, government projects done exclusively by employees, code quality isn't always the highest thing on a priority list. But +1 for your examples.
    – TZHX
    Mar 31, 2011 at 10:14
  • 8
    is Wordpress brilliant?
    – Drew
    Aug 28, 2011 at 13:16
  • Chrome
  • Firefox
  • Apache
  • MySQL
  • PostgreSQL
  • Linux
  • GNU
  • 2
    Are you sure Firefox isn't littered with stagnate pieces of code written in the early 90s? That doesn't seem to be a good piece of code for studing modern coding practices
    – TheLQ
    Aug 8, 2011 at 3:35
  • 3
    The source code for Firefox and MySQL are horrible pieces of crap that should never be used as examples of good software design.
    – Jordan
    Mar 2, 2012 at 8:06

Python. Specifically, CPython, the primary implementation. For Version 3.2, the interpreter runs about 50k sloc of C code, standard library over 400k sloc of Python code. Given the extremely high quality of the language and its encouragement of the principles of readability and good design, I would think all of this code would be quite good.


TeX along with MetaFont are really worth a study: http://www.tug.org/

Your local library can help you with printed versions of the sources.


I would recommend to read the following book before choosing an open source project. This will give you insight into what can be considered good/bad code.

Greg Wilson
Making Software What Really Works, and Why We Believe
The Architecture of Open Source Applications

Here also is his Blog stack exchange interview if you're interested in listening to the author before looking into his

Overall what is considered high quality software? The question itself is very subjective. Users have different measurement of quality. One user may consider the software package to be high quality depending on technical merits. Where another users may gauge quality based on aesthetics of the user interface and the overall user experience.

From a business perspective they typically measure software quality depending on if it either meets the client's expectations or they're meeting the contractual obligations of a client. There is also professional conduct but that depends on which side of the fence you view it from.

From a programmers point of view, how elegant is the design and constructs of the API at the time when the software was created. The same design or code standard may be considered to be unprofessional when attitudes and views of programmers change over time.


I will suggest the IntelliJ Community Edition since you mention that you like software tools.


What I like about it:

  1. It is a tool that does something rather than a framework
  2. They do really interesting things like static code analysis and data flow analysis I find really enjoyable to see the details of.
  3. A nice thing is that you can use it to perform your study since it has the ability to run all the code analysis on itself as well.

(admittedly I am a JetBrains fanboy)


I have been looking for such a project myself, and settled for CLang.

  • It is relatively new (offspring of LLVM which is only 10 years old), so no (or not that I have seen) stale code
  • A modular design (as LLVM), extremely well thought out, which I think is very important nowadays
  • Very clean code, well commented (you often see quotes from the Standard to explain things)
  • A very nicely designed test-suite/test-environment

There are not many Design Patterns there, a few Visitors here and there but that's about it. The class hierarchies are simple, and straight-forward... Actually, I think simplicity is the goal, there does not seem to be any over-engineering going on.

That said, being performance critical, a number of design decisions might seem dubious (avoiding virtual functions for numerous objects, compiling without RTTI/exceptions), so not everything is applicable to everyday software.


Blender is well structured and well designed.


Joomla, its very well done. But I am not sure if its 100,000 lines


So, just another variant - What about Nemerle programming language ?

It's not so popular ( but GitHub just added highlighting for Nemerle) and you can find many good points there.

Not the answer you're looking for? Browse other questions tagged or ask your own question.