makina, 23 bytes

v>>P >?EJ U>PU ^0n< ;1< 

Explanation

The first automaton starts in the top left, and immediately goes down and right into the ?, or if. The condition for the if is the E, or number input. Once input is given, the condition automaton jumps forwards and out of bounds, causing it to return its value. If that value is 0, or false, the first automaton turns left and goes into the top P, or print. The print spawns a new automaton going right, which jumps over the U-turn, goes left, into the n, or number. It reads the 0, turns up, does a U-turn, hits the semicolon (ending the number), and goes out of bounds, returning a 0 to the print. The first automaton then goes out of bounds and halts. However, if the value is 1, or true, the automaton turns right and proceeds directly into the n, goes left, reads the 1, and halts. Then, the first automaton goes out if the print, into the U-turn, making it go back to the arrow to the left of the print, starting the whole cycle again.

Applesoft BASIC, 28 26 bytes

1INPUTA 2PRINTA 3IFA GOTO2 

Eukleides, 40 bytes

a=number();for i=0to 0;print a;i=i-a;end 

Pretty straightforward. number() takes in a number as input. For loop seems to be the golfiest means of looping for this task. While loop skips the i=i-a; but requires two prints.

JavaScript (Node.js), 54 bytes

A JavaScript answer that actually uses both STDIN and STDOUT

n=process.argv[2];do{process.stdout.write(n)}while(+n) 

Prolog (SWI), 28 bytes

:-get(X),repeat,put(X),X=48. 

Try it online!

Gets a single character, then repeatedly print it, stopping if it is a zero.

Nekomata, 2 bytes

ᶦP 

Attempt This Online!

ᶦ Iterate the following function zero or more times until it fails P Check if the input is positive 

Funky, 28 bytes

s=io.read()while(-print(s))a 

Try it online!

Thunno 2, 2 bytes

(ß 

Attempt This Online!

 # implicit input ( # while TOS is not 0: ß # print without popping # implicit output 

Tsept v1.0, 45 bytes

Tsept is an open-source esolang I created; it's not really meant for code golfing, as even basic tasks like setting a register to a number take many instructions, and even though there are seven different registers it's almost impossible to do anything without the stacks.

?PBKpPxIIIPAPAPAPABpBPBSPBxDDPAPADPBKB!BKBPBi 

Note that you'll need a Linux machine to run this since there is no web-based interpreter for it (yet).

Analysis

?PBKpPxIIIPAPAPAPABpBPBSPBxDDPAPADPBKB!BKBPBi ?PBKpP Store input in register B xIIIPAPAPAPA Set accumulator to 48 BpBPB Swap stack value and accumulator SP Subtract ASCII 1 from accumulator and push to stack BxDDPAPADPB Calculate jump offset KB!BKBPBi Loop 

(,) 63 Chars or \$63\log_{256}(3)\approx\$ 12.48 Bytes

This was quite fun, kudos to Dadsdy for creating this language!

((),((())))(()(),(()())()(),,,(()),(()()))(,,,(()),(()()),(())) 

Try it!

Explanation

Set var_1 to the ascii value of the input (48 or 49) ((),((()))) var_2 = var_2 + 2; repeat while var_1 > var_2 (()(),(()())()(),,,(()),(()())) print var_1; repeat while var_2 > var_1 (,,,(()),(()()),(())) 

In practice this counts up in twos until var_2 becomes at least as big as the input. If the input was 0 (ascii 48) var_2 will be 48 and the last loop will run only once, if the input was 1 (ascii 49) var_2 will be 50 and the last loop will never terminate.

(,), 46 bytes

((),(((()))(())),,,(),,((())))(,,(()),,((()))) 

Try it online!

Outputs separated by newlines.I also have an alternative 46 byter using a similar strategy.

Explanation:

Note that the var shorthand below will return -1 for 0 (representing EOF) and 1 for -1, otherwise the value stored at that index (default 0).

((),(((()))(())),,,(),,((()))) First expression () Set var1 ,(((()))(())) To var(var(var(1))+var(1)) So when var(1) maps to: 0 -> var(var(0)+0) = var(-1+0) = 1 1 -> var(var(1)+1) = var(1+1) = 0 basically alternating between 0 and 1 each loop my other solution flips between 0 and -1 instead ,,,(), Repeat while 1>-1 ((())) A maximum of input char times (,,(()),,((()))) Second expression ,,(()) Output var1 ,,((())) Execute once if var(var(1)) == -1 And repeat forever if var(var(1)) > -1 

Thue++, 17 bytes

0::=~0 (?=1)::=~1 

Input is the state string, output is the alerts.

MaybeLater, 48 bytes

whenx is1{write(1)when0spass x=1}write(x=read()) 

One could remove when0spass for 37 bytes, though doing so causes a stack-overflow pretty quickly.

A Pretty Canonical MaybeLater answer, hooks to x being assigned to 1 by writing a 1 and setting x to 1 again, causing an infinite loop. when 0 seconds pass is required to avoid recursion errors by using the event queue instead. Either way, writes the result of the read.

Try it online!

Shenzhen I/O, 51 bytes, 3¥, 5 Lines

@mov p0 acc teq acc 0 +mov 0 x1 +mov 0 x0 -mov 1 x1 

Takes an input on p0 and outputs to a LCD at x1. If the input is 0, writes to an unconnected XBus wire and will wait indefinitely (this is the closest to terminating that I can think of). If the input is non-zero, loops forever writing 1.

Here is a screenshot of the two cases simultaneously.

><x>, 105 bytes

lddddddddddddddddddddddddddddddddddddddddddddddddn?v >n< 

><x>, 16 9 bytes

-7 bytes thanks to Bubbler

Abuses the fact that after every instruction, the accumulator is bound to [0, 255]. This allows us to just square the input until it's 0 or 1. Thankfully, ASCII "0", 48, takes only one square to equal 0, and ASCII "1" needs just 4 to equal 1 .

lssss>n?< 

sed -n, 10 bytes

To avoid the expensive loop, duplicate the line and use D for looping:

h G P /1/D 

Try it online!

ELVM IR, 50 bytes

getc A mov B,A sub A,48 .x: putc B jeq .x,A,1 exit 

Explanation:

getc A - Input A as ASCII mov B,A - Copy A to B sub A,48 - Subtract A by 48, which converts ASCII to number, while B still stores the ASCII .x: putc B - Output B (The ASCII) jeq .x,A,1 - If A (The number) is equal to 1, jump to .x exit - Exit 

Chef, 179 bytes

a. Ingredients. 0 a 1 b Method. Take a from refrigerator. V the a. Put b into 3rd mixing bowl. Pour contents of the 3rd mixing bowl into the baking dish. V until ved. Serves 1. 

Try it online!

A test of my new [REDACTED] compiler. As Chef always prints values only at program termination, this technically doesn't fulfill the requirements, but the baking pan (the thing that has the output) does fill up with infinite 1s so it technically counts. Here's the original code as a teaser:

def $in; read $in; while $in { print 1; flush; }; 

Uiua, 5 bytes

⍢⟜&p∘ 

Try it

Do ⍢ without popping ⟜ print &p while top of stack is 1 ∘.

Easyfuck, 5 bytes

"[']' 

" - input

[ ] - while loop

' ' - output

How dare you fuck the brain, 10 8 bytes

;/H^I|N) 

Try it online

Python 3 52 bytes

B=print def A():B(1);A() A()if input()=='1'else B(0) 

Defines a recursive function, which I believe is shorter than a while loop. Ternary statement then executes it.

Probably not the most golfed down answer.

Binary encoded lambda calculus (6.75 bytes or 54 bits)

000101100100010001101000011100110100000010110111011010

returns 0 if applied to 0, if aplied to 1 returns a lazylist of 1's

Definitions Uses the de-facto standard definition of integers, booleans and lists.

0 = λf.λx.x, 1 = λf.λx.(fx), 2 = λf.λx.(f(fx)), etc.

Booleans arent needed at all. still interesting.

True = λa.λb.a (take a and b and return a)

False = λa.λb.b (take a and b and return b)

list = λf.((fH)T) (H and T are preinserted Head and Tail)

so to construct a list, you use λH.λT.λf.((fH)T) taking Head X and Tail Y, and return λf.((fX)Y) then you can get the head X by applying True and the Tail Y by applying false. This will not be needed per se as we will only construct the list, but is interesting to know.

NOTE: this was the definition for a pair, but a list is a pair where the first argument is a value and the second argument is another list.

Pieces

The Y combinator Takes a function f, and turns it into f(Yf) thus, Yf -> f(Yf). Do you see the recursion?

Usualy defined as: (λf.(λx.f(xx))(λx.(f(xx))))

BUT! if we define it as (λf.(λx.xx)(λx.(f(xx)))) that reduces directly to (λf.(λx.f(xx))(λx.(f(xx)))), and is 5 bits smaller. lets call the compressed Y combinator Y'

The weird function W (λz.λv.(vn)z))

NOTE: this is not a closed lambda term, as it uses n. This isnt an issue though as the function its used in has n in a lambda.

The Combined function C

Just Y' applied to W

(Y' W) which is also ((λf.(λx.xx)(λx.(f(xx)))) (λz.λv.(vn)z))) Which reduces to (λv.(vn)((λx.λv.(vn)(xx))(λx.λv.(vn)(xx)))) then to (λv.(vn)(λv.(vn)((λx.λv.(vn)(xx))(λx.λv.(vn)(xx))))) and then to (λv.(vn)(λv.(vn)(λv.(vn)((λx.λv.(vn)(xx))(λx.λv.(vn)(xx)))))) and etcetera. an infinite lazy list of n.

The main function M λn.((n C) n) all together, this is λn.((n ((λf.(λx.xx)(λx.(f(xx)))) (λz.λv.(vn)z)))) n) this is where n gets 'bound'.

Results

Apply M to 0 or also (λf.λx.x) and you get (((λf.λx.x) ((λf.(λx.xx)(λx.(f(xx)))) (λz.λv.(v(λf.λx.x))z)))) (λf.λx.x))

then Reduce to ((λx.x) (λf.λx.x))

and then to (λf.λx.x) Also known as 0

Apply it to one, and after some amount of hard to explain steps where it aplies one to 1 and does some other steps to make a identity function or something, it returns the lazy list of n, but n is now one. so apply M to one and it it returns a lazy list of one.

Lazy list of one here: ((λf.(λx.xx)(λx.(f(xx)))) (λz.λv.(v((λf.λx.(fx))))z)))

Encoding

But then, we need to convert the whole thing into binary encoded lambda calculus. I wont bother with the details, but it becomes 000101100100010001101000011100110100000010110111011010

00011001 C 10 is M

C is 01000100011010000111001101000000101101110110 or 01 Y' W

Y' is 0001000110100001110011010 and W is 00000101101110110

Try it here: lambda calculus applet, then simply apply it to 1 or 0 (input so its not included) and that integer gets automatically translated.

Tcl, 38 bytes

gets stdin r puts $r while $r puts\ $r 

Try it online!

8ial, 87 74 69 bytes

PUT $1 ;d JIR l $1 0 JIR l $1 1 DEC $1 JMP d ;l OUT $1 JIR l $1 1 END 

someone pointed out that PSH was really only used for storing outputs so now it's END

Lua For windows, 70 bytes

Use lua for windows for this

I=io.read() If I=="1" then while 1 do print"1" end elseif print"0" end 

This program works because it takes a 0 or 1 from stdin then if it's a one it makes a while loop that prints one if it's a 0 it prints 0 then the program ends

Ceylon, 91 88 bytes

Improved (explanation at the end):

shared void run()=>("0"<(process.readLine()else"")then{1}.cycled else{0}).each(print);

This was the original (91 bytes):

shared void run(){if("0"<(process.readLine()else"")){while(0<1){print(1);}}else{print(0);}}

Unfortunately the most part goes to reading the input and making sure it is defined.

shared void run() { if("0"<(process.readLine() else "")) { while(0<1) { print(1); } } else { print(0); } } 

I merged this null check (in the else "" form) with the decision into one if, so when the input is ended without a line being read, it also prints 0. Also, any string sorting less than "0" lexicographically prints 0, and any string lexicographically > "0" will produce the 1-loop.

The 0<1 is used instead of true because it is shorter.

Here is a functional approach, unfortunately it can't compete (107 bytes after whitespace removal) due to the length of parseInteger:

shared void run() { value i = parseInteger(process.readLine() else "") else 0; (1:i).cycled.follow(i).each(print); } 

It cycles a range starting at 1 of length i (i.e. either {} or {1}), resulting in {} or {1,1,1,1,...}, prepends i (which results in {0} or {1,1,1,1,1,1,...}), and prints each element.

A different functional approach without variables and parsing is this one (88 bytes, shrinked version at the top):

shared void run() => ("0" < (process.readLine() else "") then { 1 }.cycled else { 0 }).each(print); 

This does the case distinction in an expression, using the then and else operators to produce either the {1,1,1,...} stream or the {0} singleton, and then calls print(...) on each element of that stream.

C#, 120 98 bytes

using c=System.Console;class o{static void Main(){if(c.Read()=='1')for(;;c.Write(1));c.Write(0);}} 

Ungolfed:

using c=System.Console; class o { static void Main() { if(c.Read()=='1') for(;;c.Write(1)); c.Write(0); } } 

x86 (Linux / NASM syntax), 86 bytes

mov dx,1 ; 3rd argument to read(): length of buffer mov ecx,esp ; 2nd argument to read(): the buffer ; 1st argument to read(): the FD is already 0 mov ax,3 ; read system call number int 128 ; invoke syscall, returns eax=1 == num of read bytes l:mov ax,4 ; start of loop, eax=syscall number of write() int 128 ; invoke syscall, returns eax=1 == num of written bytes cmp byte[esp],49 ; compare buffer against '1' jz l ; loop of it's the same int 128 ; invoke syscall otherwise (syscall 1 == exit) 

Compile with nasm -f elf h.asm && ld -o h h.o -m elf_i386 and ignore all warnings. :-)