Peripheral
A peripheral is any device that connects to a computer's central processing and memory to give it a way to receive input, produce output, or store data, without being part of the core that executes instructions. The word comes from the idea of the periphery: the CPU and main memory form the center, and everything that talks to the outside world, whether a keyboard, a screen, a printer, a camera, an external drive or a game controller, sits around that center and communicates with it through some kind of interface. A computer with no peripherals still computes, but it can neither be told what to compute nor show its answer, so in practice peripherals are what turn a processor into a tool people can use.
Peripherals are traditionally sorted by the direction data flows relative to the computer: input devices send data in, output devices take data out, and storage or communication devices do both. A keyboard, mouse, microphone, scanner and webcam are input devices; a monitor, speaker and printer are output devices; an external SSD, a network adapter and a USB flash drive move data in both directions. The sorting is a useful first approximation rather than a strict law, since a touchscreen is input and output at once and a printer also reports its ink level and paper jams back to the machine. The same split holds for built-in parts: the screen and trackpad of a laptop are peripherals that happen to be bolted to the chassis, which is why the more useful test is not whether something is external but whether it sits outside the processor-and-memory core and is reached through an I/O path.
A peripheral does not talk to the CPU directly; it is managed by a controller, reached over a bus or port, and made usable by a device driver in the operating system. The controller is a small chip, often with its own firmware, that turns the device's electrical behavior into a standard protocol such as USB, SATA, PCI Express or Bluetooth. The driver is software that knows that device's quirks and presents it to programs through a uniform interface, so an application can say save this file or draw this window without knowing which brand of drive or graphics card is installed. Peripherals usually signal that they need attention through interrupts, which let the CPU keep working until a key is pressed or a packet arrives, and bulk transfers such as disk reads use direct memory access, in which the controller copies data into RAM without the CPU moving each byte. Standards that allow plug and play, where a device announces what it is and the system loads the right driver, are what make modern peripherals feel effortless.
Peripherals differ enormously in speed, and the system is designed around that gap. A keyboard produces a few hundred bytes per second at most, while an NVMe solid-state drive can move several gigabytes per second and a graphics card exchanges data with memory at rates higher still. Because the CPU is millions of times faster than a human finger, the operating system buffers and schedules I/O so that slow devices never stall fast ones. The same logic explains why graphics cards and AI accelerators, which are expansion cards in the PCIe slots of a workstation, are treated as peripherals in the architectural sense even though machine learning engineers think of them as the main source of computing power: they sit across a bus from the host processor, have their own memory and are driven through a driver stack such as the one that CUDA depends on.
A common misconception is that the peripherals are the computer, because they are the parts that people touch. The monitor is not the computer, and neither is the keyboard; the system unit that holds the processor, memory and storage is. Another frequent confusion is assuming that a faulty peripheral means a faulty computer, when a missing or outdated driver is often the actual cause, which is why a device that works on one machine may fail on another that lacks the right software. There is also a security dimension: because peripherals have their own firmware and are trusted by the system, a malicious USB device can impersonate a keyboard and type commands, an attack class that works precisely because the operating system trusts whatever a device claims to be. Treating unknown devices with the same suspicion as unknown files is a sound habit.
Each individual device has its own entry in this glossary, covering the keyboard, mouse, monitor and printer, along with the port and USB standards that join them to the machine, so this entry deals with the general idea only. What peripherals have in common is the contract: a defined physical and logical interface on one side, a driver on the other, and a controller translating between the two.
Read a peripheral as anything that gives a computer senses, a voice or a memory beyond its processor: whatever the device, it reaches the machine through an interface, a controller and a driver, and understanding that chain explains most of what goes right or wrong when hardware is plugged in.