Tellurium, 11 bytes

I?1|[i|^;]^ 

This program asks for input and converts it to an integer (I). After that, it checks if the input is 1. If it's 1, output 1 forever ([i|^;). If it's 0, output 0.

eacal, 58 bytes

label l put set n cast number arg number 0 if get n goto l 

put outputs n, which is cast to the first argument. Call like:

node eacal.js tm.eaa <input> 

Racket, 36 bytes

(do([n(read)])((= n 0)n)(println n)) 

JQuery, 63 57 Bytes

if($("input").val()==1){while(1){alert(1)}}else{alert(0)} 

Try it!

Perl 6, 28 bytes

{.say;.say while $_}(+slurp) 

PowerShell, 22 21 bytes

Variable $a into the pipeline, prints once, then prints again if the input evaluates as true. Less elegant than TimmyD's but shorter.

$a|%{$_;while($_){$_}} 

After looking at his though it could also be written as below, dropping it to 21 bytes

$a|%{do{$_}while($_)} 

><>, 6 bytes

Takes input from command line i.e. ./fish.py program.fish -v 1

:?!;:n 

Explanation:

: ? !; :n ... (Since this is fish, it wraps around and repeats) ^ ^ ^ ^ | | | | | | | Duplicates topmost value on stack and outputs it | | | | | Skips the next instruction | | | Checks if topmost value is 0 and if so, skips the next instruction, going straight to the ; which terminates the program | Duplicates topmost value on stack 

Ru, 11 9 bytes

»Ϟα;¿{»α} 

This look way too long

Python 2, 33 bytes

Golfing suggestions welcome :)

x=input() while x:print 1 print 0 

Straw, 17 bytes

(1>:&)(:&) <1='0> 

Logicode, 43 bytes

circ l(a)->1+l(a) cond binp->out l(a)/out 0 

Logicode can't output while in an infinite circuit loop, so this program will output ALL of the 1's after the infinite loop (when the program encounters a 1).

If a truth machine that goes into an infinite loop when 1 is entered and has no output is acceptable, the code can be shorter by 2 bytes:

circ l(a)->1+l(a) cond binp->out l(a)/out 0 

braingasm, 5 bytes

;:[:] 

The braingasm instruction ; and : are very similar to the brainfuck instructions , and ..

; gets some input from stdin, reads it as an integer, and stores the integer value in the current cell. : prints the value of the current formatted as an integer. Like in brainfuck, [] loops while the current cell is non-zero.

reticular, 8 6 bytes

[do?!] 

Try it online!

This is a function. g calls the function with the TOS as input. do outputs without popping, ?! skips the next char if it's 1. Because of the way functions work, the actual constructed function is:

do?!; 

This is made in a child instance of the program. Thus, if the TOS is 0, then it terminates (exits function).

Previous versions:

8 bytes:

indp?!;! 

11 bytes:

in@@p; p1 < 

This goes right by @@ if 0, and up if 1 (wrapping around to <) and prints 1 infinitely. It's in better style to do it this way, y'know, more readable. Because 2D languages are easy to read.

PHP, 30 33 bytes

do{echo$o=$argv[1];}while($o); 

Oops, didn't see the 7 other pages, one of which contains a better PHP entry.

Old 1

do{echo$argv[1];}while($argv[1]); 

Javascript, 33 32 Bytes

i=prompt();do{alert(i)}while(+i) 

uses the +i syntax (thanks ETHproductions)

Old 1

i=prompt();do{alert(i)}while(i>0) 

D - 87 bytes

void main(){import std.stdio,std.conv;int i=readln[0..$-1].to!int;do i.write;while(i);} 

Fuzzy Octo Guacamole, 8 bytes

^X({@}X) 

^ pushes input, X prints the top item on the stack. ( starts an infinite loop. {@} ends the program (@) only if the top item on the stack is falsy, like 0. The X prints the top item on the stack (again), and the ) ends the loop.

So it repeats, printing and checking forever.

PHP, 20 bytes

<?L:echo$i;if($i)goto L;# 24 bytes <?do echo$i;while($i); # Martijn´s first version golfed 24->22 bytes <?=$i;while($i)echo$i; # Martijn´s second version golfed 24->22 bytes <?while($i|!print$i); # 21 bytes <?while($i&print$i); # 20 bytes 

Requires PHP <4.2 or PHP<7 with --d register_globals=0.
Save to file, call in browser with <scriptpath>?i=<value>.

explanation for the last version:

print$i is evaluated in any case (no short circuit for bitwise operations).
print always returns true, which, when cast to int (by the bitwise and) evaluates to 1.
For $i=0, 0&1 is 0, hence false and the loop exits. for $i=1, 1&1 is 1 and the loop continues.

shortest version(s) for current PHP, 29 bytes:

while(($i=$argv[1])&print$i); while((print$i=$argv[1])&$i); for($i=$argv[1];$i&print$i;); 

Run with php -r '<code>' <value>.

Haystack, 9 bytes

id?v |o<o 

Try it online!

I'm aware that there already is a Haystack answer, but that answer uses the older version of Haystack, this answer uses Haystack 2016 (and it's much shorter)

Explanation

id Take input and duplicate it ? If input is truthy (1) continue, otherwise (0) go down 

If input is truthy...

?v Go down o Output number Since this is a 2D language, the IP wraps around and does this infinitely Also since Haystack (new) doesn't pop the top of stack after outputting 1 can be printed forever without needing to duplicate it 

Otherwise...

 ? < Go left o Output number | Exit program 

Pushy, 3 bytes

#$# 

Extremely simple:

# \ Print input $ \ While input != 0: # \ Print input 

An input of 0 will print, skip over the while loop, and terminate, whilst any other number is considered truthy and will be printed infinitely.

QBIC, 10 bytes

:{?a~a|\_X 

Explanation:

: Reads a number from the command line and names it 'a' { DO - infinite loop ?a Print 'a' ~a IF 'a': 0 is seen as false, 1 as true | THEN: Empty THEN block, we want to act on FALSE \_X ELSE exit the program. _X accepts one implicit parameter, and prints that parameter on exit. Since no parameter is given, nothing gets printed. [IF and DO are implicitly closed by QBIC] 

Threead, 5 bytes (Noncompeting)

I[o]o 

read, while not 0 output, output

Try it online!

Pyramid, 14 bytes

+1 byte to specify starting on stack 1 (originally 13 bytes).

1< b --- ?< u 

Pyramid is my new-old language, which is based off Stackylogic. It has a bunch of extra commands that will (hopefully) make it TC, which include moving up and down multiple "stacks".

Explanation:

1< 1: Move down the stack, and push 0 to the output stack b Break: outputs the stack, and resets it - also runs the stack again --- ?< Input: 1, 0: If it's 0, move up, push 0 to the output stack, terminate the program and print the stack u If the input is 1, move up to stack 0 

Alice, 8 bytes

i.o.&#@# 

Try it online!

Explanation

i Read a byte X from STDIN (gives 48 for input 0, 49 for input 1). .o Duplicate X and print that byte back to STDOUT. . Duplicate X again. &# Skip X commands. Since the program contains 8 commands, if X = 48, this doesn't really do anything. The IP will just loop through the code six times while skipping all commands. But if X = 49, it skips one more command, so the next command is skipped. @ Terminate the program (only gets executed for input 0). # Skip the i at the beginning of the next iteration. 

This code loops indefinitely, unless the @ terminates it on the first iteration.

OIL, 25 bytes

Straightforward, but nevertheless annotated:

5 # read into cell 0 0 10 # if cell 0 is equal to 0 (from cell 1), go to cell 11 (*) else 7 (&) 0 1 11 7 4 # print what's in cell 4 (a zero) & 4 6 # jump to cell 7 (&) 7 4 # print implicit 0 * 

Javascript (Node), 40 bytes

for(;console.log(v=process.argv[2])|v;); 

In Javascript for the browser this can be 29 bytes

v=prompt();for(;alert(v)|v;); 

Triangular, 6 bytes

$.(]%< 

Try it online!

This formats into the triangle:

 $ . ( ] % < 

The commands that are executed (without control flow) are $(%]. Pretty simple.

• $ read input as integer
• ( open loop
• % print as integer
• ] jump back to loop if top of stack is truthy

ILL, 19 bytes

/RnN~ >1nR\ \ / 

ILL (inverse linear law) is new right now, so this represents virtually all the instructions/groups of instructions it has at the time of posting this. The main idea though, is that the program is run by light, which reflects off of mirrors and decrease in intensity as it moves on (obeying the inverse linear law, because its 2d). Data is primarily stored in the intensity of the light, which can sort of be used as a control structure, since light with an intensity < .5 dims and does not move on to the next tick. This means that different intensities of light move different lengths. This program utilizes the dimming behavior to either halt after printing 0, or prints 1 and continues. Basically, it takes a numerical input (side note: instructions that set intensity actually do so after the current tick has run, and they also persist the light over to the next instruction, no matter what intensity it has), prints it, and then re-intensifies and enters a loop. However, the light is only re-intensified if it reaches the re-intensify instruction, which light with an intensity of 0 will not. More detailed explanation (also a valid ILL program):

/RnN~ >1nR\ \ / #END OF FILE# Truth machine. ~ : emits light horizontally at the start of a program. N : takes numerical input, set light intensity to the input. n : produces numerical output. If the light has an intensity of 0 here, it will dim after n outputs and not move on. R : re-intensify, if the light made it here, it can now continue into the loop. > : double/splitting mirror, allows the light from the above / mirror to enter the loop and move right. 1 : set intensity to 1. n : numerical output. R : re-intensify. the remaining \, /, and \ reflect the light back to > where it can start the loop again 

C# (.NET Core), 80 79 bytes

class p{static void Main(string[]I){do{Console.Write(I[0]);}while(I[0]=="1");}} 

Try it online!

I've seen some disagreement about whether arguments count as STDIN. "No" seemed more popular, but if it were acceptable then this would save 15 bytes over the previous C# answer.

Saved 1 byte by removing an unnecessary space

Cubically, 6 bytes

According to the spec, this should work:

$(%7)7 $ - Get user input as number (either 1 or 0, according to the rules) ( )7 - do ... while input value is nonzero %7 - Output the input as a number 

However, TIO seems to continue the loop even if the input is 0. The Lua interpreter handles it correctly, though.