Java, 87 bytes

interface A{static void main(String[]a){System.out.print(a[0]);main(a[0].split("0"));}} 

(has output to STDERR, but that should not matter)

HALT, 49 bytes

1 IF '0' 2 ELSE 3 2 TYPE '0';HALT 3 TYPE '1';SET 1 

Pretty simple. If input is one go to 3, output 1, set the pointer to 1 so the program never ends. If input is output 0, print, then halt.

Online interpreter (Firefox only)

Shtriped, 33 bytes

e : t : . d : i : p : . . p : 

This prints the 0 or the infinite stream of 1's without any trailing newlines or spaces.

Explanation:

e : \ initialize a variable named ":" t : \ prompt for integer input, storing the result in : . \ define a function named "." that will only return if : is 0 (the next 4 indented lines are part the function) d : \ decrement : if : is positive, else return immediately i : \ : must have been 1 to reach here and was just decremented, so increment back to 1 p : \ print :, which we know is 1 . \ recursively call ., endlessly looping . \ call . initially p : \ if . terminated this line will finally be run, printing : which we know is 0 

BASTARD, 83 bytes

{{fi in 0{!b {= {t 0} ‘1’} {(o <> {{fi out ‘1’}{o}}){o}}{fi out ‘0’}}}} 

Note: This language is not qualified. Mostly because I'm still designing it. I just wanted to test drive it against some puzzles.

Explanation:

fi in copies the input into the 0 place on the Variable Stack.

!b is a basic if statement to check if its a "1" or not.

If it is, we just use fi out to print our "0".

Otherwise, we define a new function called o that prints a "1", and then calls itself again.

NTFJ, 27 bytes

:*:##~~~~~#@|########@|($~^ 

An online interpreter can be found here.

NTFJ is an esoteric programming language, made by user @ConorO'Brien, that is intended to be a Turing tarpit. It is stack-based, and pushes bits to the stack, which can be later coalesced to an 8-bit number.

• The only pushable values are 0 with ~ and 1 with #.
• The only manipulations possible to the actual values of the stack are to wrap eight bits into a byte with @, and to NAND with |.
• The only logic command is IF with (), but combined with JUMP ^, it can be used to create loops.

Thus, it's quite difficult to manipulate values to do your bidding.

How it works

 Implicit input: byte 48 for 0 or 49 for 1. :*: Duplicate the top item, pop/output, and duplicate again. ##~~~~~#@| Push 193 and perform NAND. ########@| Push 255 and perform NAND. These two operations change 48 to 0 and 49 to 1. ( If the top item is not 0: $ Pop the top item. ~^ Push 0 and jump to that instruction. This effectively creates a while loop that loops the entire program. 

Beatnik, 26 bytes

J ZD ZD JA K ZZZZJ Z JJ MF 

Try it online

An explanation

Words Scores Action J 8 Get character value from input ZD 12 Duplicate TOS ZD 12 Duplicate TOS JA 9 Output TOS character K ZZZZJ 5 48 Push 48 (char 0) onto stack z 10 Pop 2 from stack and subtract JJ MF 16 (7) If not zero skip back 7 words 

Of course something like the following, while still not making sense, looks more like what you would expect for a Beatnik program.

Shall falsey determine truths? We **WithoutAWarningAboutMemoryUse** printed infinitely yeas! 

Lua, 56 52 Bytes

I know that this answer in 70 Bytes exists, but its author doesn't look like he's updating it when someone point out an improvement.

if io.read'*n'>0then::a::print"1"goto a end print"0" 

Old 56 bytes solution

if io.read()=="1"then while""do print"1"end end print"0" 

Nothing special here, just using the fact that "" evaluates to true to save a byte on the infinite loop. Parenthesis for functions parameters aren't mandatory when they only take a single string, which is not stored in a variable.

Julia, 51 45 bytes

readline()>"0"?while 2>1 print(1)end:print(0) 

Read a string from STDIN. If it's lexicographically larger than the string "0" then print 1 forever, otherwise print 0 and we're done.

Saved 6 bytes thanks to Sp3000!

UGL, 6 bytes

il$o:o 

Try it online!

How it works:

i #stack.push(input) l : #while stack.peek(): $ # stack.dup() o # print(stack.pop()) o #print(stack.pop()) 

PowerShell, 24 bytes

'for(){1}'*"$args"+0|iex 

Generate expression as string and pass it to Invoke-Expression (eval).

It casts $args array to string with "", then multiplication sign casts it to int and string for(){1} is repeated int times (1 or 0 - empty string). Then we add 0 to this string, which will be cast to a string also.

Resulting string expression (for(){1}0 or 0) is then piped to Invoke-Expression, resulting either in endless loop outputting 1 or one-time output of 0.

WistfulC, 141 bytes

This C has seen better days.

if only int n were 0... wish for "%d",&n upon a star someday !n... wish "1" upon a star *sigh* wish "0" upon a star if wishes were horses... 

Obviously not competitive, but then neither is this language.

Rough translation to regular C:

int n = 0; scanf("%d", &n); while (n) { puts("1"); } puts("0"); exit(0); 

T-SQL 23 bytes

No STDIN here so a hard-coded variable.

DECLARE @ INT =1; or DECLARE @ INT =0;

and the truth machine is

l:PRINT @ IF(1=@)GOTO l

C, 41, 40 bytes

main(c){for(c=getchar();putchar(c)&1;);} 

Reads a single character from stdin, writes to stdout.

This version is 1 byte longer than feersum's solution, but removes his/her assumptions onstdin.

PHP, 34 bytes

<?for($f=fgetc(STDIN);$f;?>1<?)?>0 

Wanted to try to get rid of the print but not sure it's worth it since you have to reintroduce the <? tags

Java, 143 141 125 88 bytes

interface T {static void main(String[]a){System.out.print(a[0]);main(a[0].split("0"));}} 

Ungolfed Test Code

interface T { static void main(String[] a) { System.out.print(a[0]); main(a[0].split("0")); } } 

Lua, 34 Bytes

repeat print(arg[2])until arg[2]<1 

arg[2] contains the first command line argument, (arg[1] contains the filename)

Give an input through the command line, and it shall spam it if it's 1, or once if it's not.

Simple enough.

Copy, 67 59 bytes

My new esolang :D

getch a add b a add b -48 print a skip b skip 1 copy -4 0 1 

Explanation:

getch a Take input in variable 'a' add b a Set 'b' to 'a' add b -48 Substract 48 from 'b' print a Print 'a' skip b Skip the copy if 'a' is not zero skip 1 ^ copy -4 0 1 Copy the code block from the print to this instruction after this instruction 

Crystal, 48 37 36 bytes

y=gets;y=="0\n"&&(p 0;exit);y=="1\n"&&loop{p 1}
y=gets;y=="0\n"&&(p 0;exit);loop{p 1}
y=gets;y=="0\n"&&(p 0;1/0);loop{p 1}

Edit: Shaved off 10 bytes because the post doesn't specify what should happen on invalid input (like 2). If it does and I misunderstood, let me know.

Edit: Shaved off 1 byte by dying with an error instead of normal exit.

Crystal is statically typed, so I couldn't just do gets.chomp (gets can return nil, and nil doesn't have chomp). The alternative was gets.try &.chomp, but that takes much more space than just having the newlines.

In Crystal (and Ruby) you can do something like puts 0 if y=="0\n", however you can also shave off 2 bytes by doing y=="0\n"&&puts 0 as the && operator returns the last object it tests for truthiness.

loop is a method in the standard lib that infinitely runs the block. It's a much shorter way of writing while true;CODE;end.

p prints the result of .inspect on its arguments to the output. Here I abuse it as a shorter puts because for numbers it'll just return the number.

Valve scripting language, 38 bytes

alias 0 echo 0 alias 1 "echo 1;wait;1" 

This defines two commands, 0 and 1. Type 0 into the console for the zero case, and 1 for the 1 case.

Underload, 16 bytes

((1)S:^)~^:^(0)S 

Underload has no way to take input from standard input. The most natural way to take input is therefore from the initial stack: () for 1, (!()) for 0 (this is the normal way to represent numbers in Underload).

Here are Try It Online links for 0 and for 1 (be prepared to kill this one quickly; the infinite loop runs very quickly and will spam up your browser window).

This program didn't need much effort to golf; the most idiomatic way to do things is almost the shortest (I just had to be careful not to let the input get buried too far on the stack). It's easiest to read if I translate the code to a hypothetical functional language:

 function x(y) print(1) x(x) end x = x^(input) x(x) print(0) 

The only weird thing happening here is being able to exponentiate functions, but it's a fairly easy-to-understand operation; for example, raising a function f to the power 3 would produce f compose f compose f, i.e. lambda x.f(f(f(x))). Raising a function to the power 1 does nothing (just like if you'd raised an integer to the power 1); and raising a function to the power 0 gives you the identity function (just like raising a number to the power 0 gives you 1). Actually, the integers in Underload are defined in terms of their effect exponentiating functions, rather than the other way round; the operation is fundamental enough to Underload that you use it to construct most flow control.

Jelly, 3 bytes

Ṅ¹¿ 

If reading from STDIN is absolutely required:

ƈOḂṄ¹¿` 

I'm not sure which since "Jelly's main input method is via command line arguments, although reading input from STDIN is also possible."

SmileBASIC, 23 22 bytes

INPUT N@L?N?N/N GOTO@L 

Ends the program with a divide by 0 error.

If this isn't allowed, here's a 23 byte solution:

INPUT N@L?N IF N GOTO@L 

WireWorld (It doesnt have a scoring method yet :\)

 ████ █ <= this pixel will be the input. if it is a electron head (1), █ █ It will loop forever as 1. if its a wire (0), it will do nothing. █ ██ █ ██ █ ██ 

Common Lisp, 30

(do((x(read)))((=(print x)0))) 

Common Lisp's print function returns the object that was printed. This reads a value from the user, then prints the value until the return value of the call to print returns 0.

BitCycle, 7 bytes

Golfed 4 bytes off my example program!

?~< !~+ 

Provide input as 0 or 1 on the command-line. The -s or -p debug options are recommended, especially when dealing with infinite output.

Explanation

BitCycle is a 2D language that works by moving bits around a playfield. Commands used in this program are:

• ? puts input bit(s) onto the playfield, moving east
• ~ duplicates and negates a bit, turning the original right and the negated copy left
• < sends bits westward
• + turns 1-bits right and 0-bits left
• ! outputs bits

The input hits the first ~. A negated copy turns left (north) off the playfield and is discarded. The original bit turns right (south).

At the second ~, the original bit turns west into the ! and is output. A negated copy turns east.

If the original bit was 0, the negated copy is 1; it turns south at the +, goes off the playfield, and is discarded.

If the original bit was 1, the negated copy is 0; it turns north at the + and then west at the <. The 0 hits the first ~ again, where it turns right (north) off the playfield and is discarded. The negated copy (1) turns left (south), leading to an infinite loop.

Aceto, 11 10 bytes

X p|1 rip^ 

reads a string and converts it to an integer. | tests for truthiness (1 is truthy, 0 is not) and mirrors horizontally if truthy (in that case moving to the 1). Otherwise, we'll go to 0, which pushes the 0, we print implicit zero and eXit.

If the number was truthy (e.g. 1), we got mirrored to the 1, which pushes a 1, prints, and goes one cell up (^), going into an infinite loop.

MarioLANG, 11 bytes

;>:[< ===== 

Explanation:

; Get numerical input and save in current cell > Move left (Required to make an infinite loop) : Output the current cell [ Skip next command if cell is 0 < Move right 

Basically, it loops infinitely unless input = 0

Wise, 3 bytes

[:] 

Try it online!

Wise cannot actually output whenever you want, it only outputs the entire stack when the program terminates. So the solution to infinitely output is to simply infinitely fill the stack. When the program eventually halts (never), it will output the stack that, at that theoretical point in time, will have infinite values in it.

Explanation

[:] Implicit input from command-line arg [ If last value is != 0.. : ..Duplicate last value on stack ] If last value is != 0, jump back to [ 

Given a non-zero number, will infinitely duplicate the input on the stack, after an infinite amount of time, will terminate and output the entire stack.

Given zero, jumps to the end of the program and immediately terminates, outputting the stack, which contains only the input.

Ly, 7 bytes

n:u[:u] 

Explanation:

n # take input :u # duplicate it and print it [ # while the top of the stack is not 0... :u # duplicate it and print it ] # end loop 

6502 machine code (C64), 17 bytes

20 FD AE 20 9E B7 8A 09 30 20 D2 FF C9 30 D0 F9 60 

Online demo

This is position independent code, you can enter it at any position in RAM and call it, so it doesn't need a load address. Assuming you put it at C000 (that's the case in the online demo), call it like sys49152,0 or sys49152,1 -- any other input is undefined.

Explanation:

20 FD AE JSR $AEFD ; consume comma 20 9E B7 JSR $B79E ; evaluate number, result in X 8A TXA ; transfer X to A 09 30 ORA #$30 ; convert to numeric character 20 D2 FF JSR $FFD2 ; output character C9 30 CMP #$30 ; compare with '0' character D0 F9 BNE *-5 ; not equal? Then jump back to output (-7) 60 RTS ; return