Shortest infinite loop producing no output

Question

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 1

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 2

L00P, 0 bytes

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

Answer 3

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 4

Brainfuck, 3 bytes

+[]

Never decrement: never end.

Answer 5

///, 3 bytes

///

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

Answer 6

Java, 53 bytes

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

Yay full program requirement!

Answer 7

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. 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.

Answer 8

Haskell, 9 bytes

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

main=main

Answer 9

Python, 9 bytes

Works in both 2 and 3.

while 1:0

Shortened by @FryAmTheEggman

Answer 10

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 11

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 12

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 13

><>, 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 14

LOLCODE, 24 bytes

IM IN YR X
IM OUTTA YR X

Answer 15

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 16

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 17

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 18

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 19

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 20

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 21

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 No OPeration. 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 Jump Relative uncOnditionally. 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 22

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 23

Foo, 3 bytes

(1)

Everyone's favorite programming language! :D

Answer 24

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 25

Perl, 4 bytes

do$0

Executes itself repeatedly.

Answer 26

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 27

Pyth, 2 bytes

# 

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

Answer 28

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 29

Common Lisp, 6 characters

(loop)

Answer 30

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 31

PowerShell, 7 bytes

for(){}

...

Answer 32

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 33

Matlab/Octave, 11 bytes

while 1;end

(tested)

Answer 34

A POSIX OS's program loader, 14 bytes

#!/usr/bin/env

Answer 35

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 36

GolfScript, 3 bytes

1do

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

Answer 37

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 38

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 39

Mouse, 5 3 bytes

()$

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

Saved 2 bytes thanks to cat.

Answer 40

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 41

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 42

C, 17 bytes

main(){l:goto l;}

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

Answer 43

Macaroni 0.0.2, 14 chars

label a goto a

Fairly self-explanatory...

Answer 44

VBA (immediate pane), 14 bytes

This will freeze up the VBE and its host app:

do:loop

Answer 45

Malbolge, 1 byte

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

Answer 46

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, Ms 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 47

PHP, 8 bytes

for(;;);

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

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

Answer 48

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 49

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 50

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 51

Unlambda, 7 bytes

``ci`ci

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

Answer 52

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 53

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 54

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 55

Ruby, 6 bytes

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

loop{}

Answer 56

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 57

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 58

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 59

Beam, 2 bytes

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

><

to the very basic

>?

and

>|

Answer 60

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 61

AWK, 12 bytes

END{for(;;)}

Does nothing with each line of input, then hangs forever at the end.

Answer 62

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 63

Tcl/Tk, 0 bytes

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

Answer 64

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 65

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 66

Jelly, 1 byte

ß

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

Try it online!

Answer 67

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 68

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 69

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 70

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 71

GNU dc, 6 bytes

[dx]dx

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

Answer 72

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 73

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 74

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 75

Mathematica, 10 8 bytes

0~Do~∞

Answer 76

COBOL, 51 bytes

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

Answer 77

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 NOPs forever, so we could have a 0-byte solution. (Thanks to Thomas Kwa for pointing this out.)

Answer 78

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 79

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 80

3var, 2 bytes

{}

To quote the docs:

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

Answer 81

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 82

R, 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 83

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-execed 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 84

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 85

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 86

Half-Broken Car in Heavy Traffic, 5 4 bytes

^ov#

also in 4 bytes:

o
 #

Answer 87

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 88

AutoHotkey, 8 bytes

loop {
}

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

Answer 89

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 90

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 91

APL, 2 bytes

→1 go to line 1 (this line)

Answer 92

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 93

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 94

µ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 95

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 96

Element, 3 bytes

!{}

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

Answer 97

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 98

rs, 3 bytes

+/1

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

Answer 99

x86 Intel Assembly (NASM), 5 bytes

jmp $

Answer 100

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 101

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 102

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 103

Javascript (8 bytes)

for(;;);

Edit courtody of @KritixiLithos

Javascript (10 bytes)

while(1){}

Answer 104

Go, 31 Bytes

package main
func main(){for{}}

Nothing special, the for loop without header runs infinitely.

Answer 105

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 106

Lazy K, 8 7 bytes

SISSSII

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

Answer 107

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 108

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 109

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 110

Ziim, 14 bytes

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

↘↙↙
↑↑

Answer 111

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 112

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 113

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 114

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 115

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 116

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 117

Aubergine, 6 bytes

:aa=ia

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

Answer 118

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 119

DC, 6 bytes

[dx]dx

...puts the constant string [dx] on the stack, duplicate it (d command), pop and interprete string (x command)...

Answer 120

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 121

Subskin, 6 bytes

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

Answer 122

Batch, 9 bytes.

a:
goto a

 

Answer 123

Fuzzy Octo Guacamole, 2 bytes

()

A empty infinite loop.

Answer 124

V, 1 byte

ò

V 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:

ò<code>ò

This is equivalent to

qq<code>@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 125

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 126

evil, 2 bytes

mb

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

Answer 127

GPRX 3000, 1 byte

g

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

Answer 128

Seed, 3 bytes

0 0

Equivalent to an empty Befunge program.

Answer 129

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 130

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 131

Linux shebang, 5 bytes

#!./a

Must be named as a.

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

Answer 132

BASIC, 8 bytes

1 GOTO 1

Goto self

Answer 133

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 134

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 135

Gaot++, 27 bytes

bleeeet bleeeeeet bleeeeeet

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

Answer 136

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 137

Bash, 10 2 bytes

$0

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

Answer 138

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 139

Scala 12 bytes

while(true)0

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

Answer 140

Alice, 0 bytes

Try it online!

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

Answer 141

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 142

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 143

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 144

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 145

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 146

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 147

beeswax, 3 bytes

O_O

or alternatively

j_j

or

>_<

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

Answer 148

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 149

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 150

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 151

Keg, 1 byte

{

Auto completes the while loop and runs it infinitely

Answer 152

Pyramid Scheme, 41 bytes

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

Try it online!

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

Answer 153

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 154

Retina, 10 bytes

I'm pretty sure this can be made shorter.

0
+T`d`10

Answer 155

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 156

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 157

Scala, 12 bytes

while(1>0){}

Answer 158

R, 9 8 bytes

repeat 1

Saved 1 byte thanks to MickyT!

Answer 159

AutoIt3, 12 bytes

While 1
WEnd

Simply loop indefinitely. Nothing much to say.

Answer 160

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 161

Groovy, 8 bytes

for(;;);

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

while(1){}

Answer 162

Math++, 3 bytes

1>$

Basically a GOTO 1 statement- on line 1.

Answer 163

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 164

OCaml, 17 bytes

while 1<2do()done

1 byte removed thanks to @Mauris.

Another one bytes the dust thanks to @feersum.

Answer 165

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 166

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 167

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 168

AutoIt, 10 bytes

Do
Until 0

Lame.

Answer 169

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 170

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 171

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 172

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 173

Whitespace, 9 bytes

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

. represents a space and ; represents a newline character.

Answer 174

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 175

FlogScript, 2 bytes

F<

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

Answer 176

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 177

Factor, 14 bytes

: a ( -- ) a ;

and nicely symmetrical looking (almost)

Answer 178

Pyth, 3 bytes

W1 

Note that there is a space after W1.

Answer 179

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 180

PowerShell, 14 7 Bytes

for(){}

Previous version (14 bytes):

while($true){}

Answer 181

Roadrunner, 14 bytes

mEEp mEEP MEEp

Answer 182

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 183

BotEngine, 2 bytes

><

Fairly self-explanatory.

Answer 184

Marbelous, 7 bytes

00
\\//

One marble bounces between the two deflectors forever.

Alternate version:

00
/\/\

Answer 185

Javascript, 8 bytes

while();

This almost crashed my computer once :o

Answer 186

Mouse-2002, 2 bytes

()

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

Answer 187

QBasic, 8 7 bytes

DO:LOOP

Even shorter than the GOTO one!

---

V1.0

1:GOTO 1

Classical Goto.

Answer 188

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 189

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 190

Spiral, 1 byte

0

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

Answer 191

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 192

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 193

2-ill, 7 bytes

@ @
@$@

The instruction pointer just loops counterclockwise forever.

Answer 194

Perl, 6 bytes

{redo}

See redo in perldoc.

Answer 195

T-SQL, 8 bytes

l:goto l

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

Answer 196

S.I.L.O.S, 11 bytes

lbla
GOTO a

Answer 197

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 198

S.I.L.O.S, 9 bytes

:a
GOTO a

Try it online!

Answer 199

J, 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 200

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 201

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 202

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 203

PHP, 9 bytes

back to basic:

L:goto L;

^_^

Answer 204

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 205

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 206

Pushy, 2 1 bytes

[

Try it online!

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

Answer 207

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 208

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 209

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 210

uBASIC, 7 bytes

1GOTO1

Note trailing newline. Trivial BASIC variant.

Try it online!

Answer 211

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 212

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 213

x86 Assembly, 2 bytes

x: loop x

Bytes: Ô■

Hex: ['0xe2', '0xfe']

Answer 214

tcl, 7 bytes

vwait v

Explanation

Answer 215

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 216

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 217

OIL, 1 byte

6

TIO does not currently support OIL.

Explanation:

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

Answer 218

Lua and RBX.Lua, 14 bytes

while 1 do end

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

Answer 219

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 220

Braingolf, 4 bytes

[1+]

Try it online!

Answer 221

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 222

Aceto, 1 byte

O

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

Answer 223

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 224

Taxi, 22 bytes

[a]Switch to plan "a".

Try it online!

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

Answer 225

Emojicode, 28 bytes

Answer 226

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 227

JavaScript, 9 bytes

while(1);

Infinite while loop using 1 as a true value

Answer 228

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 229

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 230

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 231

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 232

SNOBOL4 (CSNOBOL4), 10 bytes

L	:(L)
END

Try it online!

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

Answer 233

Swift, 11 bytes

while 0<1{}

Works both compiled and as a shell script.

Answer 234

Clojure, 9 bytes (old 15 bytes) thank to @Dennins

(while 1)

Answer 235

Javascript, 8 bytes

for(;;);

An empty for with no condition does the trick.

Answer 236

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 237

VBA 7 Bytes

Do
Loop

I like VBA; it does exactly what you tell it

Answer 238

JavaScript (Node.js), 9 bytes

while(1);

Try it online!

Answer 239

Gol><>, 0 bytes

Try it online!

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

Answer 240

C (gcc), 16 bytes

main(){for(;;);}

Try it online!

Answer 241

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 242

Q'Nial7, 22 bytes

WHILE =1 DO 1 ENDWHILE

Answer 243

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 244

HadesLang, 15 bytes

while[true]
end

Answer 245

LOLZ, 9 Characters

lolloolol

lol: creates the loop statement

loolol: returns the value "1"

Answer 246

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 247

Piet, 0 bytes

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

Answer 248

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 249

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 250

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 251

Brian & Chuck, 7 bytes

!{?
!{?

Try it online!

Answer 252

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 253

Forth, 19 bytes

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

Try it online!

Answer 254

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 255

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 256

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 257

Pizza Delivery, 2 bytes

(]

While L is zero, end while.

Answer 258

Nandy, 4 bytes

:#()

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

Answer 259

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 260

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 261

W i, 1 byte

I

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

W i, 4 bytes

Pretty much a terrible language for looping.

i""E

Explanation

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

Flags:i  % Implicit print disabled
```

Answer 262

Taktentus, 4 bytes

_:=0

This is jump for line number 0 (first)

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

Answer 263

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 264

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 265

Swift, 12 bytes

while(1>0){}

Answer 266

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 267

Rust, 17 chars

fn main(){loop{}}

Nothing much interesting to see here.

Answer 268

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 269

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 270

Lua, 11 bytes

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

::y::goto y

Answer 271

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 272

STATA, 10 bytes

while 1{
}

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

Answer 273

Objective-C, 1716

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

Answer 274

Java6 : 50 Bytes

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

class A{static{for(int i=1;i>0;);System.exit(0);}}

Answer 275

VBScript, 17 bytes

do
loop while 1

Answer 276

Batch, 3 bytes

@%0

Answer 277

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 278

C++, 15 bytes

Same as C:

main(){main();}

Answer 279

F#, 14 bytes

while 0<1 do()

Self-explanatory.

Answer 280

AHK, 4 bytes

loop

quick and simple

Answer 281

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 282

Fourier, 3 bytes

1()

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

Answer 283

Aheui, 0 bytes

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

Answer 284

C, 16 bytes

main(){for(;;);}

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

Answer 285

CFL 2 (ComeFrom 2), 17 bytes

10 comefrom 20
20 

Try it here.

Answer 286

Carriage, 30 bytes

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

Answer 287

SmallTalk – 18 bytes

[true]whileTrue:[]

Answer 288

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 289

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 290

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 291

PHP, 10 8 bytes

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

while(1)

while(1){}

Answer 292

D , 21 bytes

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

No language used with D in it name.

Answer 293

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 294

Octave, 10 bytes

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

do until 0

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

Answer 295

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 296

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 297

Emily, 12 bytes

while^(1)^()

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

Answer 298

Delphi, 35 bytes

program P;begin while true do;end.

Managed to beat C# this time :)

Answer 299

Coffee Script, 9 8 bytes

1while 1

Answer 300

Gema, 18 15 characters

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

Sample run:

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

Answer 301

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 302

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 303

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 304

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 305

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 306

PARI/GP, 9 bytes

while(1,)

Or equivalently:

until(0,)

Answer 307

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.
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 308

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 309

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 310

Hassium, 17 Bytes

Calls the main() infinitely.

func main()main()

Run online and see here

Answer 311

JacobFck

:A_A

Expanded and commented here

Answer 312

, 2 chars / 4 bytes

↻;

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

Answer 313

ಠ_ಠ, 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 314

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 315

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 316

DStack, 3 bytes

skt

Language created by my few days ago

Answer 317

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 318

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 319

Thue, 11 bytes

0::=0
::=
0

(Silly 30 character minimum)

Answer 320

BASIC, 8 bytes

2 GOTO 1

A simple answer, but hey, it uses basic!

Also, for fun:

Brainf*ck, 3 bytes

+[]

Answer 321

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 322

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 1s in memory.

Answer 323

Emacs Lisp, 9 bytes

(while t)

Pretty straight-forward.

Answer 324

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 325

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 326

STXTRM, 2 bytes

;;

Program execution in this language is... strange.

Answer 327

Dirst, 4 bytes

lpn_0

Loops as long as 0 is equal to 0.

Answer 328

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 329

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 330

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 331

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 332

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 333

Puzzlang, 4 bytes

XX X

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

Answer 334

Carriage, 7 bytes

#11-\@!

Smallest self-copying program that I could find.

Answer 335

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 336

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 337

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 338

Grond, 7 bytes

w(1){}

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

Answer 339

Gogh, 1 byte

Another Gogh answer!

Ø

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

Answer 340

Factor, 15 bytes

Yea, Factor is verbose.

[ t ] [ ] while

Do nothing forever. Hangs the Listener.

Answer 341

Subleq bytecode, 3 binary words

00 00 00

Equivalent to

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

Answer 342

Pylongolf2, 2 bytes

><

That's it.

Answer 343

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 344

Jumper, 2 bytes

:0

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

Answer 345

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 346

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 347

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 348

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 349

Revaver2pi, 5 bytes

TEL 0

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

Answer 350

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 351

Sonic Pi

loop do end

I think that's easy to understand.

Answer 352

ACIDIC, 1 byte

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

Answer 353

Enigma-2D, 2 bytes

RL

The IP alternates between moving rightwards and leftwards.

Answer 354

MarioLANG(4 Bytes)

><
==

Answer 355

Nim, 16 bytes

while on:discard

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

Answer 356

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 357

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 358

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 359

Racket 18 bytes

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

Answer 360

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 361

7, 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 362

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 363

Pari/GP , 9 Bytes

while(1,)             

(dummy text such that SE accepts the answer)

Answer 364

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 365

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 366

BitCycle, 3 bytes

>1<

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

Answer 367

AWK, 1 byte

0

If I've read the rules correctly, this satisfies the constraints. If we run the code without input, as stipulated, it will be in an infinite loop processing its nonexistent input, forever. If you happen to give it some input, it won't print it.

Usage:

awk '0'

Using an END label is equivalent to this, regardless of what is attached to label, as it requires some input in order to be executed.

The smallest code that doesn't look for input would be (in my version of gawk):

BEGIN{for(;;)1}

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

Answer 368

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.

Non-competing since I only wrote the language 3 days ago.

Answer 369

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 370

MOO, 30 28 26 bytes

while(!suspend(0))endwhile

The suspend(0) is necessary to avoid "task ran out of ticks'

Answer 371

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 372

Newline, 3 bytes

i[]

Same as brainfuck answer. Adds one and loops

[i]

also works

{} 

works only if loops[0]=infinity

Answer 373

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 374

Implicit, 1 byte

(

Creates a jump point. When the interpreter hits EOF and there is an open jump point, it loops forever.

Answer 375

Nhohnhehr, 11 bytes

+-+
|$|
+-+

Try it online!

Answer 376

jq 1.5, 13 bytes

until(null;1)

this also works but is no shorter:

repeat(empty)

Answer 377

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 378

4, 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 379

Hodor, 22 bytes

hodor............(1){}

Hodor!

Or, (44 bytes)

hodor............(hodor. rhodor!? hodor? ){}

Answer 380

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 381

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 382

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 383

Whispers, 16 bytes

> 1
>> While 1 1

Try it online!

Answer 384

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 385

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 386

Forked, 0 bytes

Same as the top two answers. Try it online!

Answer 387

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 388

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 389

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 390

Stax, 1 byte

W

Try it online!

Just an unconditional loop without body.

Answer 391

axo, 1 byte

_

Try it online!

_  goes to the command at 0,0, which happens to be _

Answer 392

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 393

uBASIC, 7 bytes

1Goto1:

Try it online! Version that produces output may be seen Here

Answer 394

VBA, 7 Bytes

Anonymous VBE immediate window that takes no input and loops forever

Do:Loop 

Answer 395

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 396

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 397

Visual Basic .NET (.NET Core), 44 bytes

Declare Subroutine 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 398

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 399

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 ghrvys 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 400

Sceql, 3 bytes

Make the current byte non-zero, then loop forever. I use this implementation to verify it.

-\/

Answer 401

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 402

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 403

Canvas, 2 bytes

¹［

Try it here!

Explanation:

<num>［<...><｝|］|EOL|EOF>: execute <...> <num> times.
¹: float.MaxValue = ∞

Answer 404

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 405

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 406

Japt, 1 byte

Assumes an unlimited call stack.

ß

Test it

Answer 407

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 408

Tamsin, 10 bytes

main={''}.

Try it online!

Answer 409

Idris, 19 bytes

main:IO()
main=main

Haskell solution + type signature.

Answer 410

ink, 7 bytes

-(i)->i

Try it online!

Answer 411

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 412

Aheui, 0 byte.

Since Aheui is befunge-like, this is infinite loop.

Answer 413

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 414

Forget, 37 bytes

const 0x0 1;cleanse 0x0;while 0x0;end

TIO

Answer 415

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 416

GOLANG : 32 Bytes

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

One more solution :

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

Answer 417

Oasis, 2 bytes

1b

TIO

Explanation

1  Starting from a(1)
 b Recurse all the way down (i.e. do a(n-1))

Answer 418

Stax, 1 bytes

G

Run and debug it

G goes to the beginning of the program...

Answer 419

ABC (Esoteric), 1 byte

l

Loops back to the beginning.

Answer 420

And, 0 bytes

No && exit, therefore loops forever.

Answer 421

A0A0, 2 bytes

G0

Goes 0 lines below the current line.

Answer 422

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 423

@, 2 bytes

¤

Loops forever, takes arbitary input and has no output.

Answer 424

><>, 0 bytes

Explanation

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

Answer 425

///, 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 426

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 427

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 428

Element, 3 bytes

!{]

Negates top of stack & executes while.

TIO

Answer 429

Rust, 17 bytes

fn main(){loop{}}

Just for fun :P

Answer 430

International Phonetic Esoteric Language, 3 bytes (WIP language)

ɘ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 431

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 432

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 433

Intcode, 5 bytes

5,0,1

This is too short.

Answer 434

tq, 3 bytes

"")

Explanation

"",  # Define an empty string
   ) # Extend the list forever

Answer 435

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 436

HPPPL, 16 bytes

while 0=0 do end

Answer 437

Univar, 8 bytes

($,,)$,,

Self-calling function.

Answer 438

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 439

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 440

Befalse, 7 bytes

A two dimensional language.

Extremely straightforward; the ! unconditionally skips the next instruction and the / and \ reflect intuitively.

!/\
 \/

Answer 441

Etre, 2 bytes

()

The program sets the first cell to 1, then loops while it isn't zero.

Answer 442

Skull, 8 bytes

for(;;);

Uses a bug in the Skull2C transpiler, where unrecognized expressions are converted directly into C.

Answer 443

KimL, 14 bytes

A:
ctrl.goto A

For whatever reason, labels must come before the lines that they label.

Answer 444

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 445

Perl 5, 9 bytes

while(){}

boooooooooooooooooooooooooooooooooooooooooring.

Answer 446

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 447

Oracle PL/SQL 11.2, 30 bytes

BEGIN LOOP NULL;END LOOP;END;/

Answer 448

Magic, 7 bytes

skip -1

A simple self-GOTO.

Answer 449

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 450

GNU Make, 16 bytes

f=$(call f)
$(f)

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

Answer 451

ForceLang, 9 bytes

Works by abusing the new def instruction.

def a a
a

Original 14-byte answer:

label l
goto l

Answer 452

Pylons, 4 bytes.

w,1}

Loops while 1 is true.

Answer 453

Milky Way 1.6.5, 3 bytes

&{}

See the docs.

Answer 454

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 455

Come Here, 11 bytes

1COME FROM1

Answer 456

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 457

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 458

MNNBFSL, 4 bytes

[[<]

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

Answer 459

Bash, 10 bytes

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

Answer 460

tinyBF, 5 bytes

+|= |

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

Answer 461

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 462

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 463

Dumbfuck, 2 bytes

.?

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

Answer 464

Pyke, 1 byte

r

Try it here!

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

Answer 465

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 466

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 467

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 468

niblet, 2 bytes

 [

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

Answer 469

0815, 7 bytes

}: :#: 

(trailing space)

}:0:#:0

Explained:

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

Answer 470

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 471

Benul, 0 bytes

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

Answer 472

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 473

Java, 50 bytes

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

Answer 474

Copy, 10 bytes

copy 0 0 1

Copy the current instruction at the next location.

Basically a Core war imp.

Answer 475

LI, 2 bytes

R0

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

Explanation:

R   Recurse with input:
 0  Literal 0

LI, 1 byte

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

Answer 476

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 477

Lolo, 20 bytes

lOLolo loLOlo loloLO

You can also put in l at the end, but it won't ever get called.

Answer 478

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 479

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 480

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 481

Visity, 0 bytes

(no code)

As this answer points out Visity wraps around producing an infinite loop.
Or more conventional (2 bytes):

[]

Answer 482

Unary, 695 bytes

695 zeros. Program that prints the actual code can be found here.

Answer 483

Python: 15 bytes

while 3>1:
    x=1