compiler, interpreter, and runtime (at a glance)
These three words name the helpers that get your source code to actually do something, and beginners mix them up constantly. Quick analogy: a compiler is a translator who hands you a finished translated book; an interpreter is a live human interpreter reading aloud as you go; a runtime is the support staff - the venue, the microphone, the lights - that has to be present for the show to run at all.
A compiler is a program that reads source code and translates it ahead of time into another form, usually machine code, producing a file you can run later. An interpreter is a program that reads source code (or a halfway form called bytecode) and carries out its meaning directly, step by step, as the program runs - no separate runnable file is made. A runtime (or runtime system) is the supporting code and services your program needs while it is running: things like memory management, the parts of the standard library that must be present, garbage collection, or a virtual machine. Even a compiled C program leans on a small C runtime that sets things up before main begins.
Why it matters: telling these apart explains a lot of confusing situations. Why does a Java program need the JVM installed (that is its runtime and interpreter/JIT)? Why does a compiled C program still need the C library on the system (that is part of its runtime)? Why can the same .py file behave differently on two machines (different interpreter versions)? At a glance: compiler = translate before running; interpreter = translate-and-do while running; runtime = the support that must exist while running. Many real systems use all three together.
Running a Java app uses all three: a compiler turned MyApp.java into bytecode; the JVM acts as the runtime and interprets or JIT-compiles that bytecode; and the runtime also provides garbage collection and core libraries while the program runs.
Compile, then run-on-a-runtime that interprets/JITs - three roles, often together.
One program can play several roles: gcc is a compiler but also runs a preprocessor and invokes a linker; a JIT both interprets and compiles. The labels name jobs being done, not mutually exclusive boxes.