# Question
Title: Shortest infinite loop producing no output
Your task is to create the shortest infinite loop!

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:

```
#[Language name](http://link.to/the/language), X bytes

```

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

```
var QUESTION_ID=59347;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var OVERRIDE_USER=41805;var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=true,comment_page;function answersUrl(index){return"//api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(index,answers){return"//api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=false;comment_page=1;getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}getAnswers();var SCORE_REG=/<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,});else console.log(body)});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<a>'+lang+'</a>').text();languages[lang]=languages[lang]||{lang:a.language,lang_raw:lang,user:a.user,size:a.size,link:a.link}});var langs=[];for(var lang in languages)if(languages.hasOwnProperty(lang))langs.push(languages[lang]);langs.sort(function(a,b){if(a.lang_raw.toLowerCase()>b.lang_raw.toLowerCase())return 1;if(a.lang_raw.toLowerCase()<b.lang_raw.toLowerCase())return-1;return 0});for(var i=0;i<langs.length;++i){var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}
```

```
body{text-align:left!important}#answer-list{padding:10px;width:500px;float:left}#language-list{padding:10px;padding-right:40px;width:500px;float:left}table thead{font-weight:700}table td{padding:5px}
```

```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table>
```

# Answer
> 230 votes
# Befunge, 0 bytes

Yup. A Befunge program exists in a two-dimensional *playfield* with fixed size which wraps around the edges. With nothing in that space to interfere, the *program counter* runs in an infinite loop by default :)

# Answer
> 164 votes
# L00P, 0 bytes

This lang was made for looping, and that's just what it'll do...

# Answer
> 146 votes
# C64 Machine Code, 2 Bytes

```
D0 FE

```

Branches to itself if the zero flag is not set.

Branches are single-byte offsets from the next instruction location, and 254 is -2 in two's complement... the BNE instruction (D0) takes one byte of memory, and the offset takes a second byte, so branching two bytes back branches back to itself. The zero flag is always cleared when code is loaded into memory.

Note that this is not a recursive subroutine call, so you will never run out of memory. Also note that there is no header, compiler, or executable overhead... it is truly a two-byte program :)

# Answer
> 122 votes
# brainfuck, 3 bytes

```
+[]

```

Try it online!

Never decrement: never end.

# Answer
> 116 votes
# ///, 3 bytes

```
///

```

Try it online!

Any bonus points for using the language's name as source code?

# Answer
> 81 votes
# Java (JDK), 53 bytes

```
class A{public static void main(String[]a){for(;;);}}

```

Try it online!

Yay full program requirement!

# Answer
> 60 votes
# Prolog, 5 bytes

```
a:-a.

```

In order to know if predicate `a` is true, you only need to check if predicate `a` is true.

You need to load the file and execute `a`, both with a command-line arguments, eg. `swipl -g a a.pl` with Swi-Prolog. Note that the recursion is likely to be optimized as an infinite loop and shouldn't blow the stack.

Also, this looks like a smiley, but I am not sure how to call it. The dot looks like saliva, so maybe "vegetative state", or "Infiurated programmer with curly hair". Suggestions are welcome.

---

Edit: I look at the rules again and for a full program and no command line arguments you need to add this, as user @radrow pointed out, for a total of **10 bytes**.

```
a:-a.
:-a.

```

Alternatively, for **14** bytes you can have something more poetic:

```
:-repeat,fail.

```

# Answer
> 52 votes
## Python, 9 bytes

Works in both 2 and 3.

```
while 1:0

```

Shortened by @FryAmTheEggman

# Answer
> 52 votes
# Haskell, 9 bytes

Infinite recursion of the main function. Should get compiled to a loop due to tail recursion optimization.

```
main=main

```

# Answer
> 48 votes
# x86 ELF executable, 45 bytes

Unlike the vast majority of these answers, this is a truly complete program, as in a free-standing executable program.

```
00000000: 7f45 4c46 0100 0000 0000 0000 0000 0100  .ELF............
00000010: 0200 0300 2000 0100 2000 0100 0400 0000  .... ... .......
00000020: ebfe 31c0 40cd 8000 3400 2000 01         ..1.@...4. ..

```

The guts of the program are at byte 0x20 `ebfe`, which is featured in another answer as the smallest NASM program. If you assemble that with NASM however, you get an executable with thousands of un-needed bytes. We can get rid of most of them using the technique outlined here. You may note that this program isn't even as big as the ELF header! This bit of executable golfing malforms the ELF header and program header so they can occupy the same bytes in the file and inserts our program into some unused bytes within the header. Linux will still happily read the header and start execution at offset `0x20` where it spins forever.

# Answer
> 42 votes
# INTERCAL, ~~42~~ 18 bytes

```
(1)DO COME FROM(1)

```

Idea taken from @flawr's comment.

**EDIT:** Holy crap, INTERCAL is actually shorter than C#. I don't know if that's ever happened before...

## 42-byte version

```
DO(1)NEXT
(1)DO FORGET #1
PLEASE DO(1)NEXT

```

# Answer
> 37 votes
# Perl, 6 bytes

```
perl -e '{redo}'

```

From `perldoc -f redo`:

> The redo command restarts the loop block without evaluating the conditional again...Note that a block by itself is semantically identical to a loop that executes once. Thus redo inside such a block will effectively turn it into a looping construct.

I don't see `redo` too often in production code, but it's great for golf! Compare the above to the shortest equivalents with `for`, `while`, and `goto`:

```
for(;;){} # 9 bytes
1while 1  # 8 bytes
X:goto X  # 8 bytes

```

# Answer
> 36 votes
## \>\<\>, 1 byte

```

```

A single space will cause \>\<\> to go into an infinite loop of NOPs

Other valid single character programs (with no memory requirements) are as follows:

```
>^v</\|_#x!"'{}r

```

In addition, the rules state that your program can run out of memory in which case we can add the following characters to the list of valid 1-byte programs:

```
01234567890abcdefli

```

# Answer
> 36 votes
# Motorola MC14500B Machine Code, ~~0.5~~ 0 bytes

### Explanation

According to the manual, the system is configured to have a looping control structure. The program counter counts up to its highest value, wraps back around to zero, and counts up again.

# Answer
> 35 votes
# LOLCODE, 24 bytes

```
IM IN YR X
IM OUTTA YR X

```

# Answer
> 34 votes
# C, 15 bytes

```
main(){main();}

```

Yes, it's possible to call `main()` recursively. If you've got a compiler that does tail-call optimization (say, gcc with the `-O2` option), it doesn't even segfault: the compiler is smart enough to turn the function call into a `goto`.

# Answer
> 31 votes
# Vim, 7 keystrokes

Open the editor, preferably without any loaded scripts, for instance like like this from the command line: `vim -u NONE`

```
qq@qq@q

```

# Vimscript, ~~15~~ 8 bytes

Add it in a script, or run it directly by punching the colon (`:`) key first while you're in normal mode

```
wh1|endw

```

# Answer
> 26 votes
# Labyrinth, 1 byte

```
"

```

A labrinth program executes the same instruction over and over again if there are no neighbors. They also won't end until they execute the `@` instruction.

# Answer
> 26 votes
# Retina, 3 bytes

```
+`0

```

If given a single file, Retina uses a Count stage, replacing the input with the number of matches found for the given regex. Here, the regex is `0`. Now `+` loops the stage for as long as the result changes from the previous iteration. So what exactly is happening?

* `0` is matched against the empty input, giving zero matches, so the result is `0`. This is different from the input, so we run this again.
* `0` is matched against the previous output `0`, which now gives one match... so the result is `1`.
* `0` is matched against the previous output `1`, which fails... so the result is `0`.
* ... you get the idea.

The result of the loop iteration alternates between `0` and `1`, which a) ensures that the loop never terminates and b) ensures that we're not running out of memory because the string doesn't grow.

By default, Retina only outputs once the program terminates, so this doesn't print anything (you can change this behaviour by adding a `>` after the `+`, which will then print the alternating zeroes and ones).

As of 1.0, Retina actually also has more traditional while-loops, which you could use with a simpler stage (which doesn't change the string all the time), but they actually require more bytes. One option would be:

```
//+`

```

# Answer
> 26 votes
# BASIC (QBasic 4.5), ~~10~~ ~~5~~ 3 bytes

*In the BASIC programming language, RUN is used to start program execution from direct mode, or to start a overlay program from a loader program.* \- Wikipedia

Edit: This works without a line number in QBasic 4.5, according to @steenbergh

```
RUN

```

Here's the first version I posted. Infinite GOTO loop. Also, it's 10 bytes, which is a nice coincidence!

```
10 GOTO 10

```

# Answer
> 25 votes
# TIS Node Type T21 Architecture, 6 bytes

Tessellated Intelligence System nodes are classified as "processing" or "storage" nodes. Storage nodes simply store and retrieve information, and are irrelevant in this case. Remaining are the processing nodes. Node Type T21, or Basic Execution Node, is the most common and simple (as the name would suggest).

Technically, each node can be thought of as an independent computer. In the case of the T21, it is a computer that has two storage registers (one addressable, one not) and an instruction set of 15 commands. It has enough memory to be programmed with up to 15 instructions. All TIS nodes have four ports connecting them to the topologically adjacent nodes. Reading from a port causes that node to hang until the node on the other end writes to it, and writing to a port hangs until that node reads it.

You might be able to tell by now that TIS nodes were never meant to do much on their own. Together, though, they can be quite powerful... well, for their time. Because of these limitations, it's very rare to see someone use only a single node. In fact, a program that takes input and provides output based on it *must* use at least three nodes, as TIS systems feed input into the `UP` port of a node on the top row and take output from the `DOWN` port of a node on the bottom row. There are three rows, so data must pass through at least three nodes to get to the bottom.

Because of these limitations, TIS nodes are intended to *generally* be used somewhat like this:

1. Get input
2. Do something to it
3. Pass it on
4. Return to step 1

Because of this, the limited space for instructions and the fact that nodes simply wait quietly and don't cause trouble when trying to read input that isn't there, a decision was made in their design that makes them very good for this challenge. I'll quote from the TIS-100's reference manual:

> After executing the last instruction of the program, execution automatically continues to the first instruction.

Perfect! Infinite loops are default for TIS nodes.

I very nearly answered this question with a 0 byte answer, claiming that an empty node was an infinite loop. However, I researched further. First, the quote above states that the loop occurs *after executing the last instruction*. Additionally, I tested the implementation. Each node reports a "mode" at all times. It isn't accessible programmatically but it's intended to make debugging easier. Here are the possible modes:

```
 RUN - I am executing an instruction.
READ - I am reading from a port, waiting for it to be written to.
WRTE - I am writing to a port, waiting for it to be read from.
IDLE - I am doing nothing.

```

It turns out that, since each node is an individual computer, they are capable of determining whether or not they have instructions to execute. If not, they remain in the `IDLE` state (likely to save power). As such, I couldn't in good conscience claim that it was "looping"; rather, each node sat quietly, assuming the others were doing something important.

This program that I've submitted is truly an infinite loop, as executing it sets the state of the node to `RUN`. It is as simple as you would expect, `NOP` performs `N`o `OP`eration. Once it's done doing nothing, execution returns to the top of the code: `NOP`.

If you find it unsatisfying that I'm abusing the T21 architecture to create a loop, I offer an alternate solution at the cost of 2 bytes: `JRO 0`. `JRO` means `J`ump `R`elative unc`O`nditionally. Or something, I guess. There's no agreed-upon expanded form of the instructions. Anyway, `JRO` takes a numeric argument and jumps execution by that amount relative to the current position. For example, `JRO 2` skips the instruction that follows it (useful if that instruction is jumped to from somewhere else). `JRO 1` jumps forward one instruction, making it a `NOP`. `JRO -1` jumps back one instruction, effectively performing the previous instruction once every two cycles until the program is halted. And, of course, `JRO 0` jumps to itself, executing itself forever.

At this point you may be thinking:

> Sure, monorail, this all makes sense, but your answer is simply `NOP`. Why is its score 6 bytes?

Good question, thanks for asking. One may naively think that TIS programs should be counted the same way we count programs in multiple files: the number of bytes in all nodes, plus 1 byte for each additional node after the first. However, the TIS golfing community decided this would be unfair for the simple reason that it ignores some of the information required to recreate solutions. A node's neighbours are very important, and that scoring method gives you positional information for free. Instead, we've adopted the format used by the most common TIS emulator, the confusingly-named TIS-100. (Side note: Please don't name emulators after the system they emulate. It's not clever, it's just annoying and makes everyone have to constantly clarify what they're talking about.) It's very simple: The 12 nodes of a TIS-100 device are numbered, left to right and top to bottom, skipping any storage nodes the emulated system has installed. A node numbered `N` containing `# CODE\n# CODE\n CODE` is saved like so:

```
@N
# CODE
# CODE
# CODE

```

And so, a node numbered 0 containing `NOP` is scored according to its representation in this format:

```
@0
NOP

```

Six bytes.

As I often include in my answers in visually-interesting languages, you can watch the TIS-100 emulator execute this program on YouTube. Though, considering what this challenge is, I don't know what you expect to see...

# Answer
> 24 votes
# Perl, 4 bytes

```
do$0

```

Executes itself repeatedly.

# Answer
> 23 votes
# C#, 38 37 36 bytes

```
class B{static int Main(){for(;;);}}

```

For loop with no stopping condition.

The return of main should be an int, but since it'll never reach the end this should compile. (Tested in VS 2015 and 2013, also works in Ideone). Thanks Geobits and MichaelS.

A shorter version, **35** bytes, can be achieved, but prints `Process is terminated due to StackOverflowException` which I believe violates the third point of not printing anything to stderr. Credit to MichaelB

```
class B{static int Main()=>Main();}

```

# Answer
> 22 votes
# Foo, 3 bytes

```
(1)

```

Everyone's favorite programming language! :D

# Answer
> 21 votes
# Hexagony, 1 byte

```
.

```

I don't know much about this awesome language created by @MartinBüttner, but from what I've seen, this should loop infinitely, as there is no `@` to halt the program. `.` is simply a no-op.

# Answer
> 20 votes
# bash + BSD coreutils, ~~23 22 14 6 5~~ 6 bytes

```
yes>&-

```

`yes` outputs "y" forever; `>&-` closes STDOUT.

Thanks @Dennis and @ThisSuitIsBlackNot for help getting the size down!

# Answer
> 18 votes
## Pyth, 2 bytes

```
#

```

Pyth expects tokens after the forever operator. (That's a space.)

# Answer
> 18 votes
# Gammaplex, 0 bytes

In Gammaplex, it isn't possible to write a program that isn't an infinite loop. So I just write a program that doesn't use input/output.

# Answer
> 17 votes
## Common Lisp, 6 characters

```
(loop)

```

# Answer
> 14 votes
# Fission, 1 byte

There are exactly 4 one-byte solutions:

```
R

```

```
L

```

```
U

```

```
D

```

These four letters indicate that an atom starts there (in the corresponding direction). One of them is required because without an atom the program terminates immediately. Since the source code is only one character in size, the atom will wrap around immediately, and execute the same cell again. However, after the beginning of the program `UDLR` simply act to deflect an incoming atom in the corresponding direction, so they become no-ops in this case.

# Answer
> 13 votes
# PowerShell, 7 bytes

```
for(){}

```

...

# Answer
> 13 votes
# Microchip PIC Machine Code, 0 bytes

An unprogrammed/erased PIC will by default have the program memory (flash) contain all NOP instructions. NOP does nothing.

Now, NOPs by themselves don't implement infinite loop. But the PIC program counter by design wraps around back to zero. Therefore, an unprogrammed/erased PIC executes an infinite loop.

Note: This is true for a lot of CPU architectures. Especially microcontrollers.

# Answer
> 12 votes
# GolfScript, 3 bytes

```
1do

```

For obvious reasons, this does not work in the online interpreters.

# Answer
> 12 votes
# Funciton, 72 bytes

Encoded in UTF-16.

I cannot think of a smaller Funciton program that would run forever. It consists of a declaration of a function that calls itself and a main program that calls said function on STDIN. Is it possible to do shorter?...

```
┌─╖╓─╖┌─╖╔╗
┤∞╟╢∞║┤∞╟╢║
╘═╝╙─╜╘═╝╚╝

```

# Answer
> 11 votes
## C, 11 bytes (on old x86)

```
main=65259;

```

`65259` or `0xfeeb` is the machine code `eb fe` or `jmp -2`. Jumps are relative to the next instruction, so this loops.

This compiles (with a warnings) and works on my Linux 2.4.9.
Newer Linux will usually put `main` in a non-executable section. Adding `const` will fix it, but at an unbearable price.

Just noticed kirbyfan64sos's answer that uses the same machine code. But it's not in C.

# Answer
> 10 votes
# Matlab/Octave, 11 bytes

```
while 1;end

```

(tested)

# Answer
> 10 votes
# Mouse, ~~5~~ 3 bytes

```
()$

```

This is just a simple "while true do nothing."

Saved 2 bytes thanks to cat.

# Answer
> 10 votes
## A POSIX OS's program loader, 14 bytes

```
#!/usr/bin/env

```

# Answer
> 10 votes
## Mornington Crescent, 117 106 Bytes

```
Take Northern Line to Bank
Take Circle Line to Temple
Take Circle Line to Bank
Take Northern Line to Angel

```

There appear to be some bugs in the Python interpreter, but the language's creator has a C# interpreter that works for this code.

\*Inspired by @ETHproductions

EDIT: Since it doesn't ever terminate, can remove required return to Mornington Crescent

Thanks Martin Büttner for 8 bytes, and Timwi for 3 bytes.

# Answer
> 9 votes
# Recall, 2 bytes

```
Yy

```

Since there is no break operator, it will loop forever. You can try it here. Of course it will freeze the tab.

# Answer
> 9 votes
# Pyth, 2 bytes

I think the only solutions are `'# '`, which has already been posted, and the `f` based solutions:

```
f0
fk
fH
fY
fZ
f"
f[
f(
f{
f]

```

`f` followed by anything falsy.

# Answer
> 8 votes
# Turing Machine Code, 9 bytes

As usual, I'm using the rule table syntax defined here.

```
0 _ _ * 0

```

"When in state `0`, upon reading an empty cell, replace it with an empty cell, don't move, and transition to state `0`."

# Answer
> 8 votes
## Macaroni 0.0.2, 14 chars

```
label a goto a

```

Fairly self-explanatory...

# Answer
> 8 votes
# Malbolge, 1 byte

```

```

A single-space program causes Ben Olmstead's reference implementation to loop forever. Can you find out why?

# Answer
> 8 votes
# Piet, 2 Codels

2 Codels is as small as a loopy Piet program gets.
With only 1 codel the 8 waits needed for a finish would be immediatly met.

In the example (10 pixel codelsize) the difference between the 2 colours are +2/-2 Hue delta and +2/-2 Light delta. So it keeps on repeating a *"roll" "not"*.

# Answer
> 7 votes
# Ruby, 6 bytes

Pretty self explanatory. Ok, my post is long enough now.

```
loop{}

```

# Answer
> 7 votes
# X86/X64 Machine Code, 2 bytes

Hex dump:

```
0xEB 0xFE

```

Disassembled source code:

```
f:jmp f

```

Basically, because the entry point `_start` isn't defined, `ld` defaults to the address that is coincidentally the location of `f`.

# Answer
> 7 votes
# JavaScript, 8 bytes

**NOTE:** This is the same as the existing Processing answer; just posting it for the sake of catalogue completeness.

```
for(;;);

```

**Bonus:** Here's a 12-byte ES6 alternative, using recursion instead:

```
a=_=>a();a()

```

# Answer
> 7 votes
## VBA (immediate pane), 14 bytes

This will freeze up the VBE and its host app:

```
do:loop

```

# Answer
> 7 votes
# Chef, ~~75~~ ~~52~~ 46 bytes

*Saved 23 bytes thanks to @Sp3000*

```
L.

Ingredients.
1 i

Method.
X i.M until xed.

```

Try it online! (if you dare)

Basically, this program repeatedly checks that `i` (always 1) is greater than zero, and while it is, `M`s the empty mixing bowl. ~~I tried to stick to the original spec as much as possible, so it may be able to golf this even more.~~ Thanks to TIO, I can now verify my changes with a copy of the interpreter!

# Answer
> 7 votes
# x86 Assembly, 3 Bytes

Inspired by this post

```
E8 FD FF

```

is the same as

```
label: call label

```

even better, write it to your boot sector to make your computer ~~unbootable~~ faster!

# Answer
> 7 votes
# rSNBATWPL, 1 byte

```
{

```

Lowkey unsure if this is a parsing bug or a feature, but it works and now I can't close the repl help please I have two unclosable tabs now Radvylf why would you do this.

# Answer
> 6 votes
# PHP, 8 bytes

```
for(;;);
```

When running from command line (-r argument) you don't need php openning/closing tags.

Ex.: php -r "for(;;);"

# Answer
> 6 votes
# APL, ~~8~~ ~~5~~ 4 bytes

```
-⍣=1

```

This repeats negation until the result is equal to the previous input (beginning at 1) which can't happen, so it loops indefinitely.

Saved 3 bytes thanks to Dennis and 1 thanks to jimmy23013!

# Answer
> 6 votes
# C, 17 bytes

```
main(){l:goto l;}

```

Why not for(;;);? Because `goto` are cool.. and `17` is a nice number

# Answer
> 6 votes
# Java6 : 25 Bytes

In Java 6 and previous versions you can execute `static` initialization block without having `main` in your class file.

```
class A{static{for(;;);}}

```

# Answer
> 6 votes
# Unlambda, 7 bytes

```
``ci`ci

```

Try it here. It uses `c` (`call-cc`) which is a little magical.

# Answer
> 6 votes
## Starry, 9 bytes

```
`      +'

```

Loops in Starry are written with ``` (which marks the current location in the code as label `n`, where `n` is the number of spaces in front of it) and `'` (which pops a value from the stack and jumps to label `n` if that value was non-zero). So we use these two `n = 0`. But that leaves the question how to get a non-zero value onto the stack. I believe the shortest way to do is simply to push a `1`, which requires 6 spaces and a `+`.

# Answer
> 6 votes
# JavaScript, 8 bytes

```
for(;;);

```

Since the expression to evaluate is omitted, it will always evaluate to `true` (i.e. your classic `while(true){}` loop in "disguise").

# Answer
> 6 votes
# MarioLANG, 3 bytes

```
!
=

```

I found several other solutions, but they seem to be bugs in the Ruby interpreter rather than features of the language (e.g. replacing `!` with `@`). This one actually seems to work intentionally. `=` is just a ground cell for Mario to stand on, and `!` instructs him to stop walking. So he just stands there, waiting for something to happen, which of course doesn't. (The usual purpose of `!` is to use it on elevators, such that Mario remains in place while the elevator moves to its target position.)

# Answer
> 6 votes
# Jelly, 1 byte

```
ß

```

Recursively calls the main link. Thanks to tail call optimization, this results in an actual infinite loop.

Try it online!

# Answer
> 6 votes
# Cubix, 0 bytes

```

```

Alternatively, *any* single character does exactly the same.

**Test it online!**

Cubix is a stack-based 2D language, created by me in March 2016. Cubix differs from ordinary 2D languages in that it's not strictly 2D: the code is wrapped around a cube. Any one-byte program wraps to this cube net:

```
   ?
>. . . .
   .

```

where `?` represents the character, and the IP (instruction pointer) starts at the arrow. `.` is simply a no-op, and when the IP reaches the right side of the cube net, it simply wraps back around to the left. Thus, any 1-byte program does nothing forever, no matter what the character is (as long as it's not whitespace).

Thanks to @ErikGolferエリックゴルファー for reminding me that the empty program does the same. When Cubix was originally created, this didn't work, because the interpreter created a cube of size 0 and threw an error when it tried to run. This was fixed a while ago, and it is now impossible to cause an error in Cubix.

# Answer
> 5 votes
# Processing, 8 bytes

```
for(;;);

```

This is based on Geobit's answer in Java

Although the code below is not the shortest, it is one of Processing's specialties.

```
void draw(){}

```

This `draw` statement repeats itself over and over again. It is one of the differences between Processing and Java.

# Answer
> 5 votes
# CJam, 4 bytes

```
1{}h

```

Put a 1 on the stack, and loop until 1 is no longer truthy. Using `h` means that the number is never popped.

# Answer
> 5 votes
# C++ 11 template metaprogramming, ~~58~~ 54 bytes

```
template<int>struct I{int v=I<1>{}.v;};int a=I<1>{}.v;

```

C++ helpfully comes packaged with 2 other turing complete languages: the C preprocessor, and template metaprogramming. Note that this does reach a max recursion depth at some point, but the OP clarified that this is okay.

Example run:

> ```
> g++: internal compiler error: Segmentation fault (program cc1plus)
> Please submit a full bug report,
> with preprocessed source if appropriate.
> See <http://gcc.gnu.org/bugs.html> for instructions.
>
> ```

# Answer
> 5 votes
# Beam, 2 bytes

There is a few ways of doing this from the very basic

```
><

```

to the very basic

```
>?

```

and

```
>|

```

# Answer
> 5 votes
# Commodore Basic, 3 bytes

```
1R╭

```

PETSCII substitution:  = `SHIFT+U`, ungolfs to `1 RUN`.

Taking advantage of Commodore Basic's shortcut forms and the fact that any immediate-mode command can also be used in a program, this code simply runs itself, forever.

Alternatively, a more thoroughly infinite loop is the immediate-mode command

```
S|7

```

(PETSCII: `|` = `SHIFT+Y`, ungolfs to `SYS 7`).

This transfers execution to memory location 0x0007. The BASIC interpreter stores the current search character here; when running the above code, this character is the double-quotation mark with byte value 0x22. Opcode `0x22` is an undocumented `HALT` opcode, which works by putting the 6510's micro-operation interpreter into an infinite loop. The only way out of this loop is to reset the computer.

# Answer
> 5 votes
# TI-BASIC, 2 bytes

If recursion is allowed (is it a loop?)

```
prgmA

```

Runs a program named 'A', hence the program must be named the same. Some research revealed that `prgm` is 1 byte, plus 1 byte for `A`

Runs out of memory pretty quickly, but that doesn't seem to be addressed above.

# Answer
> 5 votes
# COBOL, 51 bytes

```
ID DIVISION.PROGRAM-ID.A.PROCEDURE DIVISION.B.GO B.

```

# Answer
> 5 votes
# Tcl/Tk, 0 bytes

Execute any empty file with the `wish` interpreter instead of `tclsh`.

# Answer
> 5 votes
# Rust, 17 bytes

Didn't see one in rust so:

```
fn main(){loop{}}

```

real original and interesting and so different from all the other entries.

# Answer
> 5 votes
# Half-Broken Car in Heavy Traffic, ~~5~~ 4 bytes

```
^ov#

```

also in 4 bytes:

```
o
 #

```

# Answer
> 5 votes
# Binary Lambda Calculus, 3 bytes

Before I dive into the explanation, let's start with the program itself.

```
F†€

```

Trust me, it's pure luck that they're all printable, and I'll get to why it is 2 1/4 bytes instead of 3 after the explanation. I'll explain this by walking through the process I took to create this program.

To start, BLC programs are just lambda calculus programs encoded in a special way. With this in mind, let's begin with the lambda calculus program that enters an infinite loop, known as omega.

```
(λx.xx)(λx.xx)

```

This results in an infinite loop because, according to Wikipedia, it reduces to itself after a single beta-reduction. To convert this into BLC, we must first convert it to De Bruijn indices. It converts into the following:

```
.λ.11λ.11 (The dots after the λs are necessary for BLC but not part of De Bruijn indices)

```

Okay, now that it's in De Bruijin indices we can now convert it into BLC where `λ` translates to `00`, function application or `.` translates to `01`, and numbers are represented as `1^n0` where `n` is the number. Knowing this, it translates into the following binary:

```
01 00 01 10 10 00 01 10 10

```

This is why it's 2 1/4 bytes. As BLC instructions aren't full bytes (with the exception of 7), it is rare for programs to fit exactly into a certain byte count. To turn this into hex, we have to pad it in order to make it fit into 3 bytes. Doing this yields the following:

```
46 86 80

```

There we have the hex dump of our program! It runs in an infinite loop, doesn't run out of memory to my knowledge, doesn't output anything, and is a complete program that can be saved and run by piping the contents of the file to the official interpreter. You can also pipe the binary text to the interpreter and add the -b flag, to demonstrate that the non-padded version can be run.

# Answer
> 5 votes
# x86-16 Assembly, IBM PC DOS, 2 bytes

There's quite a few machine code answers, but thought I'd contribute a few different takes.

```
56    PUSH SI    ; push 100H onto stack
C3    RET        ; pop stack and jump to address (PUSH SI)

```

On DOS when a program is started the `SI` register contains the starting address of the program (generally `100H`). Push that onto the stack and execute a `RET` which will pop the stack and jump to that address. Big ol' loop.

---

### x86-16 Assembly, 1 byte

```
F4   HLT         ; halt the processor and wait for signal

```

Okay, so this may depend a little on your definition of infinite loop. The `HLT` instruction (specifically in 8086 real mode) puts the processor in HALT state and awaits a signal in the form of `BINIT#`, `INIT#`, `RESET#` or interrupt (ref). While it's not technically executing our code, it is in a microcode loop of sorts waiting for one of those signals.

---

### Motorola 6800, 2 bytes

```
9D DD   HCF      ; halt and catch fire

```

From Wikipedia:

> When this instruction is run the only way to see what it is doing is with an oscilloscope. From the user's point of view the machine halts and defies most attempts to get it restarted. Those persons with indicator lamps on the address bus will see that the processor begins to read all of the memory, sequentially, very quickly. In effect, the address bus turns into a 16 bit counter. However, the processor takes no notice of what it is reading… it just reads.

# Answer
> 4 votes
# GNU dc, 6 bytes

```
[dx]dx

```

Tail recursion FTW, which GNU dc supports. Others might not.

# Answer
> 4 votes
# MUMPS, 1 byte

```
f

```

This is the equivalent of `for ( ; ; ) ;` in C-like languages. It runs from the prompt as is, though, and does not need to be wrapped in a function declaration or any such thing.

# Answer
> 4 votes
# MSM, 2 bytes

```
ee

```

Almost all 2 character strings will work, even two spaces, just don't use any of the following 6 commands `:,/.?'`.

# Answer
> 4 votes
# AT&T (PDP-11) Syntax Assembly: 4 bytes

```
br .

```

# PDP-11 UNIX A.OUT binary output: ~~24~~ 18 bytes

```
0000000  000407 000002 000000 000000 000000 000000 000000 000000
0000020  000777 000000 000000 000004
0000030

```

This is the output produced by the assembler. As the sizes in the header show, the last three words are not necessary, it can be cut down to the first 18 bytes.

Some modern assemblers do not support the br instruction, so it would be **five bytes** for `jmp .`. And executable headers are generally much bigger these days.

# Linux x86-64 binary output, after strip: 336 bytes

Now, OSX's assembler is much more strict. You must have a symbol (by default `start`, but here I use `f`) for the entry point, which balloons the size of the source. It also requires a newline at the end of the file.

# Mac OS X x86-64 Assembly: 17 bytes

```
.globl f
f:jmp f

```

# Mac OS Mach-O Binary Output: 4200 bytes

# Answer
> 4 votes
# Mathematica, ~~10~~ 8 bytes

```
0~Do~∞

```

# Answer
> 4 votes
# Javascript (8 bytes)

```
for(;;);

```

Edit courtody of @KritixiLithos

# Javascript (10 bytes)

```
while(1){}

```

# Answer
> 4 votes
# z80 Machine Code, 1 byte

```
c7       ; RST 00h

```

Or if assuming the code starts at `0000h` is cheating, two bytes:

```
18 fe    ; JR -2

```

These solutions make no assumptions about the rest of the environment's RAM. If it's filled with zero bytes, we are just spinning through `NOP`s forever, so we could have a 0-byte solution. (Thanks to Thomas Kwa for pointing this out.)

# Answer
> 4 votes
# Scheme, 12 bytes

A tail-recursive infinite loop seems most appropriate for scheme `:-)`

```
(let l()(l))
```

even though `(do(())())` (the CL variant of which is due to @JoshuaTaylor) would be 2 bytes shorter.

# Answer
> 4 votes
# Fortran, 11 bytes

It is not very creative, but here is the shortest I found:

```
1goto 1
end

```

I am pretty sure this is not standards compliant, but it compiles with `ifort`.

# Answer
> 4 votes
# 3var, 2 bytes

```
{}

```

To quote the docs:

```
{   Starts a loop which repeats forever
}   Ends a loop which repeats forever

```

# Answer
> 4 votes
# , 8 bytes

```
repeat{}

```

I believe this is the shortest way to make a loop that won't stop. We would need an infinite length list to use a for loop and `while(T)` is longer than `repeat`.

# Answer
> 4 votes
# NASM/YASM x86 assembly, 4 bytes

```
ja $

```

`$` is the address of the current instruction, and `ja` jumps there if the carry and zero flags are both unset. (i.e. the Above condition is true.) This is the case in x86-64 Linux at process startup.

`ja$` just defines a symbol, instead of being an instruction, so the space is not optional. I did test that this works without a trailing newline, so it really is 4 bytes.

Assemble/link with

```
$ yasm -felf64 foo.asm && ld -o foo foo.o
ld: warning: cannot find entry symbol _start; defaulting to 0000000000400080

```

The x86-64 ABI used by Linux doesn't guarantee anything about the state of registers at process startup, but Linux's actual implementation zeroes all the registers other than RSP for a newly-`exec`ed process. `EFLAGS=0x202 [ IF ]`, so `ja` (jump if Above) does jump, because the carry and zero flags aren't set. `jg` (ZF=0 and SF=0) would also work. Other OSes that initialize flags differently might be able to use one of the other one-letter conditions that require a flag bit to be set: `jz`, `jl`, `jc`, `jp`, `js`.

Using `ja` instead of `jmp` (unconditional jump) makes the source one byte shorter, but the binary is the same size (2 bytes: one opcode byte, one rel8 displacement, for a total size of 344 bytes for a stripped ELF64 binary. See casey's answer for a 45 byte ELF executable if you're interested in small binary size rather than small source size.)

# Answer
> 4 votes
# pb, 8 bytes

In pb, the shortest possible infinite loop is 8 bytes long. In fact, there are sixty 8 byte infinite loops, none of which produce output! (Unless you're running in watch mode, which is intended for debugging, no pb programs produce output until they halt. However, even if one of these did eventually halt, no output would have been produced.) Here are the sixty shortest infinite loops, in alphabetical order:

```
w[B!1]{}
w[B!2]{}
w[B!3]{}
w[B!4]{}
w[B!5]{}
w[B!6]{}
w[B!7]{}
w[B!8]{}
w[B!9]{}
w[B=0]{}
w[C!1]{}
w[C!2]{}
w[C!3]{}
w[C!4]{}
w[C!5]{}
w[C!6]{}
w[C!7]{}
w[C!8]{}
w[C!9]{}
w[C=0]{}
w[P!1]{}
w[P!2]{}
w[P!3]{}
w[P!4]{}
w[P!5]{}
w[P!6]{}
w[P!7]{}
w[P!8]{}
w[P!9]{}
w[P=0]{}
w[T!1]{}
w[T!2]{}
w[T!3]{}
w[T!4]{}
w[T!5]{}
w[T!6]{}
w[T!7]{}
w[T!8]{}
w[T!9]{}
w[T=0]{}
w[X!1]{}
w[X!2]{}
w[X!3]{}
w[X!4]{}
w[X!5]{}
w[X!6]{}
w[X!7]{}
w[X!8]{}
w[X!9]{}
w[X=0]{}
w[Y!1]{}
w[Y!2]{}
w[Y!3]{}
w[Y!4]{}
w[Y!5]{}
w[Y!6]{}
w[Y!7]{}
w[Y!8]{}
w[Y!9]{}
w[Y=0]{}

```

These all follow a simple pattern. `w` is a while loop, pb's only looping or branching instruction. Inside the square brackets is the condition, which is two expressions separated by `!` or `=`. To understand what this means, imagine an extra `=` just before the second expression. In the same way that you understand `2+2==4` to be true and `10!=5*2` to be false, `2+2=4` and `10!5*2` are true and false in pb. A while loop is executed until the condition becomes false. Finally, there is a pair of curly braces containing pb code. In this case, there's no code to be run, so they are empty.

The important thing here is the condition. pb has six variables, all for different purposes. They are:

```
B - The value of the character under the brush
C - The colour of the character under the brush (from a lookup table, the important thing being that white = 0)
P - The current colour that the brush is set to output in (same lookup table)
T - Set by the programmer, initialized to 0
X - X position of the brush
Y - Y position of the brush

```

The brush starts at (0, 0) on a canvas that is entirely initialized to white null bytes. This means that all of the variables start out being equal to 0.

These sixty programs fall into two categories: 10 loops that are executed until a variable (equivalent to 0) stops being zero, and 50 loops that are executed until a variable (equivalent to 0) becomes a specific non-zero number. An infinite number of programs can be written that fall into that second group, but only 50 are the same length as the 10 in the first one.

# Answer
> 4 votes
# ArnoldC, 61 bytes

```
IT'S SHOWTIME
STICK AROUND 1
CHILL
YOU HAVE BEEN TERMINATED

```

Ironic how the program never actually terminates, even though the last line says "YOU HAVE BEEN TERMINATED."

# Answer
> 4 votes
# Vitsy, 1 Byte

```
<
```

~~Since Vitsy loops around the line, a single space is an infinite loop.~~ This functionality was removed in the latest version, but this applies as a special condition for looping around a line.

You could technically also do it like this:

```
[
```

But it throws an error after a little while:

```
Exception in thread "main" java.lang.StackOverflowError
    at com.VTC.vitsy.OperativeHandler.doOperation(OperativeHandler.java:6)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:88)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    ... (few hundred more lines)

```

It's a pretty staggeringly long error.

The 'correct' way to do an infinite loop in Vitsy, however, is this:

```
[1]
```

where `1` is any number `[1-f]`. `[` starts a while loop, `1` pushes 1 to the stack, and `]` pops the top item off the stack and tests if it is 0. If it isn't, go back to the beginning of the loop.

# Answer
> 4 votes
## Brian & Chuck, 7 bytes

```
#{?
#{?

```

The `#` could be replaced by any other characters except null-bytes or underscores.

The idea is fairly simple:

* Brian moves Chuck's instruction pointer to the start (`{`) and hands control over to him (`?`).
* Chuck moves Brian's instruction pointer to the start (`{`) and hands control over to him (`?`).
* Repeat.

# Answer
> 4 votes
# Seed, 2 bytes

```
0

```

*(note the trailing space character)*

Any seed program consists out of 2 instructions, seperated by a space; The length of the Befunge program it will output and the seed which will generate that program.
Seeing how we need a Befunge program of length 0, we can create a Seed program with an empty 2nd instruction.

The Seed program `0` will output an empty Befunge program, which will run forever.

Interesting to note is that the Python compiler on the Seed esolang page is erroneous.
To create a Befunge program of length 0, any seed will do. That includes an empty seed. To stick to the spec however, the space after `0` is not omitted.

That being said, this is the world's shortest Seed program, and also the easiest to reverse engineer :-)

# Answer
> 4 votes
# Aubergine, 6 bytes

```
:aa=ia

```

`:aa` is a no-op. `=ia` sets the IP to its own location.

# Answer
> 4 votes
# Mumps, 1 byte

```
F

```

Mumps being a very old language, most of it's commands and operators can be truncated to 1 or 2 letters. The \[F\]or command with no parameters defaults to an infinite loop until interrupted by a {CTRL}{C}. The flavour of Mumps that I use is InterSystem Caché.

# Answer
> 4 votes
# Mmmm(), 56 bytes

```
mm=m[m.m()].m;mm=mm(mm(m.m()));m[mm].m(mm);<m[mm].m(mm)>

```

No, I have no idea how it works either.

# Answer
> 4 votes
# Linux shebang, 5 bytes

```
#!./a

```

Must be named as a.

Will run out of memory, but this is an infinite loop.

# Answer
> 4 votes
## Bash, ~~10~~ 2 bytes

```
$0

```

Runs the file specified by `$0` (i.e. itself). Requires that the script is executable.

# Answer
> 4 votes
# C (tcc), x86\_64, 10 bytes

```
main=-277;

```

Try it online!

### How it works

This writes the *int* **-277** (`ebfeffff` in little endian) to the memory location of *main*.

`eb` is JMP and is to be followed by a signed 8-bit address indicating where to jump to. `fe` is **-2**, so we jump back to `eb` and start over.

# Answer
> 4 votes
# Lost, 0 bytes

Try it online!

Another 2D language with a zero byte answer. Funnily enough, the *minimum* byte count to terminate consistently is 5 bytes:

```
%@
//

```

Try it online!

# Answer
> 4 votes
# Racket, 39 bytes

```
((λ(x)(x x))(λ(x)(x x)))

```

# Answer
> 4 votes
# StackLang, 1 byte

```
2

```

## Explanation

2 is an opcode for infinite loop. When it reaches the bottom of the stack, it loops around.

# Answer
> 4 votes
## Aussie++, 47 bytes

```
G'DAY MATE!
THE HARD YAKKA FOR f IS()<f();>f();

```

Tested in commit 0a5de7e. The official syntax for this is:

```
G'DAY MATE!

I RECKON I'LL HAVE A WALKABOUT UNTIL (YEAH, NAH) <
>

CHEERS C***!

```

However, that `UNTIL` loop is so verbose it's shorter to use a recursive function.

# Answer
> 3 votes
# Element, 3 bytes

```
!{}

```

The control stack is initially empty, the `!` negates it to truthy, and `{}` is a loop-while-true which never ends.

# Answer
> 3 votes
# Scala, 12 bytes

```
while(1>0){}

```

# Answer
> 3 votes
# TI-BASIC, 4 Bytes

```
While 1
End

```

Also:

```
Lbl A
Goto A

```

---

---

---

This last language isn't really an answer, as the language does not exist… yet. So, yeah, just some information, and how one might accomplish this task

**Simplex, 1 Byte**

```
O

```

*Simple* enough. Simplex has the `O` command, which goes to the \_N\_th character in the source code, with *N* being the current byte. Since, by default, a byte is `0`, this continues to go to the first character in the source code (zero-based).

# Answer
> 3 votes
# rs, 3 bytes

```
+/1

```

Note that this will eventually run out of memory...

# Answer
> 3 votes
## x86 Intel Assembly (NASM), 5 bytes

```
jmp $

```

# Answer
> 3 votes
# Julia, ~~13~~ 12 bytes

```
while 1<2end

```

Yawn. I tried a map and a for loop, but to no avail...

EDIT: Someone pointed out that I could shorten the program by removing parentheses. Thanks!

Alternatively, if stack-overflowing infinite recursion counts as infinite (11 bytes):

```
i()=i();i()

```

# Answer
> 3 votes
# ZX Spectrum BASIC, 2 bytes

```
1 RUN

```

The program will never run out of memory :-)

Explanation:

* There is no space between the line number and the command, it is just a visual clue displayed when LISTing the program
* The keyword RUN is one byte, in Sinclair BASIC the keywords were really just a single characters (with codepoints \>=128), that just happened to look like multi-character words when displayed. In particular, you enter the keyword by pressing *one key*, the one with the keyword on it, and it enters one byte.

The internal representation is a bit longer (line number is stored as two bytes), but isn't this true for almost all the languages? :-)

# Answer
> 3 votes
# k, 4 bytes

```
~:/1

```

## How it works

In k, `/` iterates the function on the left starting with the argument on the right until the result repeats. The `~:` is a "not" function which turns 1 into 0 and 0 into 1 repeatedly in this code.

# Answer
> 3 votes
# Pascal, 32 bytes

```
program l;begin while 1=1do;end.

```

A full program in just one line.

* `program l;`: Start a new Pascal program
* `begin`: Begin a code section
* `while 1=1do;`: Do nothing (`;` / `NOP`) as long as `1=1`, which shorter than `true`. Identifiers (`do` for instance) are not allowed to begin with a digit, so we can omit the space here and save one byte.
* `end.`: End the code section

# Answer
> 3 votes
# Go, 31 Bytes

```
package main
func main(){for{}}

```

Nothing special, the for loop without header runs infinitely.

# Answer
> 3 votes
# Beatnik, 8 bytes

```
K A XX K

```

Push a number, 1 in this case. Pop a number, if not zero skip back 4(crossed out 4) 5. There seems to be an issue with the interpreter so we need to skip back 5 instructions rather than 4.

Of course the example on the esolangs page is better.

```
Ha, an interminable line!

```

or my version

```
Start a neverending tale?

```

# Answer
> 3 votes
# Burlesque, 2 bytes

```
bc

```

The `BoxCycle` command. Essentially takes whatever string `s` is on STDIN and tries to evaluate the infinite list `[s, s, s...]`

# Answer
> 3 votes
# Lazy K, ~~8~~ 7 bytes

```
SISSSII

```

Reduces to the lambda expression `(λx.x x) (λx.x x)` which has no normal form.

# Answer
> 3 votes
# SQL (SQL Server 2008+), 92 bytes

```
WITH R AS(SELECT 1N UNION ALL SELECT N*1FROM R)SELECT*FROM R WHERE N<1OPTION(MAXRECURSION 0)

```

I feel ~~a little~~ dirty putting this up, but my original thought was that this wouldn't be possible with a SQL query. With something like T-SQL or PL/SQL not a problem, as a query though? The obvious answer was a recursive query with no recursion limit set. But how to get it to run without outputting anything. My initial tests using queries like

```
WITH R AS(SELECT 1N UNION ALL SELECT N FROM R)SELECT*FROM R WHERE N=0OPTION(MAXRECURSION 0);
WITH R AS(SELECT 1N UNION ALL SELECT N FROM R)SELECT*FROM R WHERE N<1OPTION(MAXRECURSION 0);

```

showed that the optimizer would cause the query to exit immediately with no rows returned. Using `N+1` allowed it to loop, but I suspect that the integer would eventually overflow. I used `N*1` in the query to avoid that and trick the optimizer into letting it run without short cutting out. I've let it run for a few minutes on my machine and it didn't seem to start consuming memory, but I can't guarantee that wouldn't happen.

# Answer
> 3 votes
# Rail, 11 bytes

```
$'main'
@-@

```

Rail starts at the `$` of the `main` function, heading southeast. We hit `-`, which makes the train turn and move eastward. After that it's just bouncing all night long between two `@` reflectors.

# Answer
> 3 votes
# Insomnia, 2 bytes

```
HY

```

It encodes the sequence of instructions: `7289`

Although it's not clear whether instruction 8 checks the content of the bit pointer or the group pointer, the code above works in either cases, since the content of the bit or the content of the group is always non-zero.

# Answer
> 3 votes
# Ziim, 14 bytes

Encoded in UTF-16. (UTF-8 without BOM is 16 bytes...)

```
↘↙↙
↑↑

```

# Answer
> 3 votes
# Emmental, ~~18~~ 11 bytes

```
;#35#63#!#?

```

Emmental is a self-modifying, stack-based language. It has no built-in looping operator, so we have to make our own. Here's what the relevant commands mean (taken from the Esolangs wiki page):

* `;` \- Push the symbol `;` onto the stack.
* `#` \- Push `NUL` (ASCII 0) onto the stack.
* `0..9` \- Pop a symbol, multiply its value by 10, add 0..9 respectively, and push the result.
* `!` \- Pop a symbol and an Emmental program (a string of symbols terminated by `;`). Then redefine that symbol as having the same semantics as that Emmental program.
* `?` Pop a symbol and execute it. This is similar to `eval`.

So, what does this program (created by @Sp3000) actually do? Well, it redefines `NUL` to mean `#?` (push `NUL` and execute it), then executes `NUL`. This sets off a domino-like effect where `NUL` executes `NUL` executes `NUL` executes `NUL`...you get the picture.

I'm no expert on Emmental, but there may be an even shorter way to loop infinitely. Suggestions welcome!

# Answer
> 3 votes
## Minkolang, 1 byte

A language inspired by space-time has to have at least SOME space! It's also worth noting that *this* particular 2D infinite loop is unique in that it's actually looping through time. That is, it's falling through the layers (of which there is only 1) of the program, which is toroidal.

# Answer
> 3 votes
# PowerShell, ~~14~~ 7 Bytes

```
for(){}

```

Previous version (14 bytes):

```
while($true){}

```

# Answer
> 3 votes
# Underload, 6 bytes

Directly from the esolangs page.

```
(:^):^
(:^)     Pushes :^ to the stack.
    :    Duplicates the top of the stack
     ^   Pops the top of the stack and includes it in the command

```

Try it here using the stepping option to see it working

# Answer
> 3 votes
# PoGo, 4 bytes

```
pogo

```

## Explanation:

* po - add current position in code to the top of the po stack
* go - pop the most recent po location off the stack and jump there

PoGo uses an explicit call stack for flow control, the "po" stack. This code unconditionally jumps back to the beginning, producing an infinite loop. Note that it will not cause a stack overflow, the call stack will never contain more than one element.

# Answer
> 3 votes
## AutoHotkey, 8 bytes

```
loop {
}

```

Previous answer posted in AHK was wrong and did not create a infinite loop.

# Answer
> 3 votes
## Quipu, 5 bytes

```
0&
??

```

`0&` pushes `0` as the current strand's value and `??` is an unconditional jump to that strand (which is the strand we're already on).

# Answer
> 3 votes
## DC, 6 bytes

```
[dx]dx

```

It puts the constant string `[dx]` on the stack, duplicates it (`d` command), pops and interprets string (`x` command).

# Answer
> 3 votes
# Subskin, 6 bytes

```

```

A series of six newlines. It contains two instructions, both of which set the IP to the second instruction.

# Answer
> 3 votes
# Batch, 9 bytes.

```
a:
goto a

```

# Answer
> 3 votes
# Fuzzy Octo Guacamole, 2 bytes

```
()

```

A empty infinite loop.

# Answer
> 3 votes
# MATL, ~~3~~ 2 bytes

Quite simple really:

```
`T

`    # Do ... while
 T   # True
     # Implicit end, normally: ]

```

Try it online here (Please stop it after testing, don't keep it running).

# Answer
> 3 votes
# evil, 2 bytes

```
mb

```

Nothing to see here, just another self-GOTO...

# Answer
> 3 votes
# GPRX 3000, 1 byte

```
g

```

Sets the IP to the value of register A (which is initially 0).

# Answer
> 3 votes
## Seed, 3 bytes

`0 0`

Equivalent to an empty Befunge program.

# Answer
> 3 votes
# Noobinary, 4 bytes

```
0000

```

`0000` is a single instruction that jumps to the last `00` (or start of program) if the top of stack is 0.

# Answer
> 3 votes
# Barely, 0 bytes

```

```

That's right! If the Barely interpreter receives the empty program, then it just hangs. Normally, the code would be terminated with a `~` to separate it from input, so the interpreter keeps reading EOF and never runs anything. Tested on DOSBox v0.74 using input redirection.

# Answer
> 3 votes
# BASIC, 8 bytes

```
1 GOTO 1

```

Goto self

# Answer
> 3 votes
# Brachylog, 2 bytes

```
=\

```

Takes no input and no output.

### Explanation

`=` will label the input with an integer. `\` is always false and will therefore trigger backtracking. Since the input has no constraints, it will unify as following, through backtracking: `0`, then `1`, then `-1`, then `2`, etc. This will go on forever.

# Answer
> 3 votes
# Sesos, 2 bytes

```
0000000: 080a                                              ..

```

Try it online! Check *Debug* to see the generated binary code.

### How it works

The binary file above has been generated by assembling the following SASM code.

```
nop       ; Set an entry marker.
    add 1 ; Increment the current cell.
          ; (implicit jnz)
          ;     If the integer in the current cell is non-zero,
          ;     jump to the previous instruction.

```

# Answer
> 3 votes
# Gaot++, 27 bytes

```
bleeeet bleeeeeet bleeeeeet

```

`bleeeet` enters the loop, and `bleeeeeet bleeeeeet` switches IP direction repeatedly.

# Answer
> 3 votes
# Bash or perl, 6 bytes

```
exec$0

```

I realize that are both bash solutions and perl solutions this length or shorter, but there are no dual-language solutions. Yup, it runs with either language.

# Answer
> 3 votes
# Casio FX-7000G, 5 bytes

```
Lbl 0
Goto 0

```

Quite self-explanatory: `Goto 0` indefinitely jumps back to the beginning of the program. The calculator stores each token as a byte, so `Lbl` and `Goto` are 1 byte each.

# Answer
> 3 votes
# tinylisp, 13 bytes

```
((v(d f(q(L(f

```

Parenthesis autocompletion really helps!

We define a function `f` that calls itself using tail-call recursion. Functions in tinylisp are lists containing two elements: parameter list and expression. Here, our parameter list is `L` (which makes this a variadic function: `L` is bound to a list of all arguments) and our expression is `(f)` (calling the function with no arguments).

```
((v(d f(q(L(f))))))
         (L(f))      The function list
       (q      )     Quoted to prevent evaluation
   (d f         )    Define f to be that list
 (v              )   The d call returns the name f; evaluate it to get the function itself
(                 )  Call the function

```

Use Ctrl-C to halt execution.

# Answer
> 3 votes
# APL, 2 bytes

`→1` go to line 1 (this line)

# Answer
> 3 votes
# Taxi, ~~22~~ 20 bytes

```
[a]Switch to plan a.

```

Try it online!

Not very exciting. TIO will only run it for 60 seconds before timing out.

# Answer
> 3 votes
# Brain-Flak, 8 bytes

```
(()){()}

Explanation:

(())   - Puts one on the top of the stack
{  }   - Runs until the top of the stack is zero
 ()    - Filler so that the above function runs

```

Try it online!

# Answer
> 3 votes
# Z80, 2 bytes \[non competitive, late entry\]

```
18 FE

```

Assembly

```
JR -2

```

or

```
LOOP JR LOOP

```

Note: `JR` is a relative jump (hex code 18), followed by a signed 8-bit number. It changes the program counter by that number; that happens after the whole command (2 bytes) has been red and program counter increased to point at the instruction immediately after. `JR 0` would then just have no effect (a 2 byte version of `NOP`).

# Answer
> 3 votes
# Z80Golf, 1 byte

```
00000000: c3                                       .

```

Try it online!

A jump opcode. Since memory is padded with zeroes, the argument is `$0000`, so that the PC forever jumps from `$0000` to `$0000`.

# Answer
> 3 votes
# Lua, 9 bytes

Here are all of the different ways (that I know of) to make an infinite loop in Lua, from shortest to longest:

Goto loop (Lua 5.2.0 beta-rc1 only) at 9 bytes:

```
@a:goto a

```

This is no longer possible in the latest version of Lua since the syntax for goto has changed, so this is now the shortest infinite loop at 11 bytes:

```
::a::goto a

```

The best that you can do using a while loop is 13 bytes by using an empty string, which Lua considers to be truthy, as the conditional:

```
while""do end

```

Here is a 14 byte repeat until loop using an uninitialized variable, which is always nil, as the conditional:

```
repeat until a

```

Tied with the return until loop, as well as my personal favorite, a recursive function using `load()` at ~~16~~ 14 bytes: (-2 bytes thanks to Jonathan French)

```
f=load"f()"f()

```

An infinite for loop made by Jo King at 18 bytes:

```
for _=1,1,0 do end

```

Finally, the longest of the methods that I know of, a normal recursive function at 22 bytes:

```
function f()f()end f()

```

I'm curious to see if anyone can find some other methods.

# Answer
> 3 votes
# µ6, 1 byte

```
@+

```

Try it online!

### Explanation

The µ-operator takes a function and returns the least \\$n\\$ that results in a \\$0\\$ and since there is no \\$n\\$ such that \\$n+1 = 0\\$ this program won't terminate:

```
@   -- µ-operator applied to
 +  -- | successor function

```

# Answer
> 3 votes
# Shakespeare Programming Language, 61 bytes

```
,.Ajax,.Act I:.Scene I:.[Exeunt][Enter Ajax]Ajax:Let usAct I.

```

Try it online!

It's totally legal to only ever use one character in a play; just don't make him do anything other than loop the program forever, exiting and entering the stage constantly.

# Answer
> 3 votes
# Stack Cats `-m`, ~~5~~ 4 bytes

```
{>}I

```

Try it online!

-1 byte thanks to negative seven

```
        Since there is no input, the stack starts with nothing but -1 on the top.
{       Remember the current value on top of the stack, and loop:
 >      Move the head right on the tape of stacks. (All of them are filled with zeroes.)
  }     Repeat while the top of the stack is not as it was remembered.
   I    Since the loop goes on forever, this is just to make the program legal.

```

# Answer
> 3 votes
# Brainetry, 41 bytes

The 41-byter is a golf of this Brainetry program with 133 bytes:

```
This program is useless.
This program is useless because it runs forever.
This program is useless because it does absolutely nothing.

```

and the golfed version:

```
a b c d
a b c d e f g h
a b c d e f g h i

```

# Answer
> 3 votes
# Flurry `-nnn`, 10 bytes

```
(<>{}{}){}

```

Try it online!

Don't be afraid to click Run; it will stop immediately, complaining the program didn't finish in 10000 steps. Change the step limit and you can see that it is reducing into the same expression over and over. Running in the original Haskell interpreter actually runs an infinite loop.

While Flurry looks like Brain-Flak, it lacks explicit looping support. Instead, because it is functional and primarily designed with combinators, we can implement the Omega combinator `S I I (S I I)`, which endlessly reduces to itself.

The nilad `<>` evaluates to `S` and `{}` pops an item from the stack. When the stack is empty, `I` is popped. The monad `(f g h...)` evaluates `f g h...` as function application, and pushes the result to the stack.

```
(<>{}{}){}  Full program
 <>         S
   {}       I
     {}     I
(      )    Evaluate to (S I I) and push it to stack
        {}  Pop (S I I)
            The entire program evaluates to (S I I)(S I I) = Omega

```

# Answer
> 3 votes
# Haskell, 8 bytes

```
main:x=x

```

One byte shorter than the classic `main=main`.

# Answer
> 3 votes
# Vyxal, 1 byte

```
{

```

Try it Online!

*-3 thanks to answering the right question*

## Explained

```
{      # Start an infinite while loop

```

# Answer
> 3 votes
# C (GNU-EFI), 0 bytes

Yes, a C GNU-EFI program won't exit. You need to return for it to exit. Will not say anything, just hang.
And yes, it works with a standart GNU-EFI Makefile.
I used this one:

```
ARCH            = $(shell uname -m | sed s,i[3456789]86,ia32,)

OBJS            = main.o
TARGET          = main.efi

EFIINC          = /usr/include/efi
EFIINCS         = -I$(EFIINC) -I$(EFIINC)/$(ARCH) -I$(EFIINC)/protocol
LIB             = /usr/lib
EFILIB          = /usr/lib/
EFI_CRT_OBJS    = $(EFILIB)/crt0-efi-$(ARCH).o
EFI_LDS         = $(EFILIB)/elf_$(ARCH)_efi.lds

CFLAGS          = $(EFIINCS) -fno-stack-protector -fpic \
          -fshort-wchar -mno-red-zone -Wall
ifeq ($(ARCH),x86_64)
  CFLAGS += -DEFI_FUNCTION_WRAPPER
endif

LDFLAGS         = -nostdlib -znocombreloc -T $(EFI_LDS) -shared \
          -Bsymbolic -L $(EFILIB) -L $(LIB) $(EFI_CRT_OBJS)

all: $(TARGET)

main.so: $(OBJS)
    ld $(LDFLAGS) $(OBJS) -o $@ -lefi -lgnuefi

%.efi: %.so
    objcopy -j .text -j .sdata -j .data -j .dynamic \
        -j .dynsym  -j .rel -j .rela -j .reloc \
        --target=efi-app-$(ARCH) $^ $@

```

Hope this counts. And yes I tested this on a virtual machine.

# Answer
> 3 votes
# Factor, 10 bytes

```
[ t ] loop

```

Try it online!

Factor is not necessarily verbose :P

Given that we need *a quotation to repeat* and *a looping word*, I believe this is the very shortest we can get in Factor.

# Answer
> 3 votes
# Scratch, 23 bytes

A "forever" block still runs when it's empty.

```
when gf clicked
forever

```

# Answer
> 3 votes
## Arduino, 27 bytes

```
void setup(){}void loop(){}

```

This is also the shortest Arduino code that will actually compile. I'm surprised no-one has done this yet.

# Answer
> 3 votes
# RISC-V machine code, 2 bytes

For CPUs implementing RV32I/E-C or RV64I-C:

```
01 a0 — c.j .

```

For RV32I/E-C CPUs only:

```
01 20 — c.jal .

```

# RISC-V machine code (no extensions), 4 bytes

There are 4 sets of 32\[1\] instructions that work for this

```
6f 00 00 00 - j .
ef 00 00 00 - jal .
6f 01 00 00 - jal x2, .
...
ef 0f 00 00 - jal x31, .

```

The other 96 options are based on the conditional jump instructions `beq`, `bge` and `bgeu` with the same register as operands

\[1\]: 16 on RV32E

# Answer
> 3 votes
# Pure CPython 3.10 Bytecode, 2 bytes

Hex:

```
71 00

```

Disassembly:

```
    >>    0 JUMP_ABSOLUTE            0 (to 0)

```

Attempt This Online!

# Answer
> 2 votes
# Retina, 10 bytes

I'm pretty sure this can be made shorter.

```

0
+T`d`10
```

# Answer
> 2 votes
# GNU sed, 3 bytes

```
:;b

```

Using this meta answer as justification for the relaxation of the no-input rule.

`:` defines a (nameless) label, `;` is a line/command separator, `b` jumps to the label.

Nameless labels seems to be a GNU extension.

# Answer
> 2 votes
# Spin, 13 Bytes

File `x.spin`:

```
pub x
 repeat

```

(without trailing newline)

Compile and download it to your P8x32a microcontroller or run it using `spinsim`.

# Answer
> 2 votes
# R, ~~9~~ 8 bytes

```
repeat 1

```

Saved 1 byte thanks to MickyT!

# Answer
> 2 votes
# Ada, 49 47 bytes

```
procedure L is begin loop null;end loop;end L;

```

I'm guessing there aren't many Ada entries on Code Golf!

Naturally it should look like

```
procedure L is
begin
   loop
      null;
   end loop;
end L;

```

and do exactly what it says on the tin.

# Answer
> 2 votes
# AutoIt3, 12 bytes

```
While 1
WEnd

```

Simply loop indefinitely. Nothing much to say.

# Answer
> 2 votes
# BBC Basic for Windows, 3 or 6

http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

`RUN`

3 ASCII characters. Note in this version of BBC basic line numbers are not required.

If you don't consider termination and self-execution a loop, then the shortest program is

`1GOTO1`

6 ASCII characters.

One might expect these to be shorter in the tokenized version (1 byte per keyword), but it seems they are not, due to the way line numbers / internal ID's are stored.

# Answer
> 2 votes
# Groovy, 8 bytes

```
for(;;);

```

Shortened from the original thanks to suggestions. The trailing semicolon is still required, unfortunately.

```
while(1){}

```

# Answer
> 2 votes
# Math++, 3 bytes

```
1>$

```

Basically a `GOTO 1` statement- on line 1.

# Answer
> 2 votes
# Microscript, 2 bytes

```
1{

```

Essentially just `n=1;while(n!=0){}`. The interpreter autocloses any loops, etc. that are left open.

The Microscript II program `1[` is equivalent.

# Answer
> 2 votes
# OCaml, 17 bytes

```
while 1<2do()done

```

1 byte removed thanks to @Mauris.

Another one bytes the dust thanks to @feersum.

# Answer
> 2 votes
# Self-modifying Brainfuck, 3 bytes

Same effect as in regular BF. Increment the cell and loop forever. `-[]` is the same.

```
+[]

```

Since the source code in placed on the tape, this is also acceptable, and only works in SMBF:

```
<[]

```

If the tape were actually infinite, `[` or `]` would work, since the interpreter would search for the matching bracket forever. Unfortunately (fortunately?), you just get an "index out of bounds" error.

# Answer
> 2 votes
## Snowman 1.0.2, 6 chars

```
~:1;bD

```

`~` sets all the variables to active, `:...;bD` is a "do" loop (i.e. continues looping while the block returns a truthy value), and `1` is `1`.

# Answer
> 2 votes
# Forth, 21 bytes

Unfortunately, you can't make a word that calls itself without using the keyword `recursive`, so I use a standard infinite loop instead.

```
: f begin 0 until ; f

```

**Try it online**

# Answer
> 2 votes
# AutoIt, 10 bytes

```
Do
Until 0

```

Lame.

# Answer
> 2 votes
# ferNANDo, 7 bytes

```
1 1
1
1

```

Line 1 initializes `1` to 1, line 2 marks the beginning of the loop, and line 3 marks the end (a single variable statement loops back to the previous occurrence, if any, for as long as the variable is true).

# Answer
> 2 votes
# Objective-C, ~~17~~16

```
-(id)a{for(;;);}

```

# Answer
> 2 votes
# StackStream, 21 bytes

```
{ dup exec } dup exec

```

Kind-of explanation thingy:

```
{ dup exec } # Push this piece of code onto the data stack.
dup # Duplicate it (stack: { dup exec } { dup exec })
exec # Execute it (stack: { dup exec })

```

# Answer
> 2 votes
# gs2, 2 bytes

CP437: `►3`

Hex dump: `10 33`

Tries to split whatever is on STDIN into chunks of length 0. We never actually split off any chunks, not even from an empty string, so this takes forever.

Note that gs2 doesn't have any traditional looping constructs.

(Mitch Schwartz found this and told me about it, and I thought it was a really cute feature.)

# Answer
> 2 votes
# Whitespace, 9 bytes

```
;
...; create label [space]
;
.;
.    goto label [space]

```

. represents a space and ; represents a newline character.

# Answer
> 2 votes
# RoboTalk, 5 bytes

```
0 rti

```

RoboTalk has three "goto" instructions: `jump`, `return`, and `rti`. `Jump` and `return` are plain "go to the address on the top of the stack" instructions, while `rti` has the side effect of (re-)enabling interrupts, as it's intended to be used to exit interrupt handlers. In a robot without any interrupt handlers defined, however, it is functionally equivalent to the other two instructions while being one byte shorter than `jump`.

# Answer
> 2 votes
# FlogScript, 2 bytes

```
F<

```

The `F<` (`flow-control-restart`) command repeatedly restarts the program.

# Answer
> 2 votes
# 8085 Intel Microprocessor ,4 1 byte

```
0000h: pchl

```

whose machine code is:

```
E9

```

Just reset the microprocessor. And load E9 at 0000h.

p.s: its almost impossible in some kit to load program at ROM memory(which is basically the start memory) So, it works on simulator and some special kits only.

```
C000H: lxi h,C000h
C003H: pchl

```

whose machine code will be

```
21 00 0C E9

```

loaded in memory from C000H

# Answer
> 2 votes
# Factor, 14 bytes

```
: a ( -- ) a ;

```

and nicely symmetrical looking (almost)

# Answer
> 2 votes
# Pyth, 3 bytes

```
W1

```

Note that there is a space after `W1`.

# Answer
> 2 votes
## Burlesque, 5 bytes

```
0bc<-

```

Trying to reverse an infinite list is guaranteed to loop forever and since it loops forever no output will be produced ever.

# Answer
> 2 votes
## Perl 6, ~~7~~ 5 bytes

The standard boring one is just an empty `loop (;;){}` construct.
( spelled `for(;;){}` in other languages )

```
loop {} # 7 bytes

```

There are also exotic ones as well

* infinite sequence of the Any type object ( default value in $\_ )

```
.roll(*) # 8 bytes

```
* unterminated sequence generator (0,1,2,3,4 ... Inf, Inf, Inf, Inf)

```
0...* # 5 bytes

```

# Answer
> 2 votes
# Roadrunner, 14 bytes

```
mEEp mEEP MEEp

```

# Answer
> 2 votes
## Seriously 0.1, 2 bytes

`1W`

`1` pushes a 1 on the stack, `W` executes the code between it and the next `W` (or EOF) while the value on the top of the stack is a truthy value. Since the value on top of the stack stays 1, it NOPs forever.

# Answer
> 2 votes
# BotEngine, 2 bytes

```
><

```

Fairly self-explanatory.

# Answer
> 2 votes
## Marbelous, 7 bytes

```
00
\\//

```

One marble bounces between the two deflectors forever.

Alternate version:

```
00
/\/\

```

# Answer
> 2 votes
# Javascript, 8 bytes

```
while();

```

This almost crashed my computer once :o

# Answer
> 2 votes
# Mouse-2002, 2 bytes

```
()

```

`(` begins a loop; `)` ends it; there's no `^` so it never breaks.

# Answer
> 2 votes
# QBasic, ~~8~~ 7 bytes

```
DO:LOOP

```

Even shorter than the GOTO one!

---

V1.0

```
1:GOTO 1

```

Classical Goto.

# Answer
> 2 votes
# QBIC, 2 bytes

```
{}

```

This compiles into QBasic as `DO: LOOP`.

---

Note that not long after answering this challenge, the workings of QBIC has been altered. We now see IF, DO and FOR as 'language constructs': an opening statement, `<code goes here>` and a closing statement. Note that WHILE/WEND, functions and subs could also be supported as language constructs in the future.

Those currently supported by QBIC (IF, FOR and DO) are opened using `~, [ and {` respectively. Closing them can be done with either a `]` or a `}`: these mean 'Close the last language construct' and 'Close all constructs'.

QBIC has had the ability to auto-close language constructs for some time now. The above code could be one byte only: `{`. The final statement that QBIC adds to its own source is a `}` to close all constructs.

# Answer
> 2 votes
# beeswax, 3 or 4 bytes

**A real loop (4 byte solution)**

```
*PFJ

```

Explanation:

```
* Generate IP, moving to the right.                      [0,0,0]•
P Increment top local stack value.                       [0,0,1]•
F Set all local stack values to top local stack value.   [1,1,1]•
J Jump to [row,column] = [top,2nd] local stack values.   [1,1,1]•
  IP jumps back to to the *

```

**Shorter 3 byte solution**

I am not sure if reflecting IPs back and forth counts as loop, but here it is:

```
j*j

```

Explanation:

```
j Mirror IP in horizontal direction
* Create IP

```

So, this program creates two IPs moving to the right and the left, which are reflected back between both `j`’s indefinitely.

# Answer
> 2 votes
## Spiral, 1 byte

```
0

```

All programs start at the label `0`. All programs halt at the command `!`. Self-explanatory.

# Answer
> 2 votes
# Mouse16, 2 bytes

I hereby release the language I've been teasing!

```
0\

```

Goes to zero... which is the first byte... which executes the `\` goto again... which -- well, you get the idea. This is like `10 GOTO 10` in BASIC.

# Answer
> 2 votes
# Lua, 14 bytes

```
repeat until a

```

or

```
while 1 do end

```

The first one works because a is nil (because it is undefined), so it will never be true. The second one works because anything that is not false or nil, when casted to a boolean, evaluates to true.

# Not boring version, 23 bytes

```
debug.getinfo(1).func()

```

debug.getinfo(1) returns the debug information of the current stack, and the func property represents a function that executes that stack. This will call the main stack an infinite amount of times.

# Answer
> 2 votes
# 2-ill, 7 bytes

```
@ @
@$@

```

The instruction pointer just loops counterclockwise forever.

# Answer
> 2 votes
# Perl, 6 bytes

```
{redo}

```

See redo in perldoc.

# Answer
> 2 votes
# Factor, 15 bytes

Yea, Factor is verbose.

```
[ t ] [ ] while

```

Do nothing forever. Hangs the Listener.

# Answer
> 2 votes
# Subleq bytecode, 3 binary words

```
00 00 00

```

Equivalent to

```
*00 = *00 - *00
if(*00 <= 0) goto 00

```

# Answer
> 2 votes
# The Infamous Shakespeare Programming Language, 122 bytes

```
.
Page,a cat.
Ford,.
Act I:
Scene I:z
[Enter Page and Ford]
Page:
Am I better than zero?
Ford:
If so, let us proceed to z.

```

# Answer
> 2 votes
# V, 1 byte

```
ò

```

is a 2D string based golfing language that I ~~wrote~~ am in the process of writing, inspired by vim. In vim, recursive macros are a little bit of a pain to set up, so I tried to make them as easy as possible in V. The syntax for a recursive macro is:

```
òò

```

This is equivalent to

```
qq@qq@q

```

in vim.

V will automagically fill in the missing delimiter (in this case, the second ò) so we can leave it off, giving us a nice and simple one-byte solution.

# Answer
> 2 votes
# T-SQL, 8 bytes

```
l:goto l

```

(Not to be confused with this excellent answer from @MickyT in Standard SQL)

# Answer
> 2 votes
# S.I.L.O.S, 11 bytes

```
lbla
GOTO a

```

# Answer
> 2 votes
# Turtlèd, 3 bytes

any character but `*` works in the middle

```
[-]

```

alt:

```
{*}

```

Explanation:

```
[    ] Brackets make a while loop. The character after the opening bracket is taken, and
       the loop is executed while the current cell is not that character.

```

hence

```
[-]

```

Runs whilst the current cell is not -, but will never change it to that value, so infinitely runs, and never ouputs as it only outputs at the end.

---

```
{*}

```

works similarly, but it runs while the current cell IS that value. by default, the starting cell is \*, so it runs forever, since it will never change its value

# (nontrivial) Polyglot, Turtlèd and Brainf\*** 5 or 4 bytes, depending on implementation

doesn't make use of BF non instruction nops.

If you happen to have another cool esolang that might be able to be fitted in, tell me.

```
+[-+]

```

In wrapping implementations,

in non-wrapping:

```
+[+]

```

Explanation:

```
+    - essentially a nop in Turtlèd with no string, increments cell in BF
 [+] - loops while current cell is not: {BF:0, Turtlèd:"+"}. increments cell in BF

```

---

```
 [+-] - loops while current cell is not {BF:0, Turtlèd:"+"}. - is nop in Turtlèd with
        no string, and `+-` together is nop (+1,-1) in BF

```

# Answer
> 2 votes
# S.I.L.O.S, 9 bytes

```
:a
GOTO a

```

Try it online!

# Answer
> 2 votes
# , 7 Bytes

```
(-^:_)_

```

A more "readable" form would be `(- ^: _) 1`. The `_` can be any non-zero number and it will work the same (`_` represents infinity in J). `^:` is the "power" conjunction; it iterates a verb a specified number of times. E.g. `(f ^: 3) 0` == `f(f(f(0)))`. When told to iterate `_` times, it keeps applying until it produces a constant output. Since negation never reaches a limit, this is an infinite loop.

# Answer
> 2 votes
# PHP, ~~8~~ 26 bytes

```
set_time_limit(0);for(;;);

```

Almost forgot: default time limit is 30 seconds and script will exit with a Fatal Error if I don´t unset it.

Run with `-r`

# Answer
> 2 votes
# 05AB1E, 2 bytes

```
[[

```

Try it online!

Explanation:

```
[     # Infinite loop start
 [    # Infinite loop start
      # Implicit infinite loop end
      # Implicit infinite loop end

```

You need something inside the infinite loop, or else it will just end

# Answer
> 2 votes
# DUP, 6 bytes

DUP is a dialect of Wouter van Oortmerssen’s FALSE, invented by Ian Osgood.

```
[1][]#

```

Explanation:

This uses DUP’s while loop. the first block `[1]` is the condition block that checks if the condition is true/nonzero, and if it is, executes the second empty block `[]` that does nothing. The execution block is executed as long as the condition is nonzero.

```
 [1][]#
 instr.    data stack   return stack
 [        0                         push '[' location
    [     0,3                       push '[' location
      #   0            5,0,3        push '#' and '[' locations on return stack
 [
  1       1            5,0,3        push 1 (truthy)
   ][]    0            5,0,3,0      condition true → execute 2nd (empty) block
 [                                  jump to condition block (location 0, popped from the return stack)
  1       1            5,0,3
   ][]    0  ...       5,0,3,0             infinite loop

```

Just for the fun of it, here is a visually equally long solution that is 8 utf-8 bytes long, but unique to DUP because FALSE lacks this functionality:

```
[A]⇒AA

```

Explanation:

```
         data     return
         stack    stack    operator
[          0                                 push location of open bracket
   ⇒                                         operator assignment to
    A                      A => 0            new operator A (at address 0)
     A                                       execute operator A, push current IP location on return stack
[                 5                          move to operator A at location 0
 A                5,1                        execute operator A, push current IP location on return stack
[                                            move to operator A at location 0
 A                5,1,1                      execute operator A, push current IP location on return stack
...
[
 A                5,1,1,1,1,1,1,1...

```

As you can see, the latter recursive solution quickly fills the return stack and sooner or later leads to a stack overflow, depending on the available RAM.

A full introduction and explanation of DUP instructions etc. can be found on my GitHub repository or on the pages linked on the online Javascript DUP interpreter webpage.

P.S.: I just noticed that someone already posted a FALSE version. I’m sorry for the duplicate. In this case both languages look the same.

# Answer
> 2 votes
**Scala 12 bytes**

```
while(true)0

```

Avoid one character using 0 instead of `while(true){}`

# Answer
> 2 votes
# Ruby w/J-uby, 5 bytes

```
:~!~0

```

J-uby is all about making procs (i.e., anonymous functions/lambdas) work more concisely in Ruby. It allows symbols to be called like procs without a call to `to_proc`. Additionally, it adds a lot of functionality to procs. The added functionality we are using here is `!~`, or "iterate until constant". Basically, it takes a proc and an initial argument, and applies that proc to the argument until the application stops changing the argument (`f.(x) == x`). So we are calling `~` (bitwise negation) on 0 until they are equal. But due to the nature of bitwise negation (`~x != x`, `~~x == x` for all `x`), this never occurs. Infinite loop.

## 7 bytes:

```
~:^^~:^

```

A more "readable" form would be `(~:^) ^ (~:^)`. In J-uby, `:^` is the call function; `f^x == f[x]`. The `~` operation turns a two-argument function into a one-argument function which applies the given argument to both sides. So `(~:^)^x == x^x`. Finally, we apply this to both sides by turning these into lambdas and we get: `->(x){ x ^ x } ^ ->(x){ x ^ x }`. This is analogous to `(x => x(x))(x => x(x))` in JavaScript, `(\x->x x)(\x->x x)` in Haskell, or `(λx.xx)(λx.xx)` in Lambda Calculus.

# Answer
> 2 votes
## Alice, 0 bytes

Try it online!

The empty program in Alice does nothing... in particular it doesn't terminate.

# Answer
> 2 votes
# AWK, 15 bytes

```
BEGIN{for(;;)1}

```

The smallest code that doesn't look for input.

I tried without the `1` and `AWK` wasn't happy.

Try it online!

# Answer
> 2 votes
# Braingolf, 4 bytes

```
[1+]

```

Try it online!

# Braingolf v2, 3 bytes

```
1[]

```

Try it online!

# Answer
> 2 votes
# Triangular, 3 bytes

```
\/<

```

Triangular is my first attempt at a two-dimensional esoteric language. Code is formatted into the smallest possible triangle - in this case, a triangle of size two. The IP starts moving Southeast from the top of the triangle.

The above code arranges into this triangle:

```
 \
/ <

```

Commands:

* `\` direct IP Southeast (towards the `<`)
* `<` direct IP West (towards the `/`)
* `/` direct IP Northeast (towards the `\`)

# Answer
> 2 votes
# Thotpatrol, 78 bytes

```
JACKING IN
  a.txt
REPORT UNPATRIOTIC ACTIVITY

```

A simple self recursive program that points the interpreter to call itself recursively. The assumption is that the program is in a file called "a.txt" The call is embedded in a try statement to suppress stack overflow warning. The structure is as follows:

```
function a:
    try a

```

Link to implementation: https://github.com/MindyGalveston/thotpatrol-

# Answer
> 2 votes
# Piet, 2 codels

Can be interpreted and executed using, for example, PietDev, by either

* setting the canvas' width to 2, height to 1 and coloring the codels yourself or
* clicking on "Open", setting the codel width to 25 and uploading the above image.

Click the step button repeatedly to see the program rotate and loop ~~or the run button to freeze the page~~.

Edit: Try It Online

**Edit 2: Just saw that someone already beat me to it.**

# Answer
> 2 votes
# Commodore BASIC V2 (Commodore 64/VIC-20), 6 tokenized BASIC bytes

```
 0 GOTO

```

or to save some typing (not actual bytes):

```
 0G[shift]O

```

which uses the keyword abbreviation for `GOTO` (may also be typed as `GO TO`)

In Commodore BASIC V2, GOTO assumes GOTO 0. Byte count is determined from `PRINT FRE(0)` on VIC-20, default value is `3581`.

# Answer
> 2 votes
# beeswax, 3 bytes

```
O_O

```

or alternatively

```
j_j

```

or

```
>_<

```

All three create two bees that get reflected back and forth indefinitely.

# Answer
> 2 votes
# Z80 Machine Code, 1 Byte

```
0x76

```

## Halt

When a software HALT instruction is executed, the CPU executes NOPs until an interrupt is received (either a nonmaskable or a maskable interrupt while the interrupt flip-flop is enabled)..

# Answer
> 2 votes
# Pepe, 6 bytes

```
REEReE

```

Try it online!

Begin loop, end loop. No need to explain it much.

Also, for fun: `REE ReE reeE` makes the permalink #FBI.

# Answer
> 2 votes
# Keg, 1 byte

```
{

```

Auto completes the while loop and runs it infinitely

# Answer
> 2 votes
# Pyramid Scheme, 41 bytes

```
   ^
  / \
 /do \
^-----^
-^    -
/1\
---

```

Try it online!

Almost a straight translation of @JoshuaTaylor's Lisp ten-byter.

# Answer
> 2 votes
# PHP, 12 bytes

Different answers are posted for PHP which use loops or labels, but here is one which doesn't use any of them. Save the file with a single character name and then include itself. For example if you save the file as `1`:

```
<?include 1;

```

Run with: `php -n 1`, this will go on until PHP goes out of memory or max execution time reaches.

# Answer
> 2 votes
# Plumber, 7 bytes

```
[]
[[]]

```

This is the shortest possible infinite loop in Plumber.

Plumber programs are divided into units, which are always two characters wide (and padded to two with spaces if shorter). This one consists of three units: `[]`, `[[`, and `]]`. When a Plumber program is run, a `0` packet is dropped from all `[]` on the top row. This packet can be picked up by a `][`, which pushes it to the sides.

A `[[` will push it to the right, but it continues down (and is destroyed upon leaving the 2d space). Likewise, when the `]]` is pushed into from either side (left in thus case), the packet is dropped and destroyed, and pushed back to the left. The `[[` pushes it back to the `]]`, and this continues indefinitely.

# Answer
> 2 votes
# I like frog, 13 bytes

```
frog like i

```

`frog like` says that it is going to based off the parameters, go back 1 instruction (which is this instruction, creating a loop) `i` is the parameter saying how many instructions to go back.

# Answer
> 2 votes
# Marbelous, 8 bytes

```
@0
00
@0

```

Marbelous is a language based on marble machines

* `@n` (`n` from `0` to `Z`) is a portal which teleport the marble to another portal with the same value
* `00`-`FF` initiate a marble with this value

interpretor

# Answer
> 2 votes
# Forth (gforth), 15 bytes

```
[begin] [again]

```

Try it online!

Shortened nonForgivingJesus's answer using square brackets for looping directly.

My first Forth answer!

# Answer
> 2 votes
# C#9, 8 bytes

```
for(;;);

```

In C#9, they introduced Top-Level Statements which means one source file no longer needs any boilerplate.

# Answer
> 2 votes
# Python 3, 14 bytes

```
{*iter(int,1)}

```

Try it online!

# Answer
> 2 votes
**C(gcc, platform-independent), 17 bytes** Highschooler here, finally something I can do.

```
main(){for(;;){}}

```

I read somewhere that this is the least bytes for an infinite loop, although I'm not sure.

# Answer
> 2 votes
# Jellyfish, 5 bytes

```
\>1
1

```

Try it online!

jellyfish doesn't have implicit output, so nothing is printed here.

## Explanation

given with positions.

```
(0,0) \ iterate the following function:
(1,0)  >  increment
(0,1) 1 on one
(2,0) till 1 is reached.

```

# Answer
> 2 votes
## x86 machine code - 2 bytes

```
 6                                  .loop:
 7 00000000 EBFE                        jmp     .loop

```

This is a same code as :

```
 6 00000000 EBFE                        jmp     $

```

## x86\_16 machine code - 2 bytes

```
 12 0005  EB FE              JMP     $

```

Tested on DOSBox

# Answer
> 2 votes
# Locksmith, 4 bytes

```
0156

```

0 pushes the next digit (1) to the stack, 5 acts as a label, and 6 jumps to the most recent 5 if the top of the stack is non-zero

# Answer
> 2 votes
# Knight, 3 bytes

```
W1N

```

Try it online!

```
# pretty straightforward
WHILE 1
    # The official name for this builtin is NULL.
    # Because builtins are determined by the
    # first character, I can call it NOP.
    NOP

```

# Answer
> 2 votes
## h, 20 bytes

```
8,2,9,4,9,6,8,2,-1,0

```

Neither the language (by Nerdaxe) nor this answer (by VilgotanL) are my creations, but I want to publicize them here.

h (link) is a programming language created by Nerdaxe which is quite limited.

Here's an explanation of how the program works through pseudocode similar to subleq assembler:

```
neg1 2 #acc is now -1
zero 4 #acc is now 1, the variable zero is 1
zero 6 #acc is now 0, the variable zero is 0
neg1 2 #acc is now -1, go back to 2
neg1:-1 zero:0 #variables

```

# Answer
> 2 votes
# Daoyu, 1 byte

```
><

```

Each instruction is one hex, so two instructions fit into one byte (0x69). The `<` increases the operating level (a number that affects certain commands) and moves the program reader to the beginning of the program, but only if the op level is less than 9. So, it's preceded by the `>` command, which decrements the op level (to a minimum of zero).

# Answer
> 2 votes
# Minim, 4 Bytes

```
C--.

```

Decrements the program counter, which is incremented back to 0 after the statement finishes.

GitHub Repository

# Answer
> 2 votes
# Vyxal, 1 byte

```
{

```

Try it Online!

# Answer
> 2 votes
# KonamiCode, 12 bytes

`v(^)L(>)B(>)`

`S(^)L(>)B(>)` does the same thing but isn't shorter.

# Answer
> 2 votes
# Lost, 1 byte

```
?

```

Try it online!

# Answer
> 2 votes
# Rust, 6 bytes

```
loop{}

```

Try it online!

That's one very fast loop

# Answer
> 2 votes
# BitCycle, 3 bytes

```
1><

```

Try it online!

## Explanation (because i can)

```
1    Creates a 1 bit, heading east by default
 >   Sets the direction to east
  <  Sets the direction to west
 >   Sets the direction to east again, creating a loop

```

# Answer
> 2 votes
# Knight, 3 bytes

```
W1N

```

Epic W1N.

# Answer
> 2 votes
# \[min\]mod, 2 bytes

```
IS

```

Treats the instruction stack as an instruction and calls it recursively.

Try it!

Try it step by step!

# Answer
> 2 votes
# Grass, 3 bytes

```
wWw

```

Try it online!

Essentially just a main function that calls itself recursively.

# Answer
> 2 votes
# Tsept v1.0, 5 bytes

Tsept is an esolang I created; it's not good at golfing since even basic tasks like storing numbers and printing strings require a lot of instructions.

This program is 5 bytes long because it has to calculate and repeatedly push the jump offset.

```
xDDPJ

```

Note: Due to a bug in the interpreter, the 'J' instruction jumps to the wrong offset (specifically the original offset plus one).

'x' clears the value in the accumulator since, at the start, it contains the interpreter's version.

'D' decrements the interpreter, and due to the aforementioned bug, it has to do it twice.

'P' pushes the accumulator onto the stack.

'J' pops a value from the stack and adds it to the instruction pointer, effectively performing a relative jump.

# Answer
> 1 votes
# CoffeeScript, 6 bytes

```
loop 0

```

Interesting fact thanks to Martin Büttner, not sure if there's any practical use to it though.

Previous attempt (8 bytes):

```
1while!0

```

There is only a `while` loop, no `for` (though there are `for..in` and `for..of`).

# Answer
> 1 votes
# Swift, 12 bytes

```
while(1>0){}

```

# Answer
> 1 votes
## Rust, 17 chars

```
fn main(){loop{}}

```

Nothing much interesting to see here.

# Answer
> 1 votes
# FlogScript, 6 bytes

This creates a string containing code for duplicating the top value on the stack, then popping it and executing it as code. Then it is duplicated, popped, and executed as code.

```
{.~}.~

```

# Answer
> 1 votes
# HALT, 7 bytes

```
1 SET 1

```

This set's the pointer to 1, this is run forever because there is no `HALT;` command. This will bybass fail-safes to prevent infinite looping.

Try This

# Answer
> 1 votes
# Lua, 11 bytes

In Lua, you can set labels that can be used with the `goto` statement!

```
::y::goto y

```

# Answer
> 1 votes
# Basilisk, 5 bytes

```
:A1gA

```

Pretty simple.

# Explanation

* `:A`

Defines position A.

* `1gA`

Pushes one and goes to position A in code. Since the `gA` pops the top value in stack, if the loop were ever to end, it would not print anything.

# Answer
> 1 votes
## STATA, 10 bytes

```
while 1{
}

```

Apparently for loops in STATA always halt, but while loops can be infinite.

# Answer
> 1 votes
# VBScript, 17 bytes

```
do
loop while 1

```

# Answer
> 1 votes
# Batch, 3 bytes

```
@%0

```

# Answer
> 1 votes
# C++, 15 bytes

Same as C:

```
main(){main();}

```

# Answer
> 1 votes
# F#, 14 bytes

```
while 0<1 do()

```

Self-explanatory.

# Answer
> 1 votes
## AHK, 4 bytes

```
loop

```

quick and simple

# Answer
> 1 votes
# Pip, 3 bytes

```
W1x

```

Basically a `while 1: 0` answer.

---

A more interesting 2-byte solution that doesn't quite fit the rules:

```
Vf

```

`f` is the current function; `V` evaluates it. This theoretically goes on forever, but in actuality it ends up causing infinite recursion in the interpreter, which very quickly exits with

```
Fatal error: maximum recursion depth exceeded while calling a Python object

```

Oh well.

# Answer
> 1 votes
# Fourier, 3 bytes

```
1()

```

Repeats until the result of the loop equals 1, which it never does.

# Answer
> 1 votes
# Aheui, 0 bytes

Aheui is a Befunge-like, and the empty program is an infinite loop for exactly the same reason.

# Answer
> 1 votes
# C, 16 bytes

```
main(){for(;;);}

```

A simple C loop construct. A `for` loop does not require curly brackets.

# Answer
> 1 votes
# CFL 2 (ComeFrom 2), 17 bytes

```
10 comefrom 20
20

```

Try it here.

# Answer
> 1 votes
# Carriage, 30 bytes

```
111-@11-~!$11111++++11-~@11-~!

```

# Answer
> 1 votes
# SmallTalk – 18 bytes

```
[true]whileTrue:[]

```

# Answer
> 1 votes
# Ceylon, ~~30~~ 29 bytes

This is an eternal loop (which also will not run out of memory or stack or something), 30 bytes:

```
shared void l(){while(true){}}

```

This can be golfed down one more byte to 29:

```
shared void l(){while(1<2){}}

```

In the Ceylon web runner you have to remove the function wrapper, getting this 12 byte snipped:

```
while(1<2){}

```

(I had to kill my Chromium window when trying this.)

This eternal recursion will quickly run out of stack space (about 1024 calls on my JVM implementation, with a StackOverflowError), 22 bytes:

```
shared void r() {r();}

```

I wouldn't consider this a valid solution.

Note that the for-loop (which is the shortest endless loop in Java) in Ceylon can only loop over an iterable, and all ways of constructing an infinite iterable are longer. Here is one example (38 bytes):

```
shared void f(){for(x in{1}.cycled){}}

```

# Answer
> 1 votes
# Poslin, 20 bytes

```
[ .true ! | ]while !

```

This does the part between `|` and `]` as long as the part between `[` and `|` returns the true value.

`.true !` creates the true value at compile time.

```
[ .true & | ]while !

```

works just the same, but here the operation `.true` is called on every iteration.

# Answer
> 1 votes
# Prelude, 3 bytes

```
1()

```

Any other non-zero digit could replace the `1`. This is essentially the same as the Brainfuck solution (just adding it for completeness).

# Answer
> 1 votes
# PHP, 10 8 bytes

The `for(;;)` solution has been posted enough, Time for this one:

```
while(1)

```

`while(1){}`

# Answer
> 1 votes
# D , 21 bytes

```
void main(){for(;;);}

```

No language used with D in it name.

# Answer
> 1 votes
# GOTO++, 19 bytes

```
§1 GOTOPASMALIN %1

```

`§1` is the label 1

`GOTOPASMALIN` is a deterministic `goto` instruction that goes to the label `X` specified with the argument `%X`.

`goto pas malin` literally means `Not-clever goto` in French. It is named this way because there are keywords in GOTO++ to do `goto` at random, on a random label in a list, etc.

# Answer
> 1 votes
# Octave, 10 bytes

1 byte shorter than @flawr's answer ...

```
do until 0

```

(Haven't tested it in Matlab though...)

# Answer
> 1 votes
# HP48's RPL, 18 bytes

`« DO UNTIL 0 END »`

You may remove the spaces around the « and » but the calculator will add them again for you.

That's the source size; "binary" size when stored in the calculator is actually longer (25.5 bytes).

# Answer
> 1 votes
# Sclipting, 6 bytes

Encoded in UTF-16.

```
到終

```

This is a while-false loop with an empty body. This assumes that the program input is falsy, but I interpret the problem statement as saying that the input will be empty, so this is fine.

# Answer
> 1 votes
# Emily, 12 bytes

```
while^(1)^()

```

I was a character short of 30 for the body of this post. :/

# Answer
> 1 votes
# Delphi, 35 bytes

```
program P;begin while true do;end.

```

Managed to beat C# this time :)

# Answer
> 1 votes
# Coffee Script, ~~9~~ 8 bytes

```
1while 1

```

# Answer
> 1 votes
# Gema, ~~18~~ 15 characters

```
\A=@a{a};a:\P?=

```

Sample run:

```
bash-4.3$ gema '\A=@a{a};a:\P?='

```

# Answer
> 1 votes
# ShadyAsFuck, 2 bytes

```
a]

```

This starts a for loop that never increases or decreases. This can also be represented by

```
+(

```

As this is a substitution language for Brainfuck (and there is a more popular answer in that language for this already), please do not consider this for the winning code.

# Answer
> 1 votes
# AppleScript, 10 Bytes

In Script Editor... it's 10 bytes, which is way better than I expected nonetheless.

```
repeat
end

```

Thanks to @Mark for pointing out that the 0 byte "loop" was no loop at all.

# Answer
> 1 votes
# MIPS, 6 bytes

I didn't use mips for ages, but if i remember correctly, it will be something like that : `a: j a`;

# Answer
> 1 votes
# Cardinal, 2 bytes

```
%$

```

or

```
$%

```

In Cardinal each pointer carries exactly 2 unsigned 8 bit values, one active, one inactive. Both are initialized to **0**

`%` creates 4 pointers moving in the cardinal directions.

`$` moves the pointer to x,y = active,inactive value of the pointer

# Answer
> 1 votes
# Staq, 2 bytes

```
()

```

`(` jump to corresponding `)` if the top stack value is greater than 0

`)` jump back to corresponding `(` if the top stack value is 0 (or if it does not exist)

# Answer
> 1 votes
# PARI/GP, 9 bytes

```
while(1,)

```

Or equivalently:

```
until(0,)

```

# Answer
> 1 votes
# Python 3, ~~100~~ 79 bytes

```
x=lambda x:x(x)
while x:
    try:x(x)
    except BaseException:pass

```

*Note: this doesn't freeze my IDLE or my machine, nor does it hog lots of memory: it just occupies (more than) a core on an eight-core processor.<br>Also note: pressing CTRL-C (or whatever you have KbInt bound to) a few times will eventually cause it to error and quit. I could write in protection for that but it's pointless in this case.*

# Answer
> 1 votes
# GOLF, 10 bytes

didn't see a golf response

```
lx:
jmp lx

```

`lx:` sets a goto marker, `jmp` sends you to the marker. Note that the marker name cannot be a single character (as far as I know) because the alphabet characters are reserved for registers.

# Answer
> 1 votes
# Hassium, 17 Bytes

Calls the main() infinitely.

`func main()main()`

Run online and see here

# Answer
> 1 votes
# JacobFck

`:A_A`

Expanded and commented here

# Answer
> 1 votes
# , 2 chars / 4 bytes

```
↻;

```

I won't add a `Try it here` because you probably don't want to try it.

# Answer
> 1 votes
# ಠ\_ಠ, 31 bytes

```
ಠ4ಠ
ಠ4ಠ
ಠ1ಠ
ಠ?ಠ

```

## Explanation

```
ಠ4ಠ # Push 4 to the stack [4]
ಠ4ಠ # Push 4 to the stack [4,4]
ಠ1ಠ # Push 1 to the stack [4,4,1]
ಠ?ಠ # Essentially: go to line 4

```

# Answer
> 1 votes
# Pyth, as of 11/3/15: 1 byte

```
#

```

There is no trailing space in this version. The requirement that statements have a value has been removed.

# Answer
> 1 votes
# Haystack, 2 bytes

```
v|

```

Haystack is a 2D-based grid language which starts executing in the upper left-hand corner. The characters `<>v^` tells the "pointer" in which direction to go. It continues in the same direction until it hits another direction identifier or the needle `|`.

# Answer
> 1 votes
# DStack, 3 bytes

```
skt

```

Language created by my few days ago

# Answer
> 1 votes
# Minecraft snap. Ver. 15w46a, 2 + 0 = 2 bytes

Note that this version of this "language" was created after the question was asked.

This is using this version of byte counting.

Put inside of an always active repeating command block, it will, indeed, loop forever with no output.

# Answer
> 1 votes
# ShapeScript, 8 bytes

```
'0?!'0?!

```

This requires the latest version of ShapeScript, since I have just implemented tail call optimization.

The online interpreter will exit quietly after one minute. Try it online!

### How it works

```
'       Push a string that, when evaluated, does the following:
  0?      Push a copy of the topmost item on the stack (i.e., this string).
  !       Evaluate the copy.
'
0?      Push a copy of the topmost item on the stack.
!       Evaluate the copy.

```

# Answer
> 1 votes
# Thue, 11 bytes

```
0::=0
::=
0

```

(Silly 30 character minimum)

# Answer
> 1 votes
# BASIC, 8 bytes

```
2 GOTO 1

```

A simple answer, but hey, it uses basic!

Also, for fun:

# Brainf\*ck, 3 bytes

```
+[]

```

# Answer
> 1 votes
# Go, 32 bytes

surprisingly long. surprisingly, *never* ends.

```
package main;func main(){for{}}

```

Fun fact: compiling this, due to the go tail-call and `03`\- optimising compiler, this generates an executable with absent `.TEXT` and `.DATA` sections.

# Answer
> 1 votes
# Arcyóu, 6 bytes

```
(@ 1 1

```

While 1: append 1. Note that this will blow the stack eventually, since it's slowly building a list of `1`s in memory.

# Answer
> 1 votes
# Emacs Lisp, 9 bytes

```
(while t)

```

Pretty straight-forward.

# Answer
> 1 votes
# Samau, 3 bytes

```
`xx

```

### Explanation

```
`x      push the quoted function [x]
  x     execute it without popping it

```

It works like the Mathematica program `#0[]&[]`, but Samau doesn't have an iteration limit.

# Answer
> 1 votes
## ResPlicate, 5 bytes

```
1 4 2

```

After 1 step, this expands to `2 2 2 2`, which is the smallest period 1 oscillator. That this is true was once the subject of a lengthy proof, which was thenceforth unceremoniously deleted when I pointed out that the fact was kind of a little bit obvious. I'm sure you can re-derive said proof yourself.

# Answer
> 1 votes
# STXTRM, 2 bytes

```
;;

```

Program execution in this language is... strange.

# Answer
> 1 votes
# Dirst, 4 bytes

```
lpn_0

```

Loops as long as 0 is equal to 0.

# Answer
> 1 votes
# GOTO, 9 bytes

```
M1:GOTOM1

```

Simply defines a label that goes to itself. GOTO seems to be Turing complete (by translation from a Minsky machine), so it should count as a programming language.

# Answer
> 1 votes
# Sally, 20 bytes

```
void a a
void main a

```

Why the extra four bytes? First, I pipe it to `sally2c`, which transpiles it to C:

```
#include "sally.h"

/* {void -> void}: */ void apply_a(void)
{
  apply_a();
}

/* {void -> void}: */ int main(int argc, char ** argv)
{
  if(argc <= 0) { fprintf(stderr, "0 values needed"); exit(1); }
  apply_a();
  {
  }
  argv = argv;
  return 0;
}

```

Then, during compilation, I use the `-O2` flag for tail-recursion (otherwise it segfaults), which I believe is necessary for consideration as a language.

# Answer
> 1 votes
## RPG fixed, 133 bytes

```
H dftactgrp(*no) actgrp(*new)
H option(*srcstmt:*nodebugio)
H bnddir('QC2LE')
C     A             TAG
C                   GOTO      A

```

Basically it defines a few headers for it to compile (`h`-spec) and have to rows of `c`-specs. If it was written in free format it would have looked like this:

```
H dftactgrp(*no) actgrp(*new)
H option(*srcstmt:*nodebugio)
H bnddir('QC2LE')
/free
tag a;
goto a;
/end-free

```

Or in Perl like this:

```
a:;     # This is a label
goto a; # Goto that label

```

# Answer
> 1 votes
# Condit, 2 bytes

```
a

```

Note the trailing space. Due to what I believe is a bug, the Python 3 interpreter loops infinitely on unrecognized tokens.

# Answer
> 1 votes
# BSM, 1 byte

```

```

A single space character. Had to use some brute-forcing for this... After about 125 cycles, it loops between the states `55`, `EF`, `B1`, `5A`, `AD`, `B2`, `D9`, `DC`, `9C`, `13`, `19`, and `F9`.

# Answer
> 1 votes
# Puzzlang, 4 bytes

```
XX X

```

I have verified that this is, in fact, the shortest possible solution. Equivalent to `+[]` in BF.

# Answer
> 1 votes
# Carriage, 7 bytes

```
#11-\@!

```

Smallest self-copying program that I could find.

# Answer
> 1 votes
# DUP, 2 bytes

```
~!

```

`Try it here.`

Found this completely by accident.

# Explanation

If the stack is empty, `~` (normally bitwise NOT) just pushes `-1` to the stack. `!`, which is normally lambda execute, pushes `1!` to the return stack, which then tells the IP to go back to `~`, and the loop goes on.

# Answer
> 1 votes
# Pancake Stack, 71 bytes

```
Put this # pancake on top!
[a]
If the pancake is tasty, go over to "a".

```

Yay, self-GOTOs with #pancakes...

# Answer
> 1 votes
## Hoon, 4 bytes

```
|-
$

```

The `|-` rune is a synthetic rune that expands to `=<($ |.($))`, a macro that expands to a self-calling function. That function returns `$`, the name of a limb. Gates like `|.` are essentially "objects" in Hoon, called cores, with a list of limbs. `$` is the empty name of the limb containing the code to run to call the gate. The code creates a core with one limb, `$`, that returns the value at the limb `$` (itself) and calls it immediately.

# Answer
> 1 votes
# Grond, 7 bytes

```
w(1){}

```

Compiler here https://github.com/epicTCK/Grond

# Answer
> 1 votes
# Gogh, 1 byte

Another Gogh answer!

```
Ø

```

The character `Ø` infinitely loops all code before it. (from the wiki)

# Answer
> 1 votes
# MNNBFSL, 4 bytes

```
[[<]

```

A bit complicated. Read the Esolangs page for more information.

# Answer
> 1 votes
# Bash, 10 bytes

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

# Answer
> 1 votes
# Pylongolf2, 2 bytes

```
><

```

That's it.

# Answer
> 1 votes
# Jumper, 2 bytes

```
:0

```

Move along, nothing to see here but a simple self-GOTO...

# Answer
> 1 votes
# Sh, 17 bytes

```
while :;do :;done

```

Probably the shortest one.
Ungolfed:

```
while [ : ]; do
:
done

```

`:` is a command that always returns `0` (a.k.a. the same as `true`).

---

# Sh+coreutils, 13 bytes

```
yes>/dev/null

```

`yes` is a program from the `coreutils` package, that, when not given an argument, continuously outputs `y`  (note the newline), while given an argument, outputs that argument plus a newline continuously. `--help` and `--version` display usage and version number, respectively.

# Answer
> 1 votes
# Parallax Assembly, 0 bytes

The effect if set up correctly leaves the processor core initialized to zeros, which happens to be a nop. Running off the end executes the processor special registers, which also happen to be initialzed to zero except for ina, but the high bits are zero (for some reason this particular CPU floats low rather than high) so it's still a nop, and loops back to the beginning by overflowing the IP register.

Incidentally a blank CPU is already set up correctly so it's just a matter of loading the null program without disturbing the state.

# Answer
> 1 votes
# Codan, 4 bytes

```
«»

```

All loops in Codan are infinite if they don't have breaks. This program is transpiled to C as follows:

```
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <termios.h>
int main(void)
{
    int mem[10000];
    int alpha, beta, t;
for (;;) {
}

    return 0;
}

```

# Answer
> 1 votes
# PRINDEAL, 10 bytes

```
a t
 t
 t
 t
t

```

Creates a command named `t` that calls itself, then calls itself regardless of whether the first call suceeded. An interpreter was posted which does not use recursion, and thus will keep running forever (or until it runs out of memory)

# Answer
> 1 votes
# Revaver2pi, 5 bytes

```
TEL 0

```

`TEL` searches (cyclically) for the next `TEL` with the same first argument and jumps to there.

# Answer
> 1 votes
# XRF, 5 bytes

```
FFFFF

```

Only contains one chunk, which is a NOP. The instruction pointer is the top of the stack, so it never changes and just repeats the code infinitely.

# Answer
> 1 votes
## Sonic Pi

```
loop do end

```

I think that's easy to understand.

# Answer
> 1 votes
# ACIDIC, 1 byte

```

```

A single newline character. In the C# interpreter, the empty program (i.e., the second line) just loops forever.

# Answer
> 1 votes
# Enigma-2D, 2 bytes

```
RL

```

The IP alternates between moving rightwards and leftwards.

# Answer
> 1 votes
MarioLANG(4 Bytes)

```
><
==

```

# Answer
> 1 votes
# Nim, 16 bytes

```
while on:discard

```

`on` is an alias for `true`. Nim disallows expressions that aren't explicitly `discard`ed, so we just discard nothing.

# Answer
> 1 votes
# Logicode, 24 bytes

```
circ r(a)->r(a)
out r(1)

```

Logicode is a new language that I made recently. It only consists of the basic logic gates `AND`, `OR` and `NOT`.

It also contains some nifty stuff like conditionals, make-your-own circuits, and output.

Basically, the first line declares a new circuit, `r`, with an argument `a`, and declares the output of the circuit to be `r(a)`. This basically results in an infinite loop.

`out r(1)` outputs `r(1)`.

# Answer
> 1 votes
## Ru, 4 bytes

```
¿Ϟ{}

```

`¿` call a function while koppa is not 0/nil/false. But since `Ϟ` also return its argument, it's possible to chain `¿` and `Ϟ`.

# Answer
> 1 votes
# Emotinomicon, (2 chars) 6 bytes

```
ℹ⏩

```

I cleverly chose the  character for 3 bytes instead of 4. Explanation:

```
ℹ⏩ explanation
ℹ  push the imaginary unit to the stack
 ⏩ close loop

```

It works, because 1)  has got a value (`i`) 2)  can't find a .

To test the code, do the following:

1. Open the interpreter.
2. Clean the box and then put a  in it (not part of the code, just in case you have a dirty output stream).
3. Paste the code after that one-big-toothed strange guy.
4. Click on "generate explanation". Watch the steps done there (also, no mono-spacing issues).
5. Click on "submit". **Warning: the code will run after this step!**

# Answer
> 1 votes
## Racket 18 bytes

```
(λ()(let g()(g)))

```

# Answer
> 1 votes
## D2, 3 bytes

```
+[]

```

Same as Brainfuck

More interesting version using the preprocessor (the code is actually never executed because the infinite loop is in the preprocessor):

```
(@a)a@a

```

Simple recursive macro

# Answer
> 1 votes
## Lithp, 40 bytes

```
((platform ext)(invoke (stdin) resume))

```

There are presently no loop constructs in my language. Instead, we tell NodeJS (in which Lithp is implemented) to resume the `process.stdin` stream. We haven't setup a handler, but the process will never exit.

In fact, you have to send a kill message to abort the application.

# Answer
> 1 votes
# PHP, 9 bytes

back to basic:

```
L:goto L;

```

^\_^

# Answer
> 1 votes
## Clojure, ~~21~~ 10 bytes

```
(#(recur))

```

After posting a question of meta regarding what's considered a full program in Clojure, it seems that the above is acceptable. If you paste it in an empty source file, it will run.

# Answer
> 1 votes
# TI-83 Hex Assembly, 3 bytes

```
PROGRAM:L
:AsmPrgm
:C3959D

```

Run it with `Asm(prgmL)`. Jumps to itself over and over. The only way to stop the program is to physically remove the batteries from the calculator. I count each pair of hex digits as one byte.

# Answer
> 1 votes
# Pushy, ~~2~~ 1 byte~~s~~

```
[

```

Try it online!

Hah, `[` is just an infinite loop, that's its only function if you see here.

# Answer
> 1 votes
# FALSE, 6 bytes

```
[1][]#

```

This is a while loop (`#`) with an empty body function (`[]`) and a condition function that always yields a truthy value. It runs forever without yielding output.

Interpreter used.

# Answer
> 1 votes
## Lithp, 27 bytes

```
 ((def x #::((next x)))(x))

```

Define a function, `x`, which uses tail recursion (via `next`) to call itself. Then call function `x`.

This program will never finish. You can't even CTRL+C out of it since keyboard input isn't handled in Node.js whilst in a `while` loop.

If one were to provide the `-d` flag to `run.js`, they would see the function calling itself over and over, never finishing nor running out of stack space.

This was a neat feature to get working in my language. Typically one would use some sort of logic flow to determine whether to return a value or tail recurse back into the current function (using `next` or `recurse`.)

The implementation of such tail recursion was fairly simple, but its implications in my functional language are great. My feature set is getting nearer and nearer to Erlang's every week. And that's fun.

# Answer
> 1 votes
# uBASIC, 7 bytes

```
1GOTO1

```

Note trailing newline. Trivial BASIC variant.

Try it online!

# Answer
> 1 votes
# Excel VBA, 7 Bytes

```
Do:Loop

```

*Note: the above freezes Excel - the shortest Excel VBA loop that does not do this is `Do:DoEvents:Loop` (16 Bytes)*

# Answer
> 1 votes
# GNU Sed, 3 bytes

Unlike this answer by @Digital Trauma (which relies on bug #21250: sed: empty label for :/b/t commands), does only use documented Sed commands, in the same byte count.

*Golfed*

```
G
D

```

*Explained*

```
G       #Append a newline to the contents of the pattern
        #space, and then append the contents of the hold
        #space to that of the pattern space.

D       #Delete text in the pattern space up to the
        #first newline, and restart cycle with the
        #resultant pattern space, without reading a new
        #line of input.

```

# Answer
> 1 votes
# tcl, 7 bytes

```
vwait v

```

Explanation

# Answer
> 1 votes
# BitCycle, 3 bytes

```
>1<

```

Places a `1` bit on the playfield and infinitely moves it back and forth between the `> <` devices.

# Answer
> 1 votes
# Forte, 4 bytes

```
1REM

```

Without an `END` statement, Forte programs loop infinitely. The empty program is an error, so we leave a comment.

Try it online!

# Answer
> 1 votes
# OIL, 1 byte

```
6

```

TIO does not currently support OIL.

Explanation:

```
6 // Jump to cell A.
0 // Implicit 0.

```

# Answer
> 1 votes
# Lua and RBX.Lua, 14 bytes

```
while 1 do end

```

Pretty self explanatory. While 1 is true, it will iterate through the loop.

# Answer
> 1 votes
# ezfuck, 2 bytes

```
+{

```

Basically equivalent to `+[]` in BrainFuck.

`+` increments the current cell to 1, then `{` jumps back a single command while the current cell is non-zero.

# Answer
> 1 votes
# Decimal, 6 bytes

```
91D91D

```

Pretty simple:

```
91D   ; declare jump 1
91D   ; goto jump 1

```

Try it online! I mean, not exactly *try* it, but... you know what I mean.

# Answer
> 1 votes
# Fission 2, 1 byte

```
R

```

Try it online!

Spawns an atom moving right, wraps on the end of the line, `R` simply sets the atom's direction to right after the program has started

# Answer
> 1 votes
# Aceto, 1 byte

```
O

```

`O` jumps to the origin of the script. Alternative solutions: Any of `v^<>NSEW;§j@`

# Answer
> 1 votes
# XSLT, 173 bytes

```
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"><xsl:template name="a" match="/"><xsl:call-template name="a"/></xsl:template></xsl:stylesheet>

```

Requires a trivial XML file as input (`<root />` will suffice), since XSLT won't actually do anything unless given input. You can test it here. It's possible to remove some of the spaces or the `xmlns:xsl` attribute and still have it parse, but most XSLT lint programs will reject the shorter versions, so this is the shortest "correct" XSLT script I could come up with that loops forever.

# Answer
> 1 votes
# Lean Mean Bean Machine, 3 bytes

```
O
~

```

Marble spawns at `O`, drops to `~`, which teleports it back up to the top of the column.

# Answer
> 1 votes
# Newline, 3 bytes

```
i[]

```

Same as brainfuck answer. Adds one and loops

```
[i]

```

also works

```
{}

```

works only if `loops[0]=infinity`

# Answer
> 1 votes
# Emojicode, 28 bytes

```

```

# Answer
> 1 votes
# Cubically, ~~2~~ 1 byte

```
)

```

This should not work, but it does due to how the interpreter handles the number of loops. With no jump points, `)` jumps to the beginning of the file, which is `)`... cue infinite loop.

This is the proper version that will work if I fix the interpreter:

```
()

```

`(` can be jumped to if all provided arguments are truthy (none are provided so they all are). `)` can jump back to the most recent `(` if all provided arguments are truthy. Once again, none provided so it jumps regardless.

# Answer
> 1 votes
# Java, 23 bytes

```
enum L{L;L(){for(;;);}}

```

Works with Java 5 and 6. Not with later versions, not with earlier versions. Just another variation of my "Hello, World!" answer.

## Proof of correctness

```
$ java -version
java version "1.6.0_45"
Java(TM) SE Runtime Environment (build 1.6.0_45-b06)
Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode)
$ cat L.java
enum L{L;L(){for(;;);}}
$ javac L.java
$ java L

```

Then it hangs.

# Answer
> 1 votes
# JavaScript, 9 bytes

```
while(1);

```

Infinite while loop using 1 as a true value

# Answer
> 1 votes
# Java (OpenJDK 8), 50 bytes

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

```

Try it online!

Since Java 8 interfaces can have method bodies. As they are always `public`, we save 3 bytes.

# Answer
> 1 votes
# Husk, 2 bytes

```
ƒI

```

Try it online!

### Explanation

This is the Haskell equivalent of the following

```
fix :: (a -> a) -> a
fix f = f $ fix f

fix id

```

where `ƒ` is `fix` and `I` the identity function (`id`).

# Answer
> 1 votes
# Aceto, 1 byte

```
~~O~~
```
~~O jumps back to the origin, which conveniently is where the O is!~~

~~Try it online!~~

I didn't see @L3viathan's post so...

### Some multi-byte solutions

* `@1$`
* `1§uu`
* `1§##`
* ```
3§ _
| |
_
```

Try It Online!

# Answer
> 1 votes
# Whispers, 16 bytes

```
> 1
>> While 1 1

```

Try it online!

# Answer
> 1 votes
# SNOBOL4 (CSNOBOL4), 10 bytes

```
L	:(L)
END

```

Try it online!

Line L is just a `goto L`, which works perfectly.

# Answer
> 1 votes
# Swift, 11 bytes

```
while 0<1{}

```

Works both compiled and as a shell script.

# Answer
> 1 votes
# FALSE, 5 bytes

```
[1]$#

```

Explanation:

```
[ {function start}
 1 {push 1}
] {push function}
$ {duplicate}
# {while loop: pop two functions, run them while the first returns true}

```

This will quickly use up memory since the body function of the while loop pushes a value which is never popped.

Here's one of the same size which doesn't cause a memory leak, but only works on certain interpreters/compilers:

```
[1]1#

```

The second 1 is read as a function pointer, which causes the while loop to jump to the `]`, skipping the other `1`.

# Answer
> 1 votes
# Clojure, 9 bytes (old 15 bytes) thank to @Dennins

```
(while 1)

```

# Answer
> 1 votes
# Javascript, 8 bytes

```
for(;;);

```

An empty for with no condition does the trick.

# Answer
> 1 votes
# mIRC v.7.49, ~~18~~ ~~16~~ 13 bytes

```
y while (1) y

```

This produces an infinite loop when no input is given.

The code is written in the mirc alias window, and to use it, just write /y in any chat window or status window. Also note that mIRC freezes when an infinite loop is encountered.

# Answer
> 1 votes
# Canvas, ~~2~~ 1 byte

Try it here!

---

redirects execution to the main program. This means the program contains a call to itself, so it runs forever.

# Answer
> 1 votes
# ORK, 132 bytes

```
There is such a thing as a y.
A y can z.

When a y is to z:
I am to loop.

When this program starts:
I have a y called X.
X is to z.

```

Try it online!

Defines a class `y` with a member function `z` that does nothing but loop. Then instantiates `y` and calls its `z` function.

# Answer
> 1 votes
# VBA 7 Bytes

```
Do
Loop

```

I like VBA; it does exactly what you tell it

# Answer
> 1 votes
# JavaScript (Node.js), 9 bytes

```
while(1);

```

Try it online!

# Answer
> 1 votes
# Gol\>\<\>, 0 bytes

Try it online!

Just for completeness. This works just like zero-byte Befunge infinite loop.

# Answer
> 1 votes
# C (gcc), 16 bytes

```
main(){for(;;);}

```

Try it online!

# Answer
> 1 votes
# DUP, 6 bytes

```
[1][]#                            {infinite while loop}

```

This is a proper and implementation independent solution. Mama Fun Roll’s 2 byte solution only works with the quirkster Javascript implementation that behaves a bit strangely in some cases.

# Answer
> 1 votes
# Q'Nial7, 22 bytes

```
WHILE =1 DO 1 ENDWHILE

```

# Answer
> 1 votes
# Ahead, 1 byte

```
l

```

`l` turns the head left 45 degrees. Since the board is 1x1, the head will keep trying to move but go nowhere. The head never stops until it encounters a `@`, so this "loops" forever.

I figured this would be more interesting than the alternative solution, one space character.

# Answer
> 1 votes
# HadesLang, 15 bytes

```
while[true]
end

```

# Answer
> 1 votes
# LOLZ, 9 Characters

```
lolloolol

```

lol: creates the loop statement

loolol: returns the value "1"

# Answer
> 1 votes
# Flobnar, 1 byte

```
@

```

Try it online!

`@` indicates the entry point of a program and evaluates the cell to its west. There is nothing to the west, meaning it wraps around and evaluates `@` again.

The language spec is unclear about whether it is legal for `@` to evaluate itself recursively. The linked interpreter supports it. It also does tail-call elimination, meaning that this is really an infinite loop and will not cause a stack overflow.

# Answer
> 1 votes
# Piet, 0 bytes

An empty image will make Piet loop around forever...

# Answer
> 1 votes
# INTERCAL, 16 bytes

```
(1)DOCOMEFROM(1)

```

Try it online!

Probably the first time I've managed to get away with not `GIVING UP`. This program goes to line 1 after line 1 finishes executing. (The shorter `(1)DO(1)NEXT` very quickly maxes out the `NEXT` stack and disappears into the black lagoon.)

# Answer
> 1 votes
# TIS-100, 0/5 bytes

Nonempty solution:

```
JRO 0

```

It's really hard to tell the difference between "halting" and "repeating infinitely" in TIS-100, since every program loops automatically. As such, I have done both an empty and nonempty solution.

# Answer
> 1 votes
# Turing Machine But Way Worse, ~~27~~ 13 bytes

```
0 0 0 1 0 0 0

```

Try it online!

**Explanation:**

Rest of the number isn't necessary, as they are text-based and pointer commands.

```
0 0 0 1 0 0 0-> do not halt
  |     | |
  |     | +-> do not print
  |     +--> go to state 0
  |
  +---------> if state 0

```

# Answer
> 1 votes
# Brian & Chuck, 7 bytes

```
!{?
!{?

```

Try it online!

# Answer
> 1 votes
## Backshift, 1 byte

```
0
```

### How it works

This tries to move 0 1-0=1 times backwards. This does not halt, as it tries to do this until it encounters a 1 (which is impossible).

## Adar, 7 bytes

```
[(0,1)]
```

### How it works

This is a looping counter; that means it starts from 0 and counts up in 1s forever.

# Answer
> 1 votes
## Forth, 19 bytes

```
: b begin again ; \ compiles word that loops endlessly
b                 \ executes this word

```

Try it online!

# Answer
> 1 votes
# Malbolge, 1787 bytes

This one doesn't rely on interpreter bug.

```
bP&A@?>=<;:9876543210/.-,+*)('&%$T"!~}|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+*/.-,+*)('&%$#"!~}|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+*)('&%$#"yb}|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%*k('&%e#d!~}|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6||3876w4-tr*/.-&+*)('&%$e"!~}|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss*/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHG*ED=%%:?>=~;:{876w43210/(-,+*)('h%$d"ca}|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(DCB%@?"=<;|98765.3210p.-n+$)i'h%${"!~}|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(D'%A@?"=<}:98y6543,1r/.o,+*)j'&%eez!~a|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HG*ED'BA@?>7~;:{y7x5.3210q.-n+*)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nl*ki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G*(D'%A$">!};|z8yw543t1r/(-,+*)(i&%fd"!~}|_t]xwvutslqTonmPkjLhKIeHFbEC_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<}{987x/4ussr).o,+l)(h&ge#db~a_{^\x[YutWrTjinQOkNLhgJeG]\aDB^]@[=SRW:877LQP3N0FEJ-+**?DC&A#98=~|:98yx/4u21rp(',mk)(ig%|{"ca}`^z][wZXtWUqTRnQOkNLhKIedcFE`YB@@?ZYRW:UTS6QPO11F..CHGF)(CB;@#>!~;XzV7gwu-QrrqMoJIkZF'WC$#AbQ`_{^L9wI64"VDConzl+j);JJ%qGFEZ~}]{ygwRuc8aSq44"H1Y.iV,e*RQ

```

Try it online!

# Answer
> 1 votes
# jq -n, 9 + 3 = 12 bytes

```
def f:f;f

```

The `-n` option makes jq not consume any input, otherwise it waits for stdin before starting the loop.

# Answer
> 1 votes
# 1+, 5 bytes

```
1##1#

```

**Explanation:**

```
1#    [Jump to 1st hash]
  #   [1st hash in program (counting starts from 0)]
   1# [Jump to 1st hash]

```

## Alternatively, 5 bytes

```
(|())

```

**Explanation:**

This program define and execute a function with an empty name. The function calls itself. Thus, it is infinite recursive.

# Answer
> 1 votes
## Pizza Delivery, 2 bytes

```
(]

```

While L is zero, end while.

# Answer
> 1 votes
## Nandy, 4 bytes

```
:#()

```

Never decrement: never end. (0 NAND 0 is 1. Thanks to @EdgyNerd for noting that.)

# Answer
> 1 votes
# \>\<\>, 0 bytes

```

```

## Explanation

There's no `;` instruction to halt the program, so it runs forever.

# Answer
> 1 votes
## Rust, 17 bytes

```
fn main(){loop{}}

```

Just for fun :P

# Answer
> 1 votes
# Cascade, 1 byte

```
|

```

Try it online!

or (if my understanding is correct) any other one-byte program from `@/\!^?_$<>=~+-*:%().#`--that is, any instruction which depends on the return value of what's below it, either directly or to the left or right, since in the case of a one-byter all three of those wrap back around to the same command. I suspect that most if not all of these would run out of call stack given enough time, but I don't know Perl so I can't quite tell what the interpreter is actually doing.

# Answer
> 1 votes
# International Phonetic Esoteric Language, ~~3~~ ~~7~~ 4 bytes

```
01ɑɒ
10   (loop bounds 0-1, set current IDX=0, LIM=1)
  ɑɒ (since IDX<LIM, infinite loop)

```

---

7 bytes. Labels are fun.

```
|a|ʟ|a|

```

Defines a label `a` and jumps to `a`.

---

3 bytes (WIP language) (OLD)

```
ɘ0e

```

What the code does is push `0`, then check if the stack is falsy, which `0` is. Then it jumps, without any output.

No TIO interpreter yet, but is runnable by cloning the repository above, and calling `python3 main.py "code here"`.

```
ɘ0e
ɘ   ; begin falsy jump
 0  ; push 0
  e ; pop, if falsy jump; else end falsy jump

```

# Answer
> 1 votes
## `i`, 1 byte

```
I

```

Forever, execute the input (which is then not printed to the console).

## `i`, 4 bytes

Pretty much a terrible language for looping.

```
i""E

```

## Explanation

<pre><code>i   E % Foreach the range from 0 to positive infinity:
 ""   % Push the null string

Flags:i  % Implicit print disabled
```

# Answer
> 1 votes
# Intcode, 5 bytes

```
5,0,1

```

This is too short.

# Answer
> 1 votes
# Taktentus, 4 bytes

```
_:=0

```

This is jump for line number 0 (first)

In English: https://esolangs.org/wiki/Taktentus

# Answer
> 1 votes
**TI-BASIC, 4 Bytes**

Written in TI-BASIC for TI-83 or 84 series.

```
While 1:End

```

Previous version, 5 Bytes

`Lbl A:Goto A`

# Answer
> 1 votes
## vJASS (Warcraft 3), 58 bytes

```
//! inject main
loop
endloop
//! dovjassinit
//! endinject

```

Without `exitwhen` inside the loop, it loops infinitely.

# Answer
> 1 votes
# Rust, 18 bytes

```
fn main(){loop{}}

```

Thankfully loop exists :) , recursion causes a stack overflow plus its the same amount of bytes.

# Answer
> 1 votes
# Integral, 6 Bytes

```
⌡◙d⌡◙d

```

Don't Try it! (it will screw up your browser)

# Answer
> 1 votes
# MAWP v1.1, 2 bytes

```
[]

```

Stack starts with 1, brackets loop as long as top of stack isn't 0.

Try it!

# Answer
> 1 votes
# 05AB1E, 1 Byte

```
[

```

Try it online!

```
[  # begin infinite loop

```

# Answer
> 1 votes
# sed, 3 bytes

```
:;b

```

Pretty simple. Make an unnamed label, then `b`ranch to it. Not all versions of sed support unnamed labels, in which case there is a 5 byte solution.

```
:a;ba

```

# Answer
> 1 votes
# Poetic, 10 bytes

```
why i
o no

```

Try it online!

# Answer
> 1 votes
## NDBall, 11 bytes

```
(0)>0
(1)<0

```

the ball bounces back and forth forever

the ball starts on (0) then is told to move forward along the 0th dimension making it go to (1)

then at (1) it is told to move backward along the 0th dimension, making it go back to (0)

the new line is mandatory, hence the extra byte

this was done in NDBallSim V1.0.1

# Answer
> 1 votes
# Pixilang, 8 bytes

```
a:goto a

```

A pixel based programming language.

# Answer
> 1 votes
# BRASCA, ~~3~~ 2 bytes

```
1J

```

Try it!

## Explanation

```
1J - Move the pointer back one character.

```

# Answer
> 1 votes
# ARM Thumb-2 machine code, 2 bytes

```
e7fe

```

```
1:
        b.n     1b

```

It is an instruction that jumps to itself. There isn't much else to it.

Being a single narrow instruction, it is the shortest possible solution.

# Answer
> 1 votes
# Pxem, Filename: 4 bytes + Content: 0 bytes = 4 bytes.

* Filename: `.w.a`
* Content: none

# Answer
> 1 votes
# convey, 2 bytes

```
5]

```

Try it online!

In convey, } is an output, and \] is a dummy output or sink. In convey, all static numbers and strings continuously output, so `5]` will continuously output 5 to a dummy output, looping forever.

# Answer
> 1 votes
# Duocentehexaquinquagesimal, 2 bytes

Try it online!

# Answer
> 1 votes
# ABC, 2 bytes

```
al

```

`l` is the actual infinite loop, `a` is just a placeholder to increment the accumulator at each iteration.

Try it online!

# Answer
> 1 votes
# CSASM v2.4.0.2, 26 bytes

```
func main:
.lbl a
br a
ret
end

```

Endlessly jumps execution back to the label `a`, which just refers to the `br` instruction itself.
The `ret` instruction and `end` token are needed for the function to compile.

# Answer
> 1 votes
# Splinter, 5 bytes

```
A{A}A

```

Try it online!

Interpreter crasher. Defines A as itself, then calls A, with infinite recursion.

# Answer
> 1 votes
# MMIXAL, 10 bytes

```
Main JMP @

```

Assembly language. Has jump-to-self. Done. (This compiles down to four bytes of actual code, `F0000000`.)

# Answer
> 1 votes
# Dis, 0 bytes.

Yes, a blank program:

## How it works

* The Dis language accepts an empty program.
* Begins with `c=0`.
* `mem[i]=0` for each `i`, so every cells stand for NOP.
* Unlike Malbolge, the Dis language does never modify the program by default.
* This goes forever.

Since TIO doesn't have Dis by native, I made the interpreter. Try it online!

# Answer
> 1 votes
# yuno, 2 bytes

```
1¿

```

This will freeze your browser window so I took the TIO link out.

```
 ¿    While
1     1
      (1)

```

The 1-byter `ɫ` (call this link) dies to recursion which unfortunately outputs to STDERR. I might add a flag to disable that in the future.

This will keep applying `1` to `1` until `1` is not true and then print the result after infinite time. Hopefully that's acceptable. If not, you can add the `d` flag to disable implicit output, or do `1¿ɳ“”` \- evaluate `1¿`, then take ignore that and take the right argument to `ɳ`, which is `“”`, an empty string.

# Answer
> 1 votes
# Mascarpone, 8 bytes

```
[:!]v*:!
[  ]v*   // define and push a new operation
 :!   :! // duplicate and execute the operation on the stack

```

# Answer
> 1 votes
# Maze, 7 Bytes

```
^^
%R%L

```

Maze is a 2D language where cars navigate through a maze and execute instructions in cells they visit. This code starts a car `^^`, which by default moves downwards. The next instruction redirects the car to the right `%R`. That lands on a cell that redirects the car to the left `%L`, creating an infinite loop.

# Answer
> 1 votes
# ErrLess, 0 bytes

An empty program in ErrLess is an infinite loop! This is because if the IP reaches the end of the program it loops back to the start, so programs have to be explicitly halted using `.`.

ErrLess is a stack-based language I made for fun over the last few months. You can read the docs here, and I also started a tutorial.

Try it online!

# Answer
> 1 votes
# Binary Pi Calculus, 6 bytes

```
0x73 0xB8 0x1B 0xDB 0xB0 0x00

```

Unfortunately, I could find no existing BPC interpreter. If one does exist, please let me know.

### Explanation

```
0x73     0xB8     0x1B     0xDB     0xB0     0x00
01110011 10111000 00011011 11011011 10110000 00000000
01110011101110000001101111011011101100000 0000000
011                                       Run the following two processes in parallel
   100    1110                            Write the free variable 0...
      1110                                ...to the free channel 0
              000                         End first process
                 001                      Run the following on an infinite number of threads:
                    1011110               Read from the free channel 0 to the bound variable 0
                           110    1100    Write the bound variable 0...
                              1110        ...to the free channel 0
                                      000 End second process

```

The corresponding pi-calculus program is

```
a<a>|!a(a).a<a>

```

Reads and writes are blocking, so each thread will be executed sequentially. As there are an infinite number of them, the program will therefore never halt.

# Answer
> 1 votes
# Exceptionally, 1 byte

```
=

```

Attempt This Online!

All programs in Exceptionally run as infinite loops. (Unfortunately, the empty program exits immediately instead of looping.) All we need is a no-op to execute each time.

Here, we're using `=`, which (given no arguments) asserts that the register is equal to itself. In fact, any of the characters `+-*^=IF{}!` should work. Several others (`&UDSW`) would also work, except that they will eventually run out of memory and print something to stderr.

# Answer
> 1 votes
# makina, 2 bytes

```
><

```

That's it, that's the program.

# Answer
> 1 votes
# Fig, \\$\log\_{256}(96)\approx\\$ 0.823 bytes

```
(

```

Beats all y'alls' one-byters mwahahaha

# Answer
> 1 votes
# Rattle, 3 bytes

```
[]0

```

Try it Online!

# Answer
> 1 votes
# TacO, 2 bytes

```
@"

```

TacO sees the source code as an infinite plane. When it encounters a `"`, it searches forever for the matching quote, idling forever. `@` is required as a program root.

Try it online!

# Answer
> 1 votes
# Arturo, 9 bytes

```
whileø[]

```

Try it

This also works and is the same length:

```
f:$[][f]f

```

# Answer
> 1 votes
# Thunno, 1 byte

Actually \\$ 1 \log\_{256}(96) \approx \\$ **0.82 bytes** but the leaderboard doesn't take decimals.

```
[

```

Attempt This Online!

Just a simple infinite loop.

# Answer
> 1 votes
# Swift, 12 bytes

```
while true{}

```

Try it online!

# Answer
> 1 votes
# (,) 8 Chars or 1.585 Bytes

```
(,,,,())

```

# Answer
> 1 votes
# Desmoslang Assembly, 0 Bytes

It's an infinite loop no matter what (at least until I implement a halt instruction (which I might not even do))

# Answer
> 0 votes
# C++ Template Meta-Programming, 48 bytes

```
template<int n>class S{enum{v=S<n-1>::v}}S<1>::v

```

There is an infinite loop in the template, so this doesn't compile. Other stuff that doesn't compile, but doesn't need to for the template to recurse (S being private, S\<1\>::v being free floating)

Can be run at http://coliru.stacked-crooked.com/ for error `g++: internal compiler error: Segmentation fault`

```
g++ -std=c++14 -O2 -Wall -pedantic -pthread -ftemplate-depth=162345 main.cpp && ./a.out

```

# Answer
> 0 votes
# HPPPL, 16 bytes

```
while 0=0 do end

```

# Answer
> 0 votes
# Univar, 8 bytes

```
($,,)$,,

```

Self-calling function.

# Answer
> 0 votes
# x86 Machine code, 2 bytes

**Machine Code**

```
     00 01
0000 73 FE

```

**Asm source**

```
[SECTION .text]
[bits 16]
[org 0x100]

EntryPoint:
    jnc     EntryPoint

```

Both the `jmp` and the `call` instructions use a 1 byte op-code followed by a 2 byte absolute offset. Conditional jumps on the other hand, are limited to a destination within \[+127, -128\] bytes of the branch. This is because they are encoded with a 1 byte op-code and a 1 byte relative offset. Dos already cleared the flags before invoking our program, so we know the carry flag will be clear and facilitate an endless (non-crashing) loop. We wont run out of stack-space, which would result in a stack-overflow error, or overwriting and ultimately crashing, our program. Approaches using `call` will suffer this after about 32,638 iterations. (stack is initally 0xFFFE, (3 byte) program begins at 0x100, each iteration decrements the SP by 2.)

# Answer
> 0 votes
## ROOP, 1 byte

```
1

```

At the beginning, the number 1 is converted to an object that contains the number. As there is no operator and the object has nowhere to move, it always happens the same: nothing. The program does not end because there is an existing object.

# Answer
> 0 votes
# Befalse, 7 bytes

A two dimensional language.

Extremely straightforward; the `!` unconditionally skips the next instruction and the `/` and `\` reflect intuitively.

```
!/\
 \/

```

# Answer
> 0 votes
# Etre, 2 bytes

```
()

```

The program sets the first cell to 1, then loops while it isn't zero.

# Answer
> 0 votes
# Skull, 8 bytes

```
for(;;);

```

Uses a bug in the Skull2C transpiler, where unrecognized expressions are converted directly into C.

# Answer
> 0 votes
# KimL, 14 bytes

```
A:
ctrl.goto A

```

For whatever reason, labels must come before the lines that they label.

# Answer
> 0 votes
# Perl 6, 7 bytes

```
loop {}

```

but...

```
> loop{}
===SORRY!=== Error while compiling <unknown file>
Whitespace required after keyword 'loop'
at <unknown file>:1
------> loop⏏{;}

```

k.

# Answer
> 0 votes
# Perl 5, 9 bytes

```
while(){}

```

boooooooooooooooooooooooooooooooooooooooooring.

# Answer
> 0 votes
# Postscript, 6 bytes

```
{}loop

```

Infinite loop that does nothing. Ties up 1 core at 100% when run under ghostscript. Interestingly, the ghostscript interpreter keeps accepting input, so it must be running a separate thread. Not sure what would happen if this was sent to a printer, though.

# Answer
> 0 votes
# Oracle PL/SQL 11.2, 30 bytes

```
BEGIN LOOP NULL;END LOOP;END;/

```

# Answer
> 0 votes
# Magic, 7 bytes

```
skip -1

```

A simple self-GOTO.

# Answer
> 0 votes
# 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.

# Answer
> 0 votes
## GNU Make, 16 bytes

```
f=$(call f)
$(f)

```

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

# Answer
> 0 votes
# ForceLang, 9 bytes

Works by abusing the new `def` instruction.

```
def a a
a

```

Original 14-byte answer:

```
label l
goto l

```

# Answer
> 0 votes
# Pylons, 4 bytes.

```
w,1}

```

Loops while 1 is true.

# Answer
> 0 votes
# Milky Way 1.6.5, 3 bytes

```
&{}

```

See the docs.

# Answer
> 0 votes
# Mathcad, 4 "bytes"

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.

# Answer
> 0 votes
# Come Here, 11 bytes

```
1COME FROM1

```

# Answer
> 0 votes
# 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`.

# Answer
> 0 votes
# 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.

# Answer
> 0 votes
# tinyBF, 5 bytes

```
+|= |

```

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

# Answer
> 0 votes
# 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                           ......

```

# Answer
> 0 votes
# 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.

# Answer
> 0 votes
# Dumbfuck, 2 bytes

```
.?

```

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

# Answer
> 0 votes
## Pyke, 1 byte

```
r

```

Try it here!

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

# Answer
> 0 votes
# 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).

# Answer
> 0 votes
# 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:

```
  !" ! " !"!

```

# Answer
> 0 votes
# 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.

# Answer
> 0 votes
# niblet, 2 bytes

```
 [

```

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

# Answer
> 0 votes
# 0815, 7 bytes

```
}: :#:

```

(trailing space)

```
}:0:#:0

```

Explained:

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

# Answer
> 0 votes
# 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).

# Answer
> 0 votes
# Benul, 0 bytes

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

# Answer
> 0 votes
# 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).

# Answer
> 0 votes
# Java, 50 bytes

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

```

# Answer
> 0 votes
## Copy, 10 bytes

```
copy 0 0 1

```

Copy the current instruction at the next location.

Basically a Core war imp.

# Answer
> 0 votes
# 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 `R`ecurse 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.

# Answer
> 0 votes
# 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.

# Answer
> 0 votes
# Lolo, 20 bytes

```
lOLolo loLOlo loloLO

```

You can also put in `l` at the end, but it won't ever get called.

# Answer
> 0 votes
# Sinclair ZX-81 Basic, 6 bytes

```
1 RUN

```

This would take 6 bytes in RAM (2 bytes for the line number, 2 bytes for the line length, 1 byte for the `RUN` token and 1 byte for a newline).

The way it works is (essentially) the same as the `10 GOTO 10`, the first line in the program causes the program to be executed.

# Answer
> 0 votes
# dotsplit, 4 bytes

```
jump

```

`jump`: pops number from stack, moves back that many commands

When the stack is empty, popping results in zero. Hence, it will jump on to the jump command.

In keeping with design principles, the problems this has will not be addressed, but perhaps a new command will be added, called `loop-safe` or something

# Answer
> 0 votes
# CMD, 2 bytes

Must be in a file named a.bat or a.cmd

```
@a

```

Must be in a bat or cmd file

```
@%0

```

# Answer
> 0 votes
# Visity, 0 bytes

```
(no code)

```

As this answer points out Visity wraps around producing an infinite loop.
Or more conventional (2 bytes):

```
[]

```

# Answer
> 0 votes
# Unary, 695 bytes

695 zeros. Program that prints the actual code can be found here.

# Answer
> 0 votes
# , 3 bits, represented as 1 byte on disk (language postdates challenge)

```
1

```

Try it online!

This is fairly simple. The program starts by pushing `7` onto the stack (which is what `1` does); then when the end of the program is reached, the top nonempty stack element is executed, without removing it from the stack (although any empty elements above it *are* removed). `7` just pushes an empty stack element to the stack, which immediately gets removed as it's the end of the program, and so nothing has changed and the same stack element just gets run again, repeatedly.

# Answer
> 0 votes
# SmileBASIC, 5 bytes

```
EXEC.

```

`.` is the same as `0.0`, so it runs `EXEC 0`, which executes the program stored in slot 0, which is the default slot.

Example use:

```
PRINT TIME$
WAIT 1
EXEC.

```

# Answer
> 0 votes
# Pari/GP , 9 Bytes

```
while(1,)

```

*(dummy text such that SE accepts the answer)*

# Answer
> 0 votes
## PKod \- 1 byte

*Version 1.1 was released very recently as I still update this, which implements this new function/command*

```
<
Explanation: Jumps back to first byte in code. So it jumps back to itself. Normally meant to be used with test cases (e.g.: if prime, jump back to start - iterate all code again, but since thread asks for infinite loop, why not)

```

Alternative version, 4 bytes:

```
-+ia
Explanation: -+ , remove then add 1 to value. Thus value keeps jumping from 0 and 1. "i" jumps two blocks back in code until value is next char after "i". Thus until char is 1. Thus until value reaches ascii code of a which is 97. Which never happens

```

# Answer
> 0 votes
# Chip, 5 bytes

```
*S

```

+3 for `-w` on the command line, which allows the program to run without reading from stdin. Instead, it uses an internal source (generating `0x00` repeatedly by default).

---

`*` is a constant high signal; this turns on adjacent elements.
`S` when powered, suppresses output for the current cycle.

# Answer
> 0 votes
# Unreadable, 25 bytes

```
'"""""'"""'""""""'"""'"""

```

Try it online!

## Explanation

```
'"""""                       While X is true, do Y
      '"""                   [X] - Return 1
          '""""""            [Y] - Set variable X to value Y
                 '"""           [X] - Return 1
                     '"""       [Y] - Return 1

```

# Answer
> 0 votes
# MOO, ~~30 28~~ 26 bytes

```
while(!suspend(0))endwhile

```

The `suspend(0)` is necessary to avoid "task ran out of ticks'

# Answer
> 0 votes
# Implicit, 1 byte

```
(

```

Creates a jump point. When the interpreter hits EOF and there is an open jump point, it loops forever.

# Answer
> 0 votes
# Nhohnhehr, 11 bytes

```
+-+
|$|
+-+

```

Try it online!

# Answer
> 0 votes
# jq 1.5, 13 bytes

```
until(null;1)

```

this also works but is no shorter:

```
repeat(empty)

```

# Answer
> 0 votes
# Chip-8, 1 byte

```
0x12

```

Instructions in Chip-8 are 2 bytes, so `0x12` is interpreted as `0x1200` (assuming the unused parts of the program are filled with zeros)

Instruction `0x1...` jumps to the address stored in the lower 1.5 bytes, which is `0x200`, the start of program memory.

# Answer
> 0 votes
# , 12 bytes

```
3.6147281494

```

Try it online! (Note: The interpreter used by TiO raises an error with this code. This is caused by the interpreter, not the program itself)

Explanation (According to the wiki specifications):

```
3.         Start program
6 14 72    Set memory cell 14 to 72
8 14       While cell 14 != 0
9          End while
4          End program

```

# Answer
> 0 votes
# Hodor, 22 bytes

```
hodor............(1){}

```

Hodor!

Or, (44 bytes)

```
hodor............(hodor. rhodor!? hodor? ){}

```

# Answer
> 0 votes
# Smalltalk-80, 8 bytes

(or more)

First there is no such thing as a program in Smalltalk-80, just write a snippet anywhere in a text pane and press the doIt! pop up menu. But we can eventually write snippets that don't stop.

```
[]repeat

```

is the obvious infinite loop

```
thisContext restart

```

is our kind of goto solution

```
|x|
x:=[:b|b value: b].
x value:x

```

is a block closure evaluating itself recursively, but since a closure close over local variables, we can do it shorter:

```
|b|(b:=[b value])value

```

Since Smalltalk-80 don't do recursive tail elimination, this infinite loop will starve memory and won't really be infinite.

We also may retry code that raised an exception, if ever the exception was temporary...
(a costly variant of repeat)

```
[0halt]on:Halt do:[:e|e retry]

```

We can also play with recursive structures, modulo recursive tail elimination problems:

```
|x|(x:=1->0)key:x;hash

```

We can also exploit weaknesses of the interpreter itself - this is in latest Squeak 6.x (you'll have to kill the image):

```
|c|c:=Class new.c superclass:c.c new

```

Since new will invoke `self basicNew initialize`, the interpreter will loop in #initialize method lookup. This time no memory growth, the loop is solid.

There must be some shorter exploit, but I'll stop here, Smalltalk is more talk than small for golfing...

In a certain sense, the interpreter performs an infinite loop itself, so doing nothing is already doing an infinite loop, but that's cheating.
In the case of Smalltalk though, since we save the state of the interpreter in an image, and later resume an image at each restart, we're just running the infinite loop for more than 20 years now (or one of its avatars). Since it's ran over a virtual machine, it even perpetuates across different machines, OS, architectures, so it's a quite robust loop!

# Answer
> 0 votes
# Operation Flashpoint scripting language, 4 bytes

```
@0>1

```

`@` waits until the condition (`0>1`) is true, which obviously never happens, so it keeps looping and checking the condition forever.

**Alternative solution (10 bytes):**

```
#l
goto"l"

```

This usually freezes the game.

# Answer
> 0 votes
## REXX, 10 bytes

```
s:signal s

```

Of course, the canonical way is a whopping 14 bytes:

```
do forever
end

```

Or, depending on implementation:

```
do forever
nop
end

```

# Answer
> 0 votes
# Acc!!, 21 bytes

```
Count i while i+1 {
}

```

Try it online!

In Acc!!, looping is *costly*. Whitespace between brackets is required and the statement is a bit wordy. This is pretty self-explanatory, but just in case, it increments `i` until `i - (i + 1) = 0`, which is never.

# Answer
> 0 votes
# Pyt, 3 bytes

```
1`ł

```

Explanation:

```
1             Pushes 1 onto the stack
 `ł           Loops while the top of the stack is not zero

```

Try it online!

# Answer
> 0 votes
# Forked, 0 bytes

Same as the top two answers. Try it online!

# Answer
> 0 votes
# Wumpus, 0 bytes

Try it online!

Another 0 byte 2D entry. In Wumpus, ~~the first cell is implicitly created,~~ the pointer is always out of bounds, so it reflects forever.

# Answer
> 0 votes
# Momema, 4 bytes

```
j0j1

```

Try it online!

## Explanation

```
j  0  #  label j0: jump past label j0 (no-op)
j  1  #  label j1: jump past label j0 (re-execute this instruction)

```

# Answer
> 0 votes
# Stax, 1 byte

```
W

```

Try it online!

Just an unconditional loop without body.

# Answer
> 0 votes
# axo, 1 byte

```
_

```

Try it online!

```
_  goes to the command at 0,0, which happens to be _
```

# Answer
> 0 votes
# PHP 7, 8 bytes

```
for(;;);

```

This is the shortest I could think of, it's one shorter then

```
while(1);
//and
a:goto a;

```

Try it online

it's 5 more if you count the `<?php` tag

# Answer
> 0 votes
# uBASIC, 7 bytes

```
1Goto1:

```

Try it online! Version that produces output may be seen Here

# Answer
> 0 votes
# VBA, 7 Bytes

Anonymous VBE immediate window that takes no input and loops forever

```
Do:Loop

```

# Answer
> 0 votes
# Yabasic, 7 bytes

Anonymous Function that takes no input and loops forever.

```
Do:Loop

```

Try it online! A version that infinitely outputs `1` may be seen here.

# Answer
> 0 votes
# MY-BASIC, 12 bytes

Anonymous `While` loop that loops forever.

```
While 1
Wend

```

Try it online! A version that prints `1` infinitely may be seen here.

# Answer
> 0 votes
# Visual Basic .NET (.NET Core), 44 bytes

Declare `Sub`routine that takes no input and loops forever.

```
Module M
Sub Main
Do
Loop
End Sub
End Module

```

Try it online! A version that outputs `1` infinitely may be seen here.

# Answer
> 0 votes
# Pain-Flak, 8 bytes

```
))((})({

```

Try it online!

# Explanation:

```
))(( pushes 1 on stack
})({ the }...{ loops until TOS = 0 and the )( makes it run as a loop because without the )( the }...{ would eval as }{ and not loop
The code is flipped and added to the end during Pain-Flak interpreting and the code does a infinite loop again.

```

# Answer
> 0 votes
*So I suppose I can create a new language and develop its intepreter for this answer, can't I?*

> 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**

# Ghrvy...!, 3 bytes

```
grv

```

Intepreter written in Python 3

**Explanation first (Syntax and functions please see below)**

```
g            # Add 1 to the 1st cell
 r           # Loop when 1st cell != 0
  v          # Switch between cell manipulation and pointer manipulation
             # Implicit end of loop. Since 1st cell is still 1, voilà, infinite loop.

```

Ghrvy...! is a new programming language developed just after I finished golfing my answer in the challenge Non discriminating programming that I at first typed a lot of `ghrvy`s in the code to meet the requirements. Since it is inspired by brainfuck, it is also the type of cell-pointer esolang. All programs in brainfuck can be transpiled to this language.

Syntax:

```
`g`: aGaru  - increase the pointer / value in current cell by 1.
              Affects the value by default.
              (Japanese for 'going up')
`h`: Heru   - decrease the pointer / value in current cell by 1.
              Affects the value by default.
              (Japanese for 'becoming less')
`r`: Repeat - repeat the next code block (block with indent
              greater than the indent of the line where the `r`
              token is on) if r is the last command of the same
              line, or else repeat the remaining code on the same
              line, when the value in current cell is non-zero.
`v`: Value  - switch the target of tokens `g` and `h` between the
              pointer and the value at the pointer.
`y`: Yee    - Set the value in current cell to a random number in
              the range [0, value in next cell] inclusive.
`.`: Input  - Get a byte from user input and set the value in
              current cell to that byte. Supports UTF-8.
`!`: Output - Output value in current cell as a byte in UTF-8.
              The program will wait for a valid UTF-8
              representation to output.
Spaces(` `) - No meaning when between commands on a line, act as
              indentation when at the beginning of a line.
Newlines    - Split code blocks, no meaning.

```

Since there must be something after the token `r` and token `v` does no pointer , cell and I/O manipulations, the program `grv` can be transpiled to brainfuck as `+[]`.

Messages in the STDERR generated are those generated by the intepreter. **No actual output is generated by the Ghrvy...! program itself.**

*Well, I came up the idea of the language first, and found this challenge may be a good place to show the features ;)*

# Answer
> 0 votes
# Sceql, 3 bytes

Make the current byte non-zero, then loop forever. I use this implementation to verify it.

```
-\/

```

# Answer
> 0 votes
# Python 3, 37 bytes

Hope I did this correctly

```
try:
    while 1:pass
except:pass

```

Try/Except will end program when memory runs out.

# Answer
> 0 votes
# Dreaderef, 5 bytes

```
1 9-1

```

Try it online!

## Explanation

```
deref 9 -1 ; put value of cell 9 (initially 0) into cell -1, the instruction pointer

```

The `9` could have been replaced with any integer except `-1`, `0`, or `2`.

# Answer
> 0 votes
## Reflections, 5 bytes

```
v\
\/

```

Test it!

Explanation:

* `v` reflects the IP down
* `\` reflects the IP right
* `/` reflects the IP up
* `\` reflects the IP left
* `v` reflects the IP down into the loop again

# Answer
> 0 votes
# Japt, 1 byte

Assumes an unlimited call stack.

```
ß

```

Test it

# Answer
> 0 votes
# MachineCode, ~~5~~ 4 bytes

```
ebfe

```

This executes the machine code `EB FE` (`JMP -2`); `-2` (0xFE) is the length of the instruction.

Try it online!

# Answer
> 0 votes
# Tamsin, 10 bytes

```
main={''}.

```

Try it online!

# Answer
> 0 votes
# Idris, 19 bytes

```
main:IO()
main=main

```

Haskell solution + type signature.

# Answer
> 0 votes
# ink, 7 bytes

```
-(i)->i

```

Try it online!

# Answer
> 0 votes
# Crystal, **6 bytes**

```
loop{}

```

The `loop` keyword takes a block, which is here denoted by the curly brackets. I'm not sure I've seen any "real" (intended for use) Crystal code that uses `loop` instead of `while`, but I'd expect it to be used in the expanded form:

```
loop do
  # do something here
end

```

# Answer
> 0 votes
# Aheui, 0 byte.

Since Aheui is befunge-like, this is infinite loop.

# Answer
> 0 votes
# VTL-2, 7 bytes

```
2 #=1

```

`#` is the system variable in VTL-2 for line numbers, and it works to retrieve a line number *or* as a GOTO if given an assignment. So this is a trivial GOTO loop. The one interesting thing about it is that VTL-2 doesn't actually let you GOTO the current line number. It does GOTO the next largest line number when given a nonexistent line, however, so a one-line infinite loop will always work given that `y` is less than `x` for the program `x #=y`.

# Answer
> 0 votes
# Forget, 37 bytes

```
const 0x0 1;cleanse 0x0;while 0x0;end

```

TIO

# Answer
> 0 votes
# 33, 4 bytes

Yes, this is a very simple answer:

```
1a[]

```

Nothing short of outright hardware failure will stop this from running. Or, y'know, stopping the program.

# Answer
> 0 votes
**GOLANG : 32 Bytes**

```
package main;func main(){main()}

```

One more solution :

```
package main;func main(){for{}}

```

# Answer
> 0 votes
## Oasis, 2 bytes

```
1b

```

TIO

### Explanation

```
1  Starting from a(1)
 b Recurse all the way down (i.e. do a(n-1))

```

# Answer
> 0 votes
# Stax, 1 bytes

```
G

```

Run and debug it

`G` goes to the beginning of the program...

# Answer
> 0 votes
## ABC (Esoteric), 1 byte

```
l

```

Loops back to the beginning.

# Answer
> 0 votes
## And, 0 bytes

```

```

No `&& exit`, therefore loops forever.

# Answer
> 0 votes
## A0A0, 2 bytes

```
G0

```

Goes 0 lines below the current line.

# Answer
> 0 votes
## Fastlane, 0 bytes

```

```

The pointer speed defaults to 1 and wraps around; there isn't a `$` instruction to halt the pointer in this program.

# Answer
> 0 votes
## , 2 bytes

```
¤

```

Loops forever, takes arbitary input and has no output.

# Answer
> 0 votes
# ///, 3 bytes

```
///

```

Try it online!

## Explanation

This replaces nothing with nothing. It runs forever because when it replaces nothing with nothing, it has to replace *that* nothing with *another* nothing, and it does this indefinitely.

# Answer
> 0 votes
# QWOP, 2 bytes

```
OO

```

## Explanation

The command O `return[s] the pointer to the last O, if one exists.` So this will run indefinitely without producing output.

# Answer
> 0 votes
# Kipple (cipple), ~~6~~ 5 bytes

```
1>a(a

```

Pretty simple, just pushes 1 to stack A, and then begins a loop that only ends if stack A is empty

-1 byte, since the ending bracket isn't necessary in cipple for some reason

Try it online!

# Answer
> 0 votes
## Element, 3 bytes

```
!{]

```

Negates top of stack & executes while.

TIO

# Answer
> 0 votes
# Whenever: 4 bytes

```
1 1;

```

Is actually an example from the specification. The instruction causes line 1 to put itself back on the to-do list.

# Answer
> 0 votes
# NULL, 2 bytes

```
41

```

Code in the NULL language is a number.

The interpreter sets X = 41 and Y = 1. Afterwards, it divides X by its smallest prime factor (41) and multiplies Y by that, so then X = 1 and Y = 41.

Afterwards, it performs an action which corresponds to that prime factor. The action for `41` is to swap X and Y, so X = 41 and Y = 1.

The program ends when X = 1, which will never happen with this code.

# Answer
> 0 votes
## tq, 3 bytes

```
"")

```

## Explanation

```
"",  # Define an empty string
   ) # Extend the list forever

```

# Answer
> 0 votes
# Kotlin, 14 bytes

```
{while(1>0){}}

```

Try it online!

# Answer
> 0 votes
# Husk, 2 bytes

```
LN

```

Try it online!

# Explanation

```
 N   The natural number list       . [1, 2, 3, 4, ...]
L    Try to find the length of that. ???

     Weirdly, Husk isn't lazy in this case.
     So it will loop forever as the
     counter approaches positive infinity.

```

# Answer
> 0 votes
# , 6 bytes

```
<^:_[1

```

Try it online!

## Explanation

```
<      # A monad
 ^:_   # Done infinity times
    [1 # To an argument

```

# Answer
> 0 votes
# Haskell, 9 bytes

```
main=main

```

Defines the main function (required to run) recurring on itself, resulting in an infinite loop.

# Answer
> 0 votes
# , 5 bytes

```
-^:]_

```

Try it online!

```
-        Negate the given number
 ^:]     Repeat (right arg) times
    _    The right arg: infinity
         Repeat (infinity) times means to find the fixed point,
         but there is none since it alternates between _ (inf) and __ (-inf)

```

---

```
0&-~_

```

Try it online!

```
0&-~_    `~` gives the argument `_` to both sides of `0&-`
         so it is equivalent to `_ (0&-) _`
_ (0&-) _
  (0&-)      Negate the given number
_            If you give left arg to a `&`-function, it becomes repeat count
             so it acts exactly like `^:_` (find the fixed point)
        _    The initial value

```

This one works with any other single-digit integer in the place of 0.

# Answer
> 0 votes
# Ruby, 6 bytes

The `loop` construct produces an infinite loop. Thanks, Yukihiro Matsumoto.

```
loop{}

```

# Answer
> 0 votes
# Python 3, 15 bytes

```
def f():f()
f()

```

Try it online!

A function calling itself (till maximum recursion depth exceeded)

# Answer
> 0 votes
# Rockstar, ~~17~~ 9 bytes

```
while 1
1

```

Try it here (Code will need to be pasted in)

# Answer
> 0 votes
# Add++, 5 bytes

```
Dx,+1

```

Try it online!

Very basic, this simply executes the following pseudocode:

```
x = 0
Do
  x = x + 1
While x > 0

```

For 1 extra byte, we can remove any possibility of running out of memory if `x` becomes too big:

```
Dx,x:1

```

Try it online!

which simply sets `x` equal to 1 each time, rather than `x+1`

# Answer
> 0 votes
# Arn, 3 bytes

```
[[{

```

Try it!

Takes advantage of Arn's pretty printing of matrices combined with an infinite, empty sequence.

# Answer
> 0 votes
# Perl 5, 6 bytes

```
{redo}

```

Try it online!

# Answer
> 0 votes
# Elixir, ~~38~~ 18 bytes

```
l=&[&1.(&1)];l.(l)

```

Try it online!

```
l=&[&1.(&1)];l.(l)  # full program
 =          ;       # set...
l                   # variable...
 =          ;       # to...
  &[       ]        # function taking one argument that...
      .(  )         # calls...
    &1              # first argument...
      .(  )         # with argument...
        &1          # first argument
              .( )  # call...
             l      # variable...
              .( )  # with argument...
                l   # variable

```

# Answer
> 0 votes
# Uselesslang, 0 bytes

Explanation:

```
<empty>
<EOF>   goto first char

```

# Answer
> 0 votes
# Arm/Thumb/MIPS/SPARC/PowerPC assembly, 3 bytes

```
b 0

```

Which produces on my machine:

# AArch64 machine code, 4 bytes

```
0: 14000000  b 0

```

Or with `--target=armv7m-none-eabi` gives @EasyasPi's answer.

Try compiling (not running) it online to several different machine languages here!

# Answer
> 0 votes
# Thunno 2, 1 byte

Try it online! (Note: it will probably crash your browser)

# Answer
> 0 votes
## ELVM IR, 5 bytes

```
jmp 0

```

Explanation: Jump to the first basic block unconditionally, in this case, it is the start of program.

# Answer
> 0 votes
# YASEPL, 2 bytes

```
?1

```

goes back to the first instruction, which is itself

---
Tags: code-golf
---