Difference between runtime and kernel?

Question

I'm reading this docker tutorial:

It’s important to note that Docker containers don’t run in their own virtual machines, but share a Linux kernel. Compared to virtual machines, containers use less memory and less CPU.

However, a Linux runtime is required for Docker. Implementations on non-Linux platforms such as macOS and Windows 10 use a single Linux virtual machine. The containers share this system.

and I'm wondering what the difference is between a linux kernel and a linux runtime.

A definition of kernel that I found:

The kernel is the lowest level of the operating system. The kernel is the main part of the operating system and is responsible for translating the command into something that can be understood by the computer.

A definition of runtime that I found:

Runtime is when a program is running (or being executable). That is, when you start a program running in a computer, it is runtime for that program. In some programming languages, certain reusable programs or "routines" are built and packaged as a "runtime library." These routines can be linked to and used by any program when it is running.

Answer 1

tl;dr: There's no difference, the Linux kernel is a type of runtime.

Long explanation:

Runtimes

The quoted definition isn't a very good definition of "runtime". In software building context, a runtime is the software takes the software you built, interprets it, and executes it (generally) instruction-by-instruction.

For example, when you build jar files for Java, they contain instructions in a language called "Java bytecode", and the runtime which executes these instructions as a Java program is running is the JVM.

When you write a Python script, the runtime which executes these Python instructions is the Python interpreter.

OSes and Loading

Runtimes also have the role of loading the program from files to a form that can be interpreted.

When you build a program in C, it is compiled to machine code which is not interpreted by any software, but rather directly by the hardware (CPU). Such programs are sometimes called "native". However, the C standard libraries are usually not bundled with your software, they have to be independently present on the machine running your code, and these are also sometimes referred to as "The C runtime", partly because they contain every C program's bootstrap code.

Even such native programs are compiled into a native executable format (the one used by Linux is called ELF), and the OS kernel must know how to read that format into instructions and load them in a way that the CPU can interpret & execute them. As such, OSes are also runtimes. (Note that while the OS kernel is the main program of the OS, often other programs are also part of this runtime, e.g. dynamic linkers.)

As you can see, runtimes are often stacked: you can have a Intel x86 hardware running MacOS kernel running a hypervisor program running a Linux virtual machine running a JVM.

Docker Runtime

Now, all the docker images you'll encounter are Linux based. All the native programs installed in these images, including runtimes like the JVM and Python interpreter, are native programs compiled for Linux (i.e. ELF executables).

When you run docker container in Linux, two things need to happen:

First, docker needs to set up a container (Setting up things like overlay filesystems and control groups).

Second, docker needs to somehow get some of the (ELF) executables (e.g. JVM or your native containerized C program) in the container to run.

Both these things are filed under "program loading" category, which is the responsibility of a runtime.

Linux is the only operating system kernel which has all these features - overlay filesystems, control groups, and ELF loading - which are utilized by docker.

On e.g. MacOS, these technologies do not exist (AFAICT), and so in order to run a docker container, docker needs to run its containers inside a Linux virtual machine which functions as a runtime which can load images.