What this note is really about
When we say a computer stores:
- text
- an image
- audio
- video
it is easy to imagine that the machine somehow stores those things in their natural form.
But it does not.
A computer stores bits.
Everything else is an interpretation built on top of those bits.
So the real topic is:
- what kinds of information humans care about
- how those kinds of information are represented as digital data
- how those representations changed historically
- what forms are common today
This note is not mainly about editing tools or media production.
It is about representation and storage.
The single unifying idea
A file is just a sequence of bytes.
What makes one file “text” and another “image” is not the bytes by themselves.
It is:
- the agreed format
- the encoding rules
- the software that interprets the bytes
So:
- text files are bytes interpreted as characters
- image files are bytes interpreted as pixels or drawing instructions
- audio files are bytes interpreted as sampled sound data
- video files are bytes interpreted as timed image frames plus audio and metadata
This is the master idea behind all digital storage.
The major categories of digital information
At a broad level, the most important human-facing categories are:
- text
- numbers
- images
- audio
- video
In practical computing, you should also add:
- executable programs
- structured data
- 3D and geometric data
Why add those last three?
Because modern computing is not only media.
A lot of digital storage is also about:
- software instructions
- records and databases
- models, scenes, and simulation data
So the whole picture is broader than just text-image-audio-video.
First principle: analog reality vs digital representation
Many things in the world are effectively continuous:
- sound waves
- light intensity
- color variation
- motion over time
Digital storage does not preserve them as continuous physical quantities.
It represents them using:
- discrete samples
- discrete symbols
- discrete values
This is one of the biggest shifts in understanding.
A digital representation is never the thing itself.
It is a structured encoding of aspects of that thing.
Text: from symbols to encoded characters
Text is one of the simplest digital media types conceptually, though language makes it rich.
Humans think in:
- letters
- digits
- punctuation
- scripts
- words
A computer stores text by assigning numbers to characters.
That mapping is called character encoding.
Early text storage
Early computing often used limited character sets because storage and hardware were constrained.
Important historical ideas include:
- telegraph codes
- punched cards
- fixed-width encodings
- ASCII
ASCII
ASCII became one of the most influential early text encodings.
It represented a small set of characters such as:
- English letters
- digits
- punctuation
- control characters
ASCII is a 7-bit encoding, though it was commonly stored in bytes.
It was extremely important because it gave computing a shared textual foundation.
But it was limited.
It did not cover the full writing systems of the world.
The Unicode era
As computing became global, limited encodings were no longer enough.
That led to Unicode:
a universal character system intended to represent text from many languages and symbol sets.
Unicode is not just one file format.
It is a system of assigning code points to characters.
Those code points can then be stored using encodings such as:
- UTF-8
- UTF-16
- UTF-32
UTF-8
UTF-8 became especially important because:
- it can represent Unicode text
- it is efficient for common English-heavy text
- it is backward-compatible with ASCII for the basic ASCII subset
- it became dominant on the web and in modern software systems
So if you ask what the “modern default” for text storage is in many contexts, the answer is often:
Unicode text, commonly encoded as UTF-8
How text is actually stored today
A modern text file is usually:
- a stream of bytes
- interpreted using an encoding such as UTF-8
- optionally structured by conventions such as lines, delimiters, or markup
Examples:
.txt.md.html.json.csv- source code files
These are all still “text” at the storage level, even though they may have additional syntax and structure.
So modern text storage is not only about characters.
It is often:
- characters
- plus syntax
- plus structure
Structured data: text that carries machine-readable structure
This deserves its own small section.
A lot of modern information is not pure prose and not pure media.
It is structured data.
Examples:
- JSON
- XML
- YAML
- CSV
- SQL rows
- logs
- configuration files
These are often stored as text, but they are meant to be read by both:
- humans
- software
So one big modern development is that text stopped being only human writing.
It also became a medium for machine-readable structured information.
Numbers: simple values, many representations
Numbers are conceptually simple, but they can be stored in many ways.
Examples:
- integers
- floating-point values
- decimals
- scientific measurements
A number may be stored as:
- plain text digits, like
"42" - binary integer representation
- binary floating-point representation
- packed decimal forms in specialized systems
So one idea matters here:
the same conceptual number can be stored either as text or as binary numeric data
That distinction matters in file formats, databases, and data interchange.
Images: from symbols to pixels
Images are more complex than text because they must represent visual appearance.
Historically, image storage evolved through several broad stages:
- symbolic or vector-like descriptions
- simple raster or bitmap storage
- compressed image formats
- high-efficiency modern image formats
Early image storage
At first, computers had limited display capabilities.
Early visual representations often involved:
- character-cell graphics
- line drawings
- simple bitmap images
- low-resolution monochrome images
A bitmap or raster image stores color or intensity values for many discrete picture elements:
- pixels
This is still the basic modern idea for most digital photography and screen imagery.
Raster images
A raster image is usually defined by:
- width
- height
- color information for each pixel
Example:
- a 1000 x 1000 image has 1,000,000 pixels
Each pixel may store:
- grayscale intensity
- RGB color
- RGBA color with transparency
Important concepts:
- resolution
- color depth
- channels
- transparency
If you store all pixel values directly with little or no compression, the file can become large very quickly.
Vector images
Not all images are stored pixel by pixel.
Some are stored as vector graphics:
descriptions of shapes such as:
- lines
- curves
- fills
- text objects
This works especially well for:
- logos
- icons
- diagrams
- illustrations
Important formats historically and practically include:
- PostScript
- SVG
Vector graphics scale well because they describe geometry, not a fixed pixel grid.
So image storage has always had two major branches:
- raster
- vector
That distinction is fundamental.
Early common image formats
As digital imaging matured, several formats became important at different times:
- BMP
- GIF
- TIFF
- JPEG
- PNG
BMP
BMP is historically important as a straightforward bitmap format with little sophistication.
It is useful for understanding raw raster storage, but it is not efficient for many modern uses.
GIF
GIF became important for limited-color graphics and simple animation.
It was widely used in the early web era.
TIFF
TIFF became important in scanning, publishing, and archival workflows because it supports flexible image storage options.
JPEG
JPEG became dominant for photographs because it uses lossy compression that can reduce file size greatly while preserving acceptable visual quality for many uses.
PNG
PNG became important for lossless web graphics, transparency, and cleaner reproduction of interface elements and diagrams.
The modern image era
Today, common image storage includes:
- JPEG for many photos
- PNG for lossless graphics and transparency
- SVG for vector web graphics
- WebP and AVIF for modern web-friendly compression
- RAW formats in photography workflows
- HEIF or HEIC in some device ecosystems
Modern image storage is shaped by competing needs:
- quality
- file size
- decoding speed
- transparency support
- browser and software compatibility
- editing friendliness
So there is no one final image format.
There are families of formats optimized for different needs.
RAW images
This is an important modern concept.
A RAW image file usually stores sensor-oriented image data with minimal in-camera processing compared with normal consumer image formats.
This is valuable because it preserves more flexibility for:
- exposure adjustment
- white balance
- color processing
- professional editing
So one branch of modern image storage is not just “final image for viewing.”
It is also:
- capture-oriented storage for later processing
Audio: storing sound as data
Sound in the physical world is continuous vibration.
To store it digitally, computers usually use sampling.
The broad modern idea is:
- measure sound amplitude at many discrete time intervals
- store those measurements as numbers
That produces digital audio.
Early audio storage
Before digital audio became common, sound was stored in analog forms such as:
- phonograph records
- magnetic tape
Early digital audio systems were limited by storage and processing constraints, but the central move was clear:
convert continuous sound into sampled numerical data.
Important ideas include:
- sample rate
- bit depth
- channels
Sample rate
How often the signal is measured per second.
Bit depth
How precisely each sample is represented.
Channels
Whether the sound is mono, stereo, surround, and so on.
PCM: the basic digital audio model
One of the most fundamental forms of digital audio storage is PCM:
- pulse-code modulation
In practical terms, PCM means:
- take sampled sound values
- store them numerically
Formats like WAV often store audio in PCM form, though WAV is really a container and can hold different encodings.
PCM audio is conceptually simple and high quality, but raw PCM can be large.
That size pressure led to compression.
Audio compression
Audio formats evolved along two broad lines:
- lossless compression
- lossy compression
Lossless audio
Preserves the exact original audio data after decompression.
Examples:
- FLAC
- ALAC
This is useful for:
- archiving
- production workflows
- high-fidelity storage
Lossy audio
Throws away some information to reduce size significantly.
Examples:
- MP3
- AAC
- Ogg Vorbis
- Opus
Lossy audio became extremely important because it made digital music distribution practical at scale.
The modern audio era
Today, common audio storage includes:
- uncompressed PCM for some professional or intermediate uses
- FLAC or ALAC for lossless storage
- AAC, MP3, and Opus for compressed distribution and streaming
Modern audio storage is shaped by:
- quality requirements
- bandwidth limits
- storage efficiency
- streaming behavior
- compatibility across devices and platforms
So, as with images, there is no single final format.
There are optimized choices for different contexts.
Video: images over time plus audio
Video is more complex than image or audio because it combines:
- a sequence of images over time
- usually audio
- timing information
- metadata
- often subtitles, chapters, and multiple tracks
So video storage is really a layered problem.
It usually involves:
- visual encoding
- audio encoding
- synchronization
- packaging into a container format
Early video storage
Early moving-image storage was analog:
- film
- magnetic tape
As video became digital, one naive approach would have been:
- store every frame as a full image
- plus audio
That works conceptually, but it creates enormous file sizes.
So digital video required powerful compression much more urgently than text or many images did.
How digital video is basically represented
At the broadest level, digital video is:
- frames
- shown in sequence over time
Important concepts include:
- frame rate
- resolution
- color sampling
- bitrate
- compression
A raw video stream can be extremely large.
So practical video storage almost always relies heavily on compression.
Codecs and containers
This is one of the most important distinctions in media storage.
Codec
A codec is the method used to encode and decode the media stream.
Examples:
- H.264
- H.265
- VP9
- AV1
- MPEG-family codecs
Container
A container is the file format that packages one or more streams together.
Examples:
- MP4
- MKV
- MOV
- WebM
So:
MP4is usually a containerH.264is a codec
People often mix these up.
They are related, but not the same.
Video compression: why it matters so much
Video compression became crucial because video contains enormous redundancy:
- neighboring pixels are often similar
- successive frames are often similar
Modern video codecs exploit both:
- spatial redundancy within a frame
- temporal redundancy across frames
That is why video files can be made practical at all.
Without compression, modern digital video distribution at scale would be far less feasible.
The modern video era
Today, common video storage and delivery involve:
- MP4 containers
- H.264 as a long-dominant widely compatible codec
- H.265 or HEVC in some high-efficiency workflows
- VP9 and AV1 in many modern web and streaming contexts
- ProRes and related formats in professional editing environments
Modern video storage is shaped by:
- bandwidth
- device support
- editability
- latency
- licensing
- quality targets
- streaming delivery needs
So once again, the “latest era” is not one universal format.
It is a landscape of tradeoffs.
Animation and moving graphics
This sits between image and video.
Some moving visual media is stored not as full natural video, but as:
- animated image formats
- motion graphics timelines
- vector animation
- sprite sequences
Examples include:
- animated GIF
- APNG
- Lottie-style animation formats
This matters because not every moving image is best treated as traditional full video.
3D and geometric data
This is another category worth adding because modern computing uses it heavily.
Examples:
- CAD models
- game assets
- simulations
- 3D scenes
- scanned geometry
3D data may store things like:
- vertices
- edges
- faces
- normals
- materials
- textures
- animation rigs
Important formats include:
- OBJ
- STL
- FBX
- glTF
This category shows that not all visual information is fundamentally an image.
Sometimes it is a scene description or geometric model from which images can later be rendered.
Executable programs: instructions stored as files
Programs are another fundamental digital category.
A program file stores:
- machine instructions
- metadata
- references to libraries
- symbols or debugging information in some builds
Examples include executable and object formats such as:
- ELF
- PE
- Mach-O
This matters because digital storage is not only about media and documents.
A stored program is itself data that tells the machine what to do.
That is one of the defining ideas of general-purpose computing.
Databases and records
A lot of important modern data is not best understood as one file containing one medium.
It is better understood as:
- records
- tables
- indexes
- logs
- document collections
Databases may store:
- text
- numbers
- timestamps
- binary blobs
- JSON
- images
- media references
So modern storage often shifts from “one file = one thing” to larger systems of structured records and indexes.
This is especially important in web, enterprise, and cloud software.
Compression as a unifying theme
Across images, audio, and video, one major historical trend is the growing importance of compression.
Why?
Because raw storage is often too large.
Compression became essential for:
- fitting media onto disks
- transmitting it over networks
- streaming it at scale
- storing large collections efficiently
Two big branches matter:
Lossless
Exact reconstruction is possible.
Useful when fidelity must remain exact.
Lossy
Some information is discarded to save much more space.
Useful when perfect reconstruction is less important than practical size and distribution.
This is one of the biggest recurring ideas in digital storage history.
Metadata: data about the data
Files often store more than the main content.
They also store metadata such as:
- dimensions
- duration
- encoding type
- timestamps
- authoring information
- color profiles
- camera information
- subtitles
- track information
Metadata became increasingly important as formats matured.
Modern digital storage is rarely just “raw content only.”
It is usually:
- content
- plus structure
- plus descriptive context
Containers, wrappers, and packaging
Many modern file formats are really packaging systems.
They do not just store one pure stream.
They may package together:
- multiple tracks
- metadata
- previews
- indexes
- attachments
- thumbnails
Examples:
- PDF for document structure
- MP4 for audio/video packaging
- archive files like ZIP
So the history of digital storage is also a history of moving from simple raw encodings to richer container structures.
The broad historical arc
If you step back, the history across text, images, audio, and video follows a similar pattern:
- early systems are limited and simple
- formats are narrower and often hardware-constrained
- storage and bandwidth limitations dominate design
- standard formats emerge
- compression becomes critical
- interoperability becomes important
- richer metadata and containers appear
- modern systems balance quality, efficiency, compatibility, and streaming/distribution needs
That pattern repeats across media types.
What the modern era looks like overall
If you want the shortest modern summary:
- text is usually Unicode, often UTF-8
- structured data is often text-based or binary-structured depending on use
- images are commonly JPEG, PNG, SVG, WebP, AVIF, HEIC, or RAW depending on context
- audio is commonly PCM, FLAC, AAC, MP3, or Opus depending on context
- video usually combines compressed video codecs and audio codecs inside containers such as MP4, MKV, MOV, or WebM
- programs are stored as executable binary formats
- large systems increasingly store everything within databases, object storage, and distributed services rather than as isolated standalone files only
That is not every format.
It is the broad practical picture.
The most important conceptual thread
If you want one flow that ties everything together, it is this:
Computers store bits, not human meanings directly. Text became digital by mapping characters to codes. Images became digital by storing either pixels or geometric drawing instructions. Audio became digital by sampling sound and storing numerical values. Video became digital by storing timed image sequences plus audio, almost always with strong compression. Over time, all of these media moved from simple, limited, often bulky formats toward richer encodings, stronger compression, better metadata, and more interoperable containers. Modern digital storage is therefore not just “bytes on disk,” but bytes organized by agreed rules that let software reconstruct text, pictures, sound, motion, programs, and structured information.
What you should come away knowing
You should leave this topic with these ideas clearly separated:
- A file is fundamentally bytes.
- Meaning comes from encoding and format rules.
- Text is stored through character encodings.
- Images are stored either as raster data or vector descriptions.
- Audio is usually stored as sampled numerical data.
- Video combines timed image data, audio, and metadata, usually inside containers.
- Compression became central as media sizes grew.
- Modern formats are shaped by tradeoffs among quality, size, speed, compatibility, and editability.
- Structured data, programs, and 3D data are also important digital categories.
- The history of storage formats is largely the history of turning real-world richness into practical, standardized, compressible digital representations.
Bottom line
Digital storage works by representing different kinds of human-meaningful information as bytes according to agreed encoding rules. Text uses character encodings, images use pixels or geometric descriptions, audio uses sampled values, and video uses time-ordered visual and audio streams with strong compression and packaging. Historically, formats moved from simple and constrained forms toward richer, more efficient, and more standardized representations. Today the main story is not that one format won forever, but that each medium has families of formats shaped by the tradeoffs that matter for that medium.