There Is No Computer Anymore

I asked whether WordPress could run on a GPU.

The first answer sounded almost like a technicality. You can install WordPress on a server that has a GPU, but WordPress itself will still run on the CPU. PHP runs there. MySQL runs there. Nginx or Apache runs there. The GPU may sit beside them and do almost nothing.

That answer exposed a confusion hidden inside the word computer.

A GPU is sold as a powerful computer component. Cloud providers offer GPU servers. AI companies measure their capacity in GPUs. A laptop with a stronger GPU is described as a faster machine. It therefore seems reasonable to ask why ordinary software cannot simply move onto the faster part.

The answer is that speed has a shape.

WordPress spends its time receiving requests, running PHP, loading plugins, checking permissions, reading files, querying a database and assembling a different page for each visitor. The work contains branches, interruptions, small decisions and communication with the operating system. A CPU is built for this kind of irregular coordination.

A GPU is built around another pattern. It becomes powerful when an enormous number of similar calculations can happen at once. Render these pixels. Apply this operation to millions of values. Multiply these matrices. Run the same model operation across many pieces of data.

A WordPress request behaves like an office. A GPU behaves like a stadium performing synchronized movement.

Sending the office into the stadium would not make the office faster. The job would first have to be reorganized into work the stadium can perform.

A computer is becoming an organization

We still speak about a phone, laptop or server as one computer. Inside, it is already a collection of computers with different responsibilities.

The CPU handles general logic and runs the operating system. The GPU handles graphics and parallel mathematics. The neural processor handles machine-learning operations. The digital signal processor handles audio, radio and other continuous signals. An image signal processor turns sensor data into photographs. Security processors protect keys and identity. Tiny microcontrollers monitor batteries, keyboards, fans, sensors and power states.

The device looks singular from the outside because product design gives it one screen, one enclosure and one name.

Internally, it resembles a company.

The CPU is the general manager. It can handle unfamiliar situations, switch between tasks and talk to the operating system. The GPU is a large specialist department that is extremely productive when its work arrives in the right format. The NPU is another specialist department trained around a narrower family of operations. Microcontrollers are the facilities staff quietly keeping the building alive.

This comparison explains why a GPU often receives tasks from a CPU. The CPU prepares the data, launches a GPU program and later receives the result. NVIDIA's CUDA programming model even uses the language of a host and a device. The host organizes the work. The device executes the parallel kernel.

A quantum processor can sit in a similar organizational position. A classical computer prepares a circuit, sends instructions to the quantum hardware and interprets repeated measurements. The resemblance is in the relationship between manager and specialist. Their internal physics are completely different.

The important shift is that the machine has stopped being one general intelligence made of silicon. It is becoming a negotiated division of labor.

The operating system lives with the manager

This also explains why GPUs usually do not run a general-purpose operating system in the way a CPU does.

An operating system manages processes, files, memory, devices, networks, permissions and interruptions. It must respond to unpredictable events and protect many unrelated programs from one another. The CPU architecture and the operating system evolved around that responsibility.

A GPU contains firmware, schedulers, memory controllers and sometimes embedded processors. It has sophisticated internal management. Yet the normal programming relationship still places Linux, Windows or macOS on the CPU side. The host operating system uses a driver to allocate GPU memory, submit work and collect results.

This creates a useful distinction between being a computer and being the computer.

The GPU can execute programs. It has memory. It can perform general-purpose calculations through systems such as CUDA. Calling it a computer is reasonable. Yet it usually operates inside a larger system whose files, network connections, user sessions and application lifecycle are controlled elsewhere.

The same is true of many processors inside a phone. They compute constantly while remaining invisible to the user and subordinate to the device's larger operating system.

The computer we interact with is therefore less a processor than an arrangement of authority.

Software is becoming assignment design

For most of computing history, application developers could imagine that their software ran on a machine. That abstraction is becoming harder to preserve.

A modern AI feature may divide one user action across the CPU, local neural processor, cloud GPU, vector database, search service, moderation system and another company's API. A video editor may decode footage with one hardware block, process effects on the GPU, run transcription on an NPU and use the CPU to coordinate the timeline and filesystem.

The software architect is increasingly deciding who should do each part of the work.

Should a model run on the phone or in the cloud? Local execution may improve privacy, latency and offline use. Cloud execution may provide a larger model and more memory. Should an image operation use the GPU? The answer depends on whether enough parallel work exists to justify moving the data. Should a background task wake the CPU, use a low-power processor or wait until the device is charging?

These choices shape the product directly.

They determine how quickly a button responds, whether the feature works on a train, how warm the phone becomes, how much battery disappears, what data leaves the device and how much each interaction costs the company.

Infrastructure decisions become interaction decisions before the user sees the interface.

This is especially visible in AI products because the same apparent action can be routed through radically different computers. A short rewrite might happen locally. A long research task might call a cloud model, search several sources, run code and return minutes later. The text box looks the same while the computational organization changes underneath it.

The interface therefore needs to communicate more than progress. It may need to explain where the work is happening, what information is leaving the device, why one request takes longer, when a connection is required and which parts can continue in the background.

The interface hides a computational supply chain

A person taps one button and experiences one product.

Underneath, the action may travel through a supply chain of machines.

The CPU validates the request. A security processor confirms identity. The network stack sends data to a server. A load balancer chooses a machine. A GPU runs a model. A database retrieves memory. Another service checks policy. The response returns to the device. A local processor converts it into speech. A microcontroller keeps the display awake long enough for the person to hear it.

The product appears coherent because every participant agrees to hide its boundaries.

That hiding is useful until something fails.

When a cloud GPU is unavailable, the user sees a spinner. When the network disappears, the feature seems to forget how to think. When a local model is used instead of a larger cloud model, the answer may change without the interface explaining why. When a tool call fails after the model has written a confident sentence, the computational supply chain produces a social problem: the product appears to have done something it did not do.

Interaction design has traditionally focused on the relationship between a person and an interface. Increasingly, the interface is the spokesperson for an organization of machines.

A good spokesperson needs to know which department is working, what it can promise and when responsibility has moved elsewhere.

The architecture diagram and the user journey are starting to describe the same event from opposite sides.

The computer survives as a product fiction

There is still value in pretending the computer is one thing.

People should not need to understand CUDA kernels before editing a photograph. They should not need to know which processor recognized their voice. The purpose of a product is partly to turn a complex technical organization into a coherent capability.

Yet the fiction becomes dangerous when it hides differences that matter.

A local action and a cloud action may look identical while carrying different privacy consequences. Two AI responses may come from different models with different costs and abilities. A feature may appear to belong to the device while depending entirely on a distant data center. A progress indicator may suggest that one machine is thinking while several companies and systems are exchanging data.

The phrase "my computer did this" compresses an entire organization into one actor.

That compression will become harder to sustain as software gains more autonomy. Agents will choose tools, route tasks, call specialized models and continue working across devices. The question will no longer be only whether a system can complete a task. We will need to understand how it delegated the task, which machine made each decision and where accountability sits when the result is wrong.

The WordPress question begins to look less naive from this perspective.

Why cannot WordPress run on the GPU?

Because WordPress is already running inside an organization whose departments have different jobs. The GPU is available, but the work does not match its structure. Reassigning the task would require redesigning the task itself.

That principle reaches far beyond WordPress.

The future of software is increasingly the design of computational organizations. CPUs, GPUs, NPUs, accelerators, cloud services and human operators each receive the work that fits them. The interface turns their coordination into one apparent action.

There is no computer anymore.

There is a company of machines pretending to be one.

Connected reading

• The Product Happens Between the Screens
• The Coding Assistant Is Becoming the Development System
• AI Makes Organizational Mess Executable
• What Kind of Worker Is AI Allowed to Become?
• The Work Takes the Shape of the Tools I Have Access To

AI authorship note

This essay began with Kris Haamer asking whether WordPress could run on a GPU, then following the question through operating systems, accelerators, quantum processors and the different kinds of computers inside a modern device. AI supported the technical explanation, source selection, argument structure, drafting, editing, metadata and publishing workflow. Kris supplied the questions, selected the organizational framing and approved the article for publication.