People often use the word evolution to describe the change over time that can be seen in human computer interfaces.

Is there any research that looks at whether human computer interfaces evolve over time, following principles such as survival of the interface best suited to the task or gradual refinement through generations resulting in an interface really well tuned to a particular task?

I'm looking for specific researched examples that demonstrate principles from the theory of evolution evident in the progression of an interface.

  • Are you asking for examples of softwares which have evolved ?
    – Mervin
    Mar 2, 2014 at 15:58
  • yes, or better still studies that look for evidence of evolution in the development of general purpose interfaces, such as a GUI or, outside HCI, car controls
    – Toni Leigh
    Mar 2, 2014 at 16:01
  • 3
    I think you are mixing evolutionary science with UX. There is zero correlation with the principles since they principles of evolution are based on biology. (though...maybe there'll be a crossover once we figure out organic computing and AI...)
    – DA01
    Mar 2, 2014 at 16:12
  • 1
    this describes what I mean: rationalwiki.org/wiki/Evolution#Non-biological_evolution
    – Toni Leigh
    Mar 2, 2014 at 16:49
  • 1
    @DA01 - evolution can apply to much more than biological systems.
    – obelia
    Mar 2, 2014 at 17:23

4 Answers 4


Genetic algorithms have been used to successfully find solutions to complex optimization problems. The algorithms rely on the same basic principles of "survival of the fittest" to improve the solution over time (many hundreds or thousands of iterations). On a basic level, many candidate solutions are generated, then scored, and the worst scoring ones are discarded while the better scoring ones are combined in some way (called cross-over, to simulate "breeding") to form new solutions. The better solutions get to survive to the next iteration (generation), and everything is performed again and again.

The challenge here, is to frame interface design as an optimization problem. Firefox performed an experiment recently with exactly this in mind. Some highlights:

Creating the perfect Firefox interface is a challenging problem. Every user has their own set of common tasks. The challenge is in defining a common “default” interface that maximizes task success for the most people, on the most tasks. Using designer insight alone, it’s not always easy to know the impact of each design element!


Within 700 generations, good candidates started emerging, and by generation 1100, convergence was achieved. We then chose the most visually appealing one as our candidate.

There have been other experiments with generating visual art and music (among others). You should look up "interactive evolutionary computation" for some more papers and background material. The major challenge usually involves scoring the solution quality. For problems that can be framed in a mathematical way, this is quite easy. But for more creative pursuits this is much harder, and you have to encode some underlying set of rules or evaluation criteria (algorithmically determine good design from bad design). If your rules are too simplistic, you could end up with thousands of different solutions that all meet the criteria. If they are too strict, you could end up with no solutions, or all the generated solutions will look the same. That is what makes it so difficult to encode problems rooted in creativity/subjectivity/aesthetics. Interactive evolutionary algorithms usually rely on humans to assign a score ("fitness") to each candidate solution, but this is very labor intensive.

It is an interesting field that has been around for decades, even though it doesn't often get applied to interface design (for the aforementioned reasons).

  • Very interesting, now, can the processes be observed in the wild, so to speak :-)
    – Toni Leigh
    Mar 2, 2014 at 18:09
  • @ColinSharpe In principle, yes. Lets look at browsers. You have a population of interfaces (different browsers). Each browser has a fitness (number of users, or popularity). Each browser has many offspring (alpha and beta tests, new versions). Sometimes these offspring mutate (introduce a new feature found to be popular by users of other browsers). Each offspring either survives or dies (popularity improves, fitness increases), and the interface is said to have evolved. The challenge is in how you define and measure fitness :-)
    – CJF
    Mar 2, 2014 at 18:13
  • Um... About that Mozilla experiment... Does that post make a lot of sense to you? Did you by any chance notice the date it was posted? :) Mar 2, 2014 at 19:51
  • 1
    Well spotted :-) The post made sense from the perspective of an experiment, given that the results were 'odd'. That is actually one of the major critiques of GAs - they are not always easily applicable to real-world problems. I have found some other academic material about using GAs to evolve UIs, but it won't really affect my answer. The principles remain the same. The usefulness will always be up for debate :-)
    – CJF
    Mar 3, 2014 at 7:33

This is a soft science answer, but think about how symbols are added to the collective vocabulary. Symbols indicating new actions are often (and should be) accompanied by words at first:

Twitter Desktop

As people learn a symbol's meaning, the clarifying text becomes red. Sometimes the descriptive text is replaced/removed too soon, and designers provide options to maintain clarity.

Twitter Mobile

You may be able to argue that the words are gone for space constraints, but there's a familiarity with the actions prior to removing/replacing the words.

This idea of collective vocabulary is similar to the patterns learned in culture.

Culture consists of patterns, explicit and implicit, of and for behavior acquired and transmitted by symbols, constituting the distinctive achievement of human groups, including their embodiments in artifacts; the essential core of culture consists of traditional ideas and especially their attached values; culture systems may, on the one hand, be considered as products of action, on the other hand, as conditioning influences upon further action.

This question about learned design patterns is similar (conceptually at least).


Microsoft, Google, and Adobe present examples where interfaces evolve (they change over time) but are selected mainly by engineering pressures rather than pressures encountered "in the wild" (feedback effects from end-users).

  • There had been a trend in Windows versions, from 3.1 to 7, to improve consistency throughout the interface and to make Windows a more effective tool for performing computer tasks. This might be "evolution" as intended to mean in the question. At the same time, Microsoft has been pursuing experimental software projects to maintain a presence in markets it cannot control (examples: .NET, Silverlight), and pursuing these tends to override usability interests. From a usability perspective, it is better to improve existing options than to offer more of similar quality. .NET, especially, drifts because it competes with other versions of itself and cannot be killed, despite end-user concerns about its cancerous size, frequency of security updates, and unclear role in getting work done. Because their goal is probably to win in Apple's market, Microsoft is still pushing Windows 8 and its colored boxes.

  • Google thinks Chrome and Javascript are the greatest things ever, and it has been growing increasingly obnoxious if you don't use them. Worse, their web search mainly uses Javascript to hide the interface. Google typically makes design choices by fiat rather than in response to feedback or anticipation of it (somebody in the company really likes spellchecking, so it is ubiquitous despite its decreasing accuracy). Their response to feedback is to ignore or remove channels for it (try to obtain technical support for Gmail). Google interfaces seem unable to evolve in the intended sense.

  • The Adobe Reader interface is evolving, but not in response to selection by end-users. It is unclear how most features of the program could be useful, why they persist, or why they are introduced (and often mandatory).

  • There seems to be a recent trend toward smaller, less comprehensible icons and more non-interactive animation. That might have an explanation in terms of competing forms of selection.

  • 1
    If you could add some screenshots or links to your answer, it would be much better.
    – PatomaS
    Mar 3, 2014 at 1:09

In the lab, evolutionary analysis can be applied to things like A/B testing. Note here the fitness test is not market share, but something well specified by the experiments designers (e.g. user task success rate or sign-up rate). I would imagine this kind of analysis mainly applies to specific narrow aspects of the UI (e.g. the shade of blue), but this approach could be scaled up/composited to encompass the whole UI, but I don't thing the state-of-the-art is there yet.

In the wild there is some research on the theoretical evolution of software, but I don't think you'll find anything specific to UIs.

Scientifically, it would be difficult to isolate the UI from the software package as a whole in order to apply evolutionary driven analysis to just the UI. This is because it would be difficult to come up with a fitness test that applies mainly to the UI. The most obvious fitness test for software is market acceptance, or simply amount of usage, and an arguably great UI can be paired with a bad backend and the package as a whole will fail. To further muddy the waters, the overall quality of the software is sometimes a minor factor in a fitness test based on market share - bad software can be successfully marketed, and vice versa.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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