What a graphical interface is
A graphical user interface, usually shortened to GUI, lets people work with a computer by looking at and pointing to things on a screen instead of typing commands from memory. The familiar elements are windows (separate rectangular areas for separate tasks), icons (small pictures standing for files, programs or actions), menus (lists of available commands) and a pointer moved by a mouse or similar device. Together these are often called WIMP, for windows, icons, menus and pointer.
Before this style became common, most people who used computers did so by typing. Early machines took punched cards or paper tape, and later interactive systems offered a command line, where the user typed a short instruction and read the text that came back. That approach is precise and fast for people who know the commands, but it asks a beginner to remember a vocabulary that nothing on the screen reveals.
Early ideas in the 1960s
The graphical interface was not invented in one place on one day. Several lines of research in the 1960s pointed the same way. One of the best known is Ivan Sutherland’s Sketchpad, from the early 1960s, in which a person drew and changed shapes on a display using a light pen. It showed that a screen could be something to interact with directly, not only something to read, and it became a landmark in interactive graphics.
Around the same time, Douglas Engelbart and his team at the Stanford Research Institute worked on a system for augmenting human thinking. A public demonstration in 1968 showed on-screen text editing, linked documents, shared screens and an early mouse. It did not look like a modern desktop, but many of its ideas, including pointing at things and working with several views of information, fed into later work. Other groups explored similar territory, and credit for the overall direction is widely shared.
Research labs in the 1970s
In the 1970s, researchers at Xerox’s Palo Alto Research Center built experimental personal workstations in which a bitmapped display, where each dot of the screen can be controlled, replaced the fixed grid of characters used on most terminals. A bitmapped screen made it possible to show different type styles, pictures and overlapping windows. The same period produced the idea of a desktop as a metaphor, with documents and folders standing in for paper on a desk, and of menus that let a user choose rather than recall. The story of how those ideas were shared, borrowed and rebuilt by other companies is often told in oversimplified ways, and the full account of Xerox PARC and its visitors deserves its own careful treatment.
Researchers also made a quieter but important discovery: ordinary people could test an interface, and their struggles could be used to improve it. Designing for the person at the keyboard, rather than for the machine, became a field of its own.
Reaching the public in the 1980s
The first commercial products with these ideas were expensive and sold in limited numbers. Xerox released a workstation with a graphical interface in the early 1980s, and Apple’s Lisa followed in 1983. The Macintosh arrived in 1984 at a lower price and is the machine most people associate with the moment the graphical interface reached a broad audience. Other systems soon appeared from various makers, and Microsoft released the first version of Windows in the mid-1980s as a graphical layer on top of its older command-line system. Early versions were limited, and it took several years for graphical environments to become the normal way to use personal computers.
Hardware mattered as much as design. A graphical screen needs more memory and processing power than a text display, and for years that made graphical machines costly. As prices fell and operating systems took on the work of drawing windows and handling the pointer, software makers could assume that users had a graphical screen. Programs written for such an environment shared common menus, dialog boxes and keyboard shortcuts, so that learning one program taught something about the next. That consistency may be the most lasting practical gain.
What changed for ordinary users
The main effect was that computers became approachable for people who had no interest in learning commands. Choosing from a menu is easier to discover than recalling a command, and a picture of a folder gives a hint about what a file is. Tasks that depend on seeing the result, such as page layout, drawing, photo editing and later web browsing, suited the graphical approach especially well and grew alongside it. Programs that showed the page as it would print, such as the word processors that began to replace typewriters, were one visible example.
The graphical interface also changed who wrote software. Programmers now had to think about event-driven designs, where the program waits for clicks and key presses, rather than a fixed sequence of questions and answers.
What did not change
It is easy to overstate the shift. The command line did not disappear. Many programmers, system administrators and scientists still prefer typed commands for tasks that are repetitive, scriptable or performed on remote machines, because a typed command can be saved, repeated and combined with others in ways that clicking cannot. Graphical systems often include a text window for exactly this reason.
There were trade-offs, too. Menus can hide features several levels deep, icons are not always self-explanatory, and a pointer-driven interface is harder to use for people who cannot see the screen or cannot operate a mouse, unless the software is designed with accessibility in mind. Graphical systems also demand more from the hardware, and a screen full of windows can be as confusing as a page of commands.
Later technologies built on the same ideas rather than replacing them. Touch screens on phones and tablets dropped the mouse pointer, but kept icons, windows in a modified form and menus. The desktop metaphor itself has been stretched, and many people now work in a browser where the line between files, programs and web pages is blurred. Even so, the underlying proposition of the graphical interface, that the screen should show what the user can do and respond to direct action, remains the starting point for most everyday computing.