portability and a platform/target
If you write a recipe in metric units and someone in a country using cups and ounces wants to cook it, the recipe needs converting. Software faces the same issue: code that runs perfectly on your laptop may not run elsewhere, because the elsewhere differs in ways the code quietly relied on. Portability is how easily a program can be made to run on a different platform; a platform (or target) is the specific combination of CPU, operating system, and tooling a program is built for.
A platform bundles several things: the CPU architecture (which machine code it understands - say x86-64 or ARM), the operating system (Linux, macOS, Windows - which system calls and conventions exist), and often the libraries and compiler available. A program is portable if it can be moved to another platform with little or no change. For compiled languages like C, portability usually means the same source code can be re-compiled on each target rather than the same executable running everywhere - because an executable is machine code for one platform. The 'target' is simply the platform you are building for, which can differ from the one you build on (that is cross-compiling).
Why it matters: portability is a constant tension in systems programming, because the very low-level details that give you power - exact integer sizes, byte order, available system calls, memory layout - are exactly the things that differ between platforms. C is famously portable as a language yet full of sharp edges (an int is not always the same size; some behavior is 'implementation-defined') that bite when you move code. Writing portable code means consciously not depending on accidents of your one machine, and standards exist largely to make this possible.
The same hello.c compiles and runs on a Linux x86-64 server and on an Apple-silicon Mac - that source is portable. But the executable 'hello' built on the Linux box will not run on the Mac; each platform needs its own compile. Code that assumes int is exactly 4 bytes is less portable than code using a fixed-width type like int32_t.
Portable source, platform-specific executable - recompile per target.
Portable means 'movable with reasonable effort', not 'runs identically everywhere with zero work'. And source portability is not executable portability: re-compiling per target is the norm in C, and depending on machine-specific details (int width, byte order) silently breaks it.