# Shortest infinite loop producing no output

The point of this challenge is to create an infinite loop producing no output, unlike its possible duplicate. The reason to this is because the code might be shorter if no output is given.

## Rules

• Each submission must be a full program.
• You must create the shortest infinite loop.
• Even if your program runs out of memory eventually, it is still accepted as long as it is running the whole time from the start to when it runs out of memory. Also when it runs out of memory, it should still not print anything to STDERR.
• The program must take no input (however, reading from a file is allowed), and should not print anything to STDOUT. Output to a file is also forbidden.
• The program must not write anything to STDERR.
• Feel free to use a language (or language version) even if it's newer than this challenge. -Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language. :D
• Submissions are scored in bytes, in an appropriate (pre-existing) encoding, usually (but not necessarily) UTF-8. Some languages, like Folders, are a bit tricky to score - if in doubt, please ask on Meta.
• This is not about finding the language with the shortest infinite loop program. This is about finding the shortest infinite loop program in every language. Therefore, I will not accept an answer.
• If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainf**k-derivatives like Alphuck), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.
• There should be a website such as Wikipedia, Esolangs, or GitHub for the language. For example, if the language is CJam, then one could link to the site in the header like #[CJam](http://sourceforge.net/p/cjam/wiki/Home/), X bytes.
• Standard loopholes are not allowed.

(I have taken some of these rules from Martin Büttner's "Hello World" challenge)

Please feel free to post in the comments to tell me how this challenge could be improved.

## Catalogue

This is a Stack Snippet which generates both an alphabetical catalogue of the used languages, and an overall leaderboard. To make sure your answer shows up, please start it with this Markdown header:

# Language name, X bytes

Obviously replacing Language name and X bytes with the proper items. If you want to link to the languages' website, use this template, as posted above:

Now, finally, here's the snippet: (Try pressing "Full page" for a better view.)

• I've got to start posting programs with a negative byte count to beat all these empty files! – CJ Dennis Oct 3 '15 at 4:32
• This challenge is interesting because it brings out lots of 0 byte languages (some of which are NOT esolangs). FWIW, most declarative languages have an implicit infinite loop because declarative languages don't have loops in their syntax (they assume they're running in an infinite loop). Ladder diagrams are perhaps among the oldest such languages. Then you have the Instruction Language (IL), a sort of assembly for PLCs that also assume an infinite loop. ILs, like assembly are different between manufacturers – slebetman Oct 5 '15 at 9:36
• Are programs that read and execute their own source code allowed, or does file I/O break the "must take no input" rule? – ThisSuitIsBlackNot Oct 6 '15 at 13:05
• @ThisSuitIsBlackNot Yes, file input is allowed. – user41805 Oct 6 '15 at 16:47
• Can you print "", an empty string? – OldBunny2800 Mar 7 '16 at 23:39

# Oracle PL/SQL 11.2, 30 bytes

BEGIN LOOP NULL;END LOOP;END;/

# Magic, 7 bytes

skip -1

A simple self-GOTO.

# NTFJ, 2 bytes

Try it here!

~^

This is stiflingly simple. ~ pushes a 0 to the stack, and ^ pops N and goes that position in the source code. The simplest unconditional loop in NTFJ is this.

## GNU Make, 16 bytes

f=$(call f)$(f)

The loop is in make itself, not a program it invokes.

# Pylons, 4 bytes.

w,1}

Loops while 1 is true.

&{}

See the docs.

# ForceLang, 9 bytes

Works by abusing the new def instruction.

def a a
a

label l
goto l

In Mathcad the user enters programming language commands using keyboard shortcuts (or picking them from the Programming Toolbar) rather than writing them in text. For example, typing ctl-] creates a while-loop operator that has two "placeholders" for entering the condition and a single line of the body, respectively. Typing = at the end of a Mathcad expressions causes Mathcad to evaluate the expression.

So to enter the above while loop, the user enters "ctl-]11=". Mathcad will then eternally evaluate 1.

# WhoScript, 4 bytes

1v;d

The 1 tells the interpreter to use one-line mode, v starts an infinite loop, and d loops back to the v.

1COME FROM1

[[<]

# Bash, 10 bytes

f(){ f;};f
It does end up crashing the program /bin/bash, but I think that's allowed.

# Cy, 8 bytes 6 bytes

{1} do

Explanation:

{1} is a block (procedure) that pushes 1 to the stack (truthy). do will continue to execute that block until it pushes something falsy to the stack, which will never happen.

# tinyBF, 5 bytes

+|= |

Similar to +[] in BF. The space is required here, as |=| (meaning []) is converted to ,.

# Braille, 6 bytes

⠁⡀

Self-GOTO with a NOP. If it isn't displayed properly (and/or you want to test it):

0000000: e2a0 81e2 a180                           ......

# Grocery List, 6 bytes

W
L
E

Note the preceding newline. W pushes 100 to the stack, and L and E loop while the top of stack isn't 0.

# Dumbfuck, 2 bytes

.?

. sets the current cell to 1, and ? jumps to itself (due to the cell being an odd number).

## Pyke, 1 byte

r

Try it here!

The r node sets the counter to 0, resetting the program.

# Tellurium, 5 bytes

[i|p]

This is pretty simple to explain. It runs the command p (Does nothing, which is why it's good for this challenge) forever (i = infinity).

# Glypho, 3 bytes

1[]

Pushes 1 to the stack, then loops while the top of the stack isn't 0. Uses the Java interpreter. This is shorthand for the following "real" Glypho program:

!" ! " !"!

# Churro, 20 bytes

{o}=}{==={*}{===={*}

Consists of three churros. {o}=} pushes 1 to the stack, and {==={*} and {===={*} loop while the top of stack is not zero.

# niblet, 2 bytes

[

The space is just a no-op, and the [ moves the IP to the previous character.

# 0815, 7 bytes

}: :#:

(trailing space)

}:0:#:0

Explained:

}:0:    :Create a label 0
#:0 :Go to the label 0 if Z is 0h

# Trigger, 5 bytes

!  !

Generally, any program with an "ABAAB" pattern should work. toggles the ' ' trigger to 1, ! toggles the '!' trigger, and ! jumps to the nearest ! if the ' ' trigger is 1 (which it is).

# Benul, 0 bytes

In Benul, programs are placed in an implicit infinite loop and require special conditions to terminate.

# AlphaBeta, 2 bytes

N

is a no-op, and N moves the IP to the value stored in the position register (initially 0) if the third register is 0 (which it is).

# Java, 50 bytes

interface D{static void main(String[]a){for(;;);}}

## Copy, 10 bytes

copy 0 0 1

Copy the current instruction at the next location.

Basically a Core war imp.

# LI, 2 bytes

R0

Usually, LI programs (under the current interpreter) always take in input. No input is commonly represented as falsy input, i.e. 0; however, in order to truly accept "no" input, I need to provide my own input to the Recurse function.

Explanation:

R   Recurse with input:
0  Literal 0

LI, 1 byte

If we're a bit more lax with the input requirements, simply R will work. It doesn't error if you don't give it an input, but that's simply because, while it interprets the input as invalid (empty), it doesn't try to use its value.

# ABCR, 2 bytes

5x

Explanation: 5 loops while the front member of queue B resolves to a truthy value. The default value for queue B is 1, so the loop continues until it finds its matching x; since there are no operations in the loop, it continues ad infinitum with no output.