Can you render using the CPU with Eevee
The Blender EEVEE render engine uses OpenGL for all the rendering, so YES, rendering on the CPU should be completely doable, as long as a viable CPU-based OpenGL implementation is also installed and enabled.

In particular, Blender lists system requirements of only "OpenGL 3.3", which is officially supported by both softpipe and LLVMpipe.



Base Knowledge

OpenGL is just a standard interface that programmers can use to perform operations that are commonly related to computer graphics. What happens when a program actually runs that code is completely up to the system it's running on.

In most cases, a program that runs OpenGL code will have its processing redirected  by the OS to the GPU, because the GPU is specifically designed to be more efficient than the CPU at running the kinds of operations that OpenGL is used for.

However, there is nothing fundamentally different about the mathematics that the CPU is capable of doing and that the GPU is capable of doing, so it is also possible for the OS to simply compute the result of each OpenGL operation entirely on the CPU, without the program ever touching the GPU (or knowing any better).

Analogy

Imagine that the CPU is a secretary, and the GPU is a group of workers. Usually, when a blueprint (OpenGL call) comes in, the secretary passes it along to the workers to do the heavy lifting (rendering).

However, there's nothing that's actually stopping the secretary from rolling up their sleeves and helping with the work themselves— so long as they have the proper training (OpenGL software implementation). They might not be as skilled or in as great shape, so they'll be slower, but they can still do it.

Caveats

There are only some limited situations where this would come in handy:


You do not have access to a GPU, for either a lack of compatible hardware or software.
You have a surplus of CPU power, and you want to squeeze out as much rendering speed as possible from what you have without caring about the efficiency and electricity usage.


Basically, if you have the choice, using the GPU will almost certainly be both faster and more efficient than the CPU. In order to match the speed of a \$50, 30 watt integrated GPU, you would probably need a \$400, 150 watt server-grade CPU. But in cases where GPU-rendering simply isn't an option, setting up a CPU pipeline should be fully possible too.

Addendum

Wikipedia has some information on the software OpenGL capabilites on most Linux desktop and workstation computers:


https://en.wikipedia.org/wiki/Mesa_(computer_graphics)#Software_renderer


The following software projects all purport to offer some degrees of support for CPU-only software rendering of OpenGL (and potentially other graphic APIs):


https://www.openswr.org/index.html
https://dri.freedesktop.org/doxygen/gallium/softpipe.html
https://www.mesa3d.org/llvmpipe.html


Phoronix.com has also done a performance benchmark of two of the above options:


https://www.phoronix.com/scan.php?page=article&amp;item=llvmpipe-swr-xeon


(Note that the above tests were done on an 80-thread server-grade CPU— and it still struggled to reach a playable framerate in simple video games.)

These guys seem to have successfully run Eevee using openswr:


https://www.highperformancegraphics.org/wp-content/uploads/2018/Posters-Session/HPG2018_BlenderRenderingAbstract.pdf
https://www.highperformancegraphics.org/wp-content/uploads/2018/Posters-Session/HPG2018_BlenderRenderingPoster.pdf