sed, 4

/./q

Waits for a line of input that has 1 or more characters, then quits.

Try it online. But it works better on a live shell:

sed '/./q'

JavaScript, 37 22 17 bytes

while(!prompt``);

while(!prompt``);

Explanation

The while keyword starts the while loop. In the condition of the loop, !prompt`` asks for input and checks whether it is given or not. If it isn't given, the body of the loop is executed, which in our case is empty, then the interpreter goes back to the loop condition. The same process happens over and over again until the user gives the input.

Python 3, 18 bytes

while''==input():0

Try it online!

Perl 5, 8+1 (-p or -n flag) bytes

/./&&die

Takes input from stdin and dies as soon as the regex matches anything except a newline.

C# (.NET Core), 72 bytes

using System;class C{static void Main(){for(;Console.ReadLine()!="";);}}

Try it online!

brainfuck, 26 bytes

+[>,----------[[-]<[-]>]<]

Try it online!

Java, 55 bytes

void f()throws Exception{while(System.in.read()==10);}}

If I remember correctly (it's been a while since I've been active on PPCG), my program can just be a function.

This is system specific; it only works on systems where the end-of-line character is a single newline. If the end-of-line character is instead a carriage return, replace the 10 with 13. On Windows, this doesn't work, as end-of-line on windows is \r\n.

This makes use of the fact that I can read directly from System.in.

Jelly, 3 bytes

ɠṆ¿

Not much to look at on TIO, I'm afraid.

Try it online!

How it works

This is a niladic program, meaning that it takes no input arguments. The implit argument and return value are both 0 in this case.

¿ (while) is a quick that pops two links from the link stack: a condition (Ṇ) and a body.

Ṇ is a monadic atom: flat logical NOT. If the previous return value is falsy (here, 0 or an empty string), it returns 1 and the body is called.

ɠ is a niladic atom; it reads a raw line from STDIN and returns the result.

Once ɠ reads a non-empty line, Ṇ returns 0 and we break out of the loop.

Pyth, 3 bytes

W!w

Try it online!

Translated to Python:

while Pnot(input()):
 pass

Braingolf, 8 bytes [non-competing]

1[{?:+|]

Non competing because {, which reads input from STDIN, was added to braingolf after this challenge's post date.

Explanation:

1         Pushes 1 to the stack
 [        Begins while loop
  {       Reads from STDIN, returns -1 if no input given
   ?      Checks if last item in stack is > 0
    :     Else
     +    Adds the last 2 items together, however there is only 1 item, so add it to itself
      |   Endif
       ]  End While, decrement first item in stack, or exit if first item is 0

HTML 5, 33 bytes

<form action=y.p><input required>

<form action=y.p><input required>

Explanation

The required attribute on the <input> causes the browser to inform the user "this field is required"-sort-of-message, if they do not enter a value. However, when they enter a value, the value is sent to the URL of the action attribute of the <form> (which in our case is "y.p", an imaginary file). So, the browser is redirected to "y.p" file, causing our HTML program to terminate.

Note: It doesn't matter whether "y.p" is available in the same directory. If it isn't, a 404 error is output by the browser. If it is, then it is displayed. Both of them cause our HTML program to terminate.

Another Note: This should work in any HTML5 compatible browser.

Charcoal, 4 bytes

Ｗ¬Ｓω

Explanation

Ｗ      While
  ¬Ｓ   Logical not of string input
     ω  Print ""

Java, 128 126 bytes

2 bytes thanks to Kevin Cruijssen.

import java.util.*;class a{public static void main(String[]a){for(Scanner s=new Scanner(System.in);s.nextLine().isEmpty(););}}

Try it online!

05AB1E, 5 bytes

[IõÊ#

Explanation:

[     Start infinite loop
 I    One line of input
   Ê  Not equal to
  õ   Empty string
    # Break if true

Try it online!

C, 52 bytes, 33 bytes, 29 bytes

-19 bytes thanks to Justin

-4 bytes thanks to Christoph

main(){while(getchar()==10);}

10 is equal to '\n' - In case this isn't obvious.

QBasic, 34 bytes

INPUT A$
WHILE A$=""
INPUT A$
WEND

I think nothing can be more self-explanatory than that. To test, go to this website and copy-paste the following code in their text-editor :

10 INPUT A$
20 WHILE A$=""
30 INPUT A$
40 WEND

The reason why line numbers are required is that their website only supports unstructured BASIC.

PHP, 18 bytes

while(!readline())

C#, 36 bytes

_=>while(System.Console.Read()==13);

Compiles to a Action<int>.

Or if a full program is required, 62 bytes.

class P{static void Main(){while(System.Console.Read()==13);}}

R, 27 bytes

while(!length(scan(,''))){}

Takes input from stdin, and repeat as long as input is of length 0.

Batch, 35 bytes

@set s=
@set/ps=
@if "%s%"=="" %0

Rather unfortunately, Batch doesn't clear the variable if you don't enter anything.

Bash, 51 bytes

It's my first time participating in PPCG, so dont be to rude ;D

#!/bin/bash
read a
while [ -z "$a" ]
do
read a
done

PowerShell, 20 Bytes

for(;!(read-host)){}

runs a for loop,

read-host prompts for input

if read-host returns nothing it evals to false, so we invert that !(...) and use that as the loop end check.

much shorter than any do{$a=read-host}while($a-eq"") type solution involving variables.

Perl, 15 bytes (14 + -n flag)

1/0if$_ ne"\n"

Explanation:

The -n flag places a read loop around the program, turning it into:

LINE:
while (<>) {
    1/0 if $_ ne "\n"
}

Where "<>" reads a line from stdin to the variable $_. If the line contained more than the ending newline (ne is string inequality), a division by zero is performed which causes the program to output an error message and terminate.