BASIC

10 PRINT "HELLO WORLD" 20 GOTO 10 

Postscript 9

{1 =}loop 

Output 1 in an infinite loop.

Python, 17 13

while 1:print 

Thanks to Ben and r.e.s.

C, 20 bytes (competing according to the challenge's creator)

Suppose the following code is contained in e.c:

int i; #include"e.c" 

In a machine with infinite system resources, GCC will create an infinitely big temporary file trying to resolve a recursive #inclusion.

C, 26 25 24 (no recursion)

main(){for(;;puts(""));} 

Prints endless '\n' characters. This is a byte longer than the shortest C answer, but doesn't rely on tail call optimization to avoid overflowing the stack.

R, 13 characters

repeat cat(1) 

PowerShell 2.0: 17 11 8

My initial solution:

while(1 -eq 1){1}

Thanks to r.e.s.:

while(1){1}

I think Danko Durbić has the winner, here. I'm not even sure why this should work, but it does and I can't think of anything shorter so far.

for(){1} 

C#, 57

Another C# entry, with a twist:

class M{static int Main(){for(;;)System.Console.Beep();}} 

This interpretation of "output" may be stretching, but still valid I think (and saves 4 characters! :)

Xojo, 18 12 chars

Again, please don't actually run this (same reason as the JavaScript answer):

do Beep loop 

Never said the output couldn't be audio...

Windows Batch File, 1 character

Create a file called a.bat containing:

a 

When you execute this batch file, it executes itself. The Windows Command Prompt by default echos every command to the console, so the output resembles:

C:\>a C:\>a C:\>a C:\>a 

Malbolge (Original Interpreter), 164 46 44 bytes

Warning: This code uses non-printable characters, replace [2] by a byte containing 0x02, [8] by a byte containing 0x08, and [15] by a byte containing 0x0f

(=&`^?>=<}X98765[2][8][18][2][2][8][2][2][2][8][2][2][2][8][2][2][2][8][18]!~}|{zy[15] 

1505 bytes? Using a toolchain? Surely we can torture ourselves improve this code even more by making it non-portable. This program prints the letter T forever. The technique used here is the same one used by Lou Scheffer. We try to find a good enough pattern that we can exploit for our program, and we put the goto values we want in binary as padding (When not needed, I just used o instead). Luckily, we have a pattern of printing (<) at position 3 and a pattern of data pointer jumping (j) at position 9. In the previous version of the code, I absolutely wanted these two commands to be together, which was a mistake. Here's an explanation of the normalized version of the code minus the extra bytes:

jpj -> Put some printable value in the accumulator and jump to data section <i -> Sometimes prints and jumps to the data pointer resetting section oooo ji -> Sometimes rewinds the tape and jumps to the printing section [INSERT PADDING HERE] 

Malbolge and Malbolge Unshackled, 113 90 bytes

(=BA@?>=<;:381x543,1N/.-,+*)('&%$#"!~}|{zLxwvutWr1p0.--kjihgfedcF!`_^]\[ZYXWVUTSRQPONMLKig 

Try it online!

To be honest, I wasn't completely satisfied with my first attempt, since it was using a well-known bug from the original interpreter, so I tried to rewrite it so that it would work for a regular interpreter. This took more time than I expected... Well, if you disregard the fact that I'm programming in Malbolge. Here's a short explanation of the code:

j -> Move the data pointer forward pooooooooopopjooop -> Crazy operations in order to initialize the right values into the data section loop o i -> Starts loop oooooooooooooooooooo / -> Used for the first crazyop at the start of the program ooooo joio<i -> MAIN LOOP: Alternates between data pointer resetting and printing i< -> Some values for crazyop and goto ooooooooo ji -> Data pointer resetting loop oooooooooooooooooooooo <i -> Printing loop 

sed 7 5 chars (version 4.2)

sed -e ':;p;b' <<<'Hello world!' 

Unfortunely, this won't work anymore, from version 4.4 of GNU sed:

sed -e ':a;p;ba' <<<'Hello world!' 

Perl 6, 13 11 characters

Using some nice Perl6 syntax for infinite lazy lists:

.say for ^∞ 

The code will print all integers from 0 upto infinity or until RAM runs out to store single big integers, whichever comes first.

Microsoft Word Math AutoCorrect, 4 bytes

1. Add a new entry in the Math AutoCorrect table (not the regular one): $ -> $$. This makes a new production rule for us. (3 bytes)
2. Insert an Equation (Alt + =), and type a single $. The AutoCorrect will replace it with a $$, but that's not you inputting any extra characters, so it doesn't add to the byte count. This initializes our memory tape. (1 byte)
3. Press the "Professional" button under Equation Tools. This is where the program officially starts running.
4. Watch the little right-moving Turing Machine freeze up Word.

Explanation

The Professional button makes the Autocorrect sweep from left to right, running the production rules. On initial state $$, it sees a $ in the first position and replaces it with $$.

1. Then check the next position to the right.
2. Replace $ with $$, otherwise halt.
3. Repeat.

Note: the GUI doesn't show the $'s being generated as the GUI doesn't update until the operation halts, which it won't here. If you open up your Task Manager, you can see the memory usage going up to see that this is indeed what's happening. Sure, I could have made it produce more $s but the production rate would still just be O(1) per loop anyway, and I'd be spending precious bytes programming it. Oh, and I'm counting the $s as output.

Brachylog, 2 bytes

ẉ⊥ 

Try it online!

Not only does it print infinitely, this prints something much more interesting than most answers here: all integers.

Explanation

 Assign an integer value to the input ; since it is not constrained, it can take any value in (-∞, +∞), meaning there is an infinite number of choice points The way = is implemented makes it so that the order of choices it will try is: 0, 1, -1, 2, -2, 3, -3, … ẉ Write that integer to STDOUT, followed by a linebreak ⊥ False (i.e. go back and try the next integer choice point) 

tinylisp, 15 bytes

(d f(q(A(f g (f 

Try it online!

An infinite stream of errors. Just as DLosc intended, hopefully.

unsure, 20 bytes

um but uh okay wait 

Don't try it online, it freezes the browser. Listen to the code. Even it wants you to wait. Think this through. Don't be like me. Don't lose that unsaved tab.

Haskell, 18 chars

a=1:a;main=print a 

N.B.: No new line at end!

Perl, 10 chars

TIMTOWTDI:

$ perl -nE 'say;redo' <input> # 10 chars (1+8+1) $ perl -E 'say while+1' # 11 chars $ perl -E 'o:say;goto o' # 12 chars $ perl -E 'for(;;){say}' # 12 chars $ cat inf.pl warn;exec$^X,$0 # 15 chars 

If you have infinite RAM (maybe in the cloud ;-)

$ perl -E 'sub o{say;&o}o' # 14 chars $ perl -E '&{*1=sub{say;&1}}' # 17 chars, just kidding *gg* 

Matlab, 13

while 1 1 end 

This prints

ans = 1 

infinitely many times.

Emotinomicon 18 bytes, 5 chars

😀⏪😀😨⏩ 

Explanation:

😀 - push 0 to the stack ⏪ - open loop 😀 - push 0 to the stack 😨 - pop top of the stack, and output it as a number ⏩ - end loop 

As long as there's something on the stack, it's going to loop indefinitely

PHP - 17 16 13 11 bytes

<?for(;;)echo O; 

Oh well, I guess PHP can't ever always win... _{Thank you, m.buettner}

Edit:

<?for(;;)0/0; 

As it turns out, division by zero triggers a warning in php. So, even though the output it produces goes to STDERR, it's still infinite!

Edit 2:

for(;;)0/0; 

(Run with php -r)

Wolfram Language ( Mathematica ) 14 bytes 12 characters

Do[Echo@1,∞] 

Grass, 11 bytes

Taken from original document (Japanese):

wWWwwwwWWww 

Try it online!

How it works

In pseudo code:

function f(x){ Out("w"); return x(x); } f(f) 

tinylisp, 13 bytes

(d f(q(a(f (f 

Try it online!

Outputs an infinite stream of errors. -1 thanks to DLosc.

The tinylisp interpreter throws a warning because a shadows the builtin a, but continues evaluation.

Bash, 3 bytes

top 

Haven't seen anyone do this yet. It's tied with the yes answer.

☾, 5 chars (11 UTF-8 bytes)

➰1:☾ 

Prints an infinite stream of new lines, since calling ☾ (Python's print) with no arguments prints a singular new line. You could try it in the web UI, but there, it just hangs without output (it prints after halting).

APL, 7

{∇⎕←⍵}1 

Defines a function which output its argument and call itself with the same argument, then call it once with argument 1

Brainfuck, 8 bytes

+[[+.]+] 

Assumes wrapping.

I'm aware that a solution was already posted by @cardboard_box - allthough his doesn't print any printable characters.

Shell, 16 Chars

cat /dev/urandom