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.

Bitwise Cyclic Tag, 3 bits or 0.375 bytes

Bitwise Cyclic Tag is one of the simplest Turing-complete languages out there. It works with two bitstrings, the program and the data. The bits of the program are read cyclically and interpreted as follows:

• 0: Delete the first data bit (and output it, in implementations that have output).
• 1x: If the first data bit is 1, append x (representing either 0 or 1) to the end of the data. (If the first data bit is 0, do nothing.)

The program runs until the data string is empty.

Truth-machine

110

When the data string is set to 0:

• 11 does not append anything because the first data bit is not 1.
• 0 deletes/outputs 0.
• The data string is now empty and the program halts.

When the data string is set to 1:

• 11 appends a 1.
• 0 deletes/outputs 1.
• The data string is back to a single 1 and the program is back to where it started, so we loop forever.

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.

8ial, 67 bytes

PUT $1
JIR o $1 1
PSH $1
OUT
JIR e $1 0
;o
PSH $1
OUT
JIR o $1 1
;e

Try it online

if you know the 67 meme, then just say it.

however i will try to make a 8ial interpreter later that can be encoded to binary

How dare you fuck the brain, 10 8 bytes

;/H^I|N)

Try it online

'Python' is not recognized, 17 15 14 bytes

0@?[0|;]jl1|jl

Input "0", Input "1" or anything else

Explanation

0@              " Pushes zero then the input to the stack            "
   ?[...]       " Checks if the two TOS's match, if it is...         "
     0|; jl..jl " ...print 0 and halt, else enter the loop that...   "
           1|   " ...prints the number 1                             "

Tcl, 39 bytes

gets stdin r
puts $r
while $r {puts $r}

Try it online!

SAKO, 68 bytes

CZYTAJ:I
GDYI=0:1,INACZEJ2
2)TEKST
1
SKOCZDO2
1)TEKST
0
STOP1
KONIEC

I believe this to be an optimal solution.

Piet + ascii-piet, 12 bytes (2×6=12 codels)

tavnsJ dl jj

Try Piet online!

As a grid:

tavnsj
 dl jj

As an image:

There was an existing answer with 12 codels, but I got this independently. Any smaller image size is likely not possible, though ascii-piet encoding allows to omit trailing black cells on each line (which makes the linked answer 11 bytes) and therefore may allow for a bit more optimization.

How it works

If the input is 1:

      InN        [1]
Loop: DP+        []   (rotate right once)
      OutN       []   (stack underflow, ignored)
      Push1      [1]
      Dup        [1 1]
      Goto Loop
      DP+        [1]  (rotate right once)
      OutN       []   (print 1)
      Push1      [1]
      Dup        [1 1]
      Goto Loop ...

If the input is 0:

InN    [0]
DP+    []   (go straight through)
Push1  [1]
Not    [0]
OutN   []   (print 0)
HALT

Bespoke, 48 bytes

truth:a machine?fiction or fact
answer:i am true

This is adapted from an example program I bundled with the source code of the official interpreter, but without the trailing CONTROL END (because it's not needed!).

Malbolge, 113 90 bytes

(=BA@?>=<;:381x543,bO/.-,+$)('~g$#"!~=|{zLxwvutWr1p0.--kjihgfI7cF!`_|0\[ZfXWVUNSL5POlMLKig

Try it online!

Do you remember when I was trying to write a short program to produce infinite output? Want to see me do it again? So, as it turns out, my previous printing program can be modified so that it works as a truth-machine... This is not a joke, don't ask me how, don't ask me why, but there was just enough remaining space available in the program to add a small branching that somehow happens in a nop zone of the previous program. This is some Malbolge magic (or should I say devilry?) right there. Like my previous program, it also works with Malbolge Unshackled.

It will be kind of hard to explain how the program works, since it has so many segments now, so I will not explain how the main loop of the program works again, just the branching and the general logic that transformed it into a truth-machine:

jpooooooo
oopopjooo
p <- Start of the program, setting up the main loop

 /<ooooop
ooopjoooo
oi <- Retrieves the input, prints it, set up address [72] if 0,
     [73] if 1, and goto address

ooo/ooo
oojoio<ii
<ooooooj/
ojiooi/oo
o <- The main loop, the address resetting loop and other values
     for crazyops

v <- Address [72], stop the program
oooopopjooiooo <- Address [73], put 1 back into the accumulator
                  and start loop
<i <- Printing loop

Hatchback, 32 bytes

0 0 0 16 0 1 0 6 0 65281 1 65535

asks for input, prints, checks if its 1 and if it is continue printing.

punchcode, 16 9 bytes

hexdump:

00000000: 16 01 05 1A 1D 0B 11 1E 0D  | .........

uncompiled:

-START  |
---O-OO-|
-------O|
-----O-O|
---OO-O-|
---OOO-O|
----O-OO|
---O---O|
---OOOO-|
----OO-O|

ibe, 18 bytes

addsQakqasQshQmqmq

explanation: (ibe doesn't support comments so this code is not valid)

ad      | initialize 1 item in tape: Q
dsQ     | get input and set it to Q
akq     | point 0 (aka 'q')
asQ     | print Q
shQmqmq | if Q is not equal to 0, go to point 0. (aka, if input is 1 then it will loop forever)

MAWP v1.1, 18 14 bytes

@A{1A:.}1M[!:]

-4 bytes with integer input.

Try it!

Qdeql, 678 531 273 bytes

&------------------------------------------------\=-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==-==\-=-\/\/==/*/------------------------------------------------\=/=\--\/\/=/*

-147 by computing the ASCII 0 as (0 - 208) rather than putting 48 directly
-258 by computing the ASCII 1 similarly

Explanation:

& get input
---------- ---------- ---------- ---------- -------- subtract 48
\ while not 0:
  queue must be 1 0 0 now
  = skip the 1
  get an ASCII 1:
  -==-==-==-==-==-==-==-==-==-==
  -==-==-==-==-==-==-==-==-==-==
  -==-==-==-==-==-==-==-==-==-==
  -==-==-==-==-==-==-==-==-==-==
  -==-==-==-==-==-==-==-==-==
  \-=-\/\/==/
  * print the ASCII 1
/ end while
get an ASCII 0:
---------- ---------- ---------- ---------- --------
\=/= \--\/\/=/
* print it

Motivation is a funny thing. If you had asked me last year if I wanted to write Qdeql code the answer would be no. But I need test cases for my interpreter, and Ørjan's transpiler from Brainfuck generates code that's too verbose to run in a reasonable amount of time.

Boo, 34 bytes

def f(x):
 print x;while x:print x

Boo is a language inspired by Python and implemented in .NET. Its syntax is very similar to Python 2's.

Befalse (quirkster), 12 bytes

,!/$.$1!
&?/

Try it!

,    Take a char from stdin
!    Jump to enter the loop
$.   Print as char and keep it
$1&  Dup and Bitwise AND with 1
     (! jumps over the newline to keep running on the second line)
?    If zero, jump out of the loop
     Otherwise, keep running infinitely

Befalse, 15 bytes

,!/$.$\
  \?&1/

Same program, but does not exploit any interpreter-specific features/bugs.

Easyfuck, 5 bytes

"[']'

" - input

[ ] - while loop

' ' - output

Uiua, 5 bytes

⍢⟜&p∘

Try it

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

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; };

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

*><>, 11 bytes

Takes input through the -i flag

:?`n;
 !`:n

Try it online!

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!

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

Intcode, 19 bytes | 8 ints

Everyone's favorite intcode computer from the Advent Of Code 2019.

3,0,4,0,1005,0,2,99

Trilangle, 13 bytes

?!<(@^\<.#^)/

Try it on the online interpreter!

Unfolds to this:

    ?
   ! <
  ( @ ^
 \ < . #
^ ) / . .

As in every Trilangle program, control flow starts at the north corner heading southwest. \|/_ reflect control flow, while <^7>vL change the direction conditionally (depending on both the stored value and the direction of the IP).

The IP starts on the red path, where it encounters the following instructions:

• ?: Read an integer from STDIN
• !: Write an integer to STDOUT (with trailing newline)
• (: Decrement
• \: Redirect control flow
• <: Branch

Upon reaching the branch instruction, the number inputted will already have been outputted once, and the stored value will be one less than that: -1 if the input is 0, or 0 if the input is 1. The branch instruction proceeds left for negative values and right otherwise.

If the value inputted was 0, the program follows the green path, which immediately hits @ (end program). Otherwise, it follows the blue path:

• /: Redirect control flow

• ): Increment, to cancel out the decrement instruction from earlier

• ^: Redirect control flow

  (Walk off the edge of the board, and wrap around to the southeast corner)

• .: No-op

• #: Skip the next instruction

After encountering #, the IP jumps into the middle of the yellow loop. ! prints out the stored value (1) repeatedly, and the other two characters keep it in the loop.

<^ is not the only combination of control flow manipulators that works. I've found that at least the following pairs also work: <7, <v, <<, L>, ^>, >>. Interestingly, <\ causes it to print every odd number twice (1, 1, 3, 3, 5, 5, ...). All other pairs I've tried exhibit one of three behaviors:

• Loop without hitting ! (e.g. L<)
• Exit early, printing out finitely many numbers (e.g. <_)
• Print a couple 1's before going back to the start and waiting for more input (e.g. <|)

shell, 28 bytes

[ 0 -eq $1 ]&&echo 0||yes 1

><x>, 105 bytes

lddddddddddddddddddddddddddddddddddddddddddddddddn?v
                                                 >n<

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.

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!

Desmos, 51 50 45 bytes

o→\left\{i=0:[0],join(1,o!)\right\}
i=0
o=0

Try It Online! (Click the play button on the ticker up top (metronome icon) to run the program)

Desmos doesn't exactly have standard I/O support, but this should get the point across. Input is the i variable, output is the o variable. Each line is a separate expression, and the first expression needs to be in the ticker, as shown in the TIO.

Addendum: at the very least, this output method is accepted by default. Not sure about the input.

EDIT: a surprising -1, apparently → parses properly as an action! Unfortunately, it still costs 3 bytes, which is the same as \to, BUT it allows me to change \to join to →join since the parser gets confused by \tojoin

EDIT: -5 thanks to zygan on discord who showed me that an action itself can be piecewise, and also me realizing that o! is shorter than o^o and doesn't even have to rely on wacky edge case behavior lol

Thue++, 17 bytes

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

Input is the state string, output is the alerts.

Racket, 58 bytes

#!racket
(let l([n(read)])(print n)(if(= n 0)(void)(l n)))

Try it online!

Explanation

Our program creates a recursive named let statement that loop if n is not equal to 0. On the first iteration, we read user input into n. We print ns value and test whether we should loop or not.

#lang racket

(let loop ([n (read)])
  (print n)
  (if (= n 0)
      (void)
      (loop n)))

ForWhile, 28 bytes

ForWhile does not have infinite loops, so to output indefinitely the program has to continuously copy its source code behind the instruction pointer.

_:49=[{}1+20[:@;20-$1-:)'#]#

online interpreter

Explanation

_                            \ read a character from standard input
 :49=                        \ check if it is one
     [                    ]# \ if the character is not one, print it
      {}1+20[:@;20-$1-:)'#   \ infinite 'loop'
      {}                     \ get the current instruction pointer (empty procedure)
        1+                   \ offset instruction pointer such that it points to start of code block
          20[:@;20-$1-:)     \ copy code starting at {  to position after #
                        '#   \ print the second value on the stack (the character read from standard input)

ForWhile, 42 bytes

This version has constant memory usage

_:49=[34(!;$1-]{}10+:34[:@;34-$1-:)49#$.]#

it works similarly to the shorter version, but additionally deletes the old code and cleans up the stack

(,) i 140 85 29 Chars or \$29\log_{256}(3)\approx\$ 5.75 Bytes

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

TIO

AArch64 machine code + Linux syscalls, 40 bytes

00: 528007e8  mov   w8, #63    // read()
04: 2a1f03e0  mov   w0, wzr    // 0 = stdin
08: 910003e1  mov   x1, sp     // to stack
0c: d2800022  mov   x2, #1     // 1 byte
10: d4000001  svc   #0         // syscall, should mov x0, #1
14: 394003e9  ldrb  w9, [sp]   // load byte
18: 52800808  mov   w8, #64    // write()
1c: d4000001  svc   #0         // syscall, w0 = 1 = stdout
20: 3707ffe9  tbnz  w9, #0, 1c // loop last instruction if byte & 1
24: d65f03c0  ret

Can be used as a void (void), or an int (void) such as main(), returning 1. If you want to use it as _start() without segfaults, replace the ret with:

24: 52800ba8  mov   w8, #93    // exit()
28: d4000001  svc   #0         // syscall

(,), 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

(,) 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.

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

x86 machine code, PC DOS, 10 bytes

00000000: a082 00cd 293c 3174 fac3                 ....)<1t..

Listing

A0 0082     MOV  AL, DS:[82H]       ; AL = first char from command line 
        DISPLAY: 
CD 29       INT  29H                ; DOS fast write AL to console 
3C 31       CMP  AL, '1'            ; was input a '1'? 
74 FA       JE   DISPLAY            ; if so, loop "forever" 
C3          RET 

Sample output

A standalone DOS .COM program.

A>TRUTH.COM 0
0

A>TRUTH.COM 1
111111111111111111111111111111111111111111111111111111111111111111111111111111
111111111111111111111111111111111111111111111111111111111111111111111111111111
111111111111111111111111111111111111111111111111111111111111111111111111111111
111111111111111
(ended because Ctrl-Break was hit)

Note: shouldn't ever crash or run out of memory since no memory is used. More likely it'll just burn a permanent screen full of 1's onto your IBM 5151 monochrome CRT monitor (so in a sense it will run forever).

hyperscript, 39 bytes

init log prompt()repeat while it log it

Full program

hyperscript, 44 bytes

def f(n)repeat while n>0 log n end log n end

Function

<script src="https://unpkg.com/hyperscript.org@0.9.8"></script>
<script type="text/hyperscript">
def f(n)repeat while n>0 log n end log n
</script>


<label style="font-family:monospace">n: <input type="number"style="font-size:1.5rem;width:4.5ch"_="on change call f(my value)" /></label>

(Note: it will crash if you give it 1)

AFAIK hyperscript can't take input from STDIN, so I'm using a function instead.

Ungolfed:

def f(n)
  repeat while n > 0
    log n
  end
  log n
end

Desmoslang Assembly, 12 Bytes

7+2*IJTGE1TO

Thunno 2, 2 bytes

(ß

Attempt This Online!

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

Funky, 28 bytes

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

Try it online!

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

Google Forms, 3 sections + 1 question

Try it online!

Google Forms has two features which I believe make it qualify as a (very limited) programming language:

1. Multiple sections, which allow arbitrary rules for which sections redirect to which, allowing for uncontrolled infinite loops
2. The ability to make different responses to a question take the user to a different section upon clicking "next", allowing for input/conditionals, and controlling loops based on input

Google Forms also has a back button, which may make it possible to store arbitrarily large amounts of information, though there's no way to make use of that information without the human running the program doing something.

Thunno, \$ 6 \log_{256}(96) \approx \$ 5 bytes

(actually 4.94 bytes, but the leaderboard doesn't take floats)

!)[1ZK

(No ATO link since that's on an outdated version)

Explanation

!)[1ZK  # Implicit input
!       # Push `not input` (i.e., 1 if input == 0; 0 if input == 1)
 )      # Break if the top of the stack is truthy (i.e. input == 0)
        # Since the stack is filled with 0s at the start, 0 is implicitly output in this case
  [     # while True:
   1ZK  #  print 1

nroff/troff, 27 bytes

Ties with user100411's 27 bytes answer. This version, however, does REALLY outputs 1's FOREVER for input 1, while previous version halts by stack overflow.

.de a
\\$1
.while \\$1 1
..

Try it online!

Usage

.a 0
.a 1

ArcPlus, 22 bytes

(: n (,))(@ (p n) (p n

Verbose version:

(set n (input))
(while (print n) (print 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.

Leaf-Lang, 43 Bytes

Note: Link to interpreter is liked above.

code:

input toNumber 1=while 1 print stop 0 print

Brainfuck, 5 Bytes

,.[.]

I/O is as 0x00 / 0x01 bytes.

I just think it's a neat thing.

K (ngn/k), 13 bytes

{x}{ \x}/.1:0

(Don't) Try it online!

The web interpreter does support stdin (via a popup prompt), and entering a 0 will print a single 0. But entering a 1 will hang the entire tab.

We need an unbounded loop, which means either m m/ or a recursive function. The latter being {x o/ \x}@.1:0 is 1 byte longer than the above.

{x}{ \x}/.1:0  full program
          1:0  read stdin as a single list of bytes (= single string)
         .     eval it
{ }{   }/      while loop:
 x               while the value is truthy,
     \x          debug-print the value (print with newline) and return it unchanged

If the input is 0, the loop runs zero times and the resulting value 0 is implicitly printed. If the input is 1, the loop runs forever, printing 1\n repeatedly.

Shell (posix), 26 bytes (code) + 1 (input) = 27 bytes

run:

$ ./<name> <1 or 0>

code:

[ $1 = 1 ]&&yes 1||echo 0

Explained:

[ $1 = 1 ] is a hacky way of evaluating if argv[1] is equal to 1

in bash && executes if the previous command finishes with exit code 0

yes 1 yes is a command that takes in a string and prints continually to stdout

in bash || executes if the previous command finishes with a non-zero exit code

echo 0 self explainatory.

Old versions

[ $1 -eq 1 ]&&yes 1||echo 0

[ $1 == 1 ]&&yes 1||echo 0

Python, 59 43 bytes

if input()=="1":
 while 1:print(1)
print(0)

-16 by Seggan

Fig, \$4\log_{256}(96)\approx\$ 3.292 bytes

?x(;

See the README to see how to run this

The ? could be replaced with a ! for the same effect.

?x(; # The program
?    # If
 x   # The input is truthy (i.e. 1)
  (; # Print the input forever
     # Otherwise print the condition (which was 0)

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)

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.

A0A0, 67 bytes

I0S1M2V0G0
G-1G-1G-1G-1
O0

A0A0
A0C3G1G1A0
A0O1A0
A0A1G-3G-3A0
G-3

The top line takes input, then adds one to this number and multiplies it by two. For input 0 we now have 2 and for input 1 we have 4. This is used as the offset for the goto instruction. If we jump by two we end up at line three which prints zero and halts. If we jump by four, we get to line five and get to an fininite loop.

A0  A0
A0  C3 G1  G1  A0
A0  O1 A0
A0  A1 G-3 G-3 A0
G-3

This infinite loop simply prints one (on the third line in the loop: O1).

SMALL, 14 bytes

$->x{x=1?1!}0!

Ungolfed code:

$ -> x

{
    x = 1?
    1!
}

0!

We first read from stdin and store the input in x, with the following line.

$->x

We then enter an iteration, where we first compare if x is 1. If that's the case, we print 1. Since this check will never be false, this iteration will be infinite.

{
    x = 1?
    1!
}

If the condition in this iteration is false, the entire iteration stops and we go to the last line, which prints a single zero after which the program halts.

0!

Applesoft BASIC, 28 26 bytes

1INPUTA
2PRINTA
3IFA GOTO2

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.

PostScript, 36 bytes

.runstdin 0 eq{0 =}{{1 =}loop}ifelse

Probably needs to be run through ghostscript to get the .runstdin operator.

tinylisp, 31 bytes

(d A(q((N)(i N(A(c 1(disp 1)))0

Defines a function A that takes the required input, as tinylisp has no concept of program input.

Try it online!

Plumber, ²⁸ 20 bytes

[]
=]]][=[]
  ][=[][

Try it Online!

I figured Plumber could use some love, so I thought I'd give it a try. It's a pretty fun language to work with! There's no online interpreter for it, so the TIO link is to Javascript, with the interpreter in the header, compliments of @RedwolfPrograms.

This simply takes in input, prints it, and if it is non-zero, it keeps printing it forever.

10IPL, 34 bytes

11001000 01001100 00100010 10100001 10100100 00100010 10100001 10100100 00100010 10100001 10100100 00100010 10100001 10100100 00100010 10100001 10100100 00100010 10100001 10100100 00100010 10100001 00100010 00011010 00101010 00101010 00101010 00101010 00101010 00000100 00000100 00000100 00110010 11110000

Try it online!

Program:

; input

inp rp0

; r1

xor r1, rp0

; rp0 OR r1

rtr r1
nor rp0, r1
nor rp0, rp0

rtr r1
nor rp0, r1
nor rp0, rp0

rtr r1
nor rp0, r1
nor rp0, rp0

rtr r1
nor rp0, r1
nor rp0, rp0

rtr r1
nor rp0, r1
nor rp0, rp0

rtr r1
nor rp0, r1
nor rp0, rp0

rtr r1
nor rp0, r1
rtr r1

; pointer

inr rp1
rtr rp1
rtr rp1
rtr rp1
rtr rp1
rtr rp1
zro r2
zro r2
zro r2

; print

prt r1

; jump

jmp

What is 10IPL?

10IPL, short for 10 Instruction Programming Language, is a simple compiled language I made for use in a computer I'm building in Minecraft. I made an online interpreter for it (with a few extra features), since I think it's a neat language.

How does this work?

This program consists of a few parts:

1. Take input
2. Set rp0 (the upper 8 bits of a pointer) to either 00000000 (if the input is truthy) or 11111111 (if the input is falsy)
3. Set rp1 (the lower 8 bits of the pointer) to point to the prt instruction after it
4. Print the inputted value
5. Jump to the pointer

This will jump into a few KiB of zeroed out RAM if the input is 00000000, then terminate. Otherwise, it keep going forever. Don't try it online.

dotcomma, 8 bytes

[,].[.,]

Try it online!

Dotcomma is a language I recently invented, designed to do things in an interesting way with as few instructions as possible. In order to accomplish this, there are two operators (predictably . and ,) which can do entirely different things depending on context. This answer's explanation will be very introductory. To see some more complicated code, check out the examples in the page linked in the title.

This program is actually a pretty neat showcase of some of the more interesting features of dotcomma. You'll notice it's divides into two main parts, [,] and [.,], separated by a .. These are called blocks. Every block and operator has a return value.

The way dotcomma manages to do so many different things with each operator is by changing what they do based on what precedes and follows them. Take the , in the first block. Because it is at the start of a block, its return value will be a value taken from input. Because it is at the end of a block, it will also output this value and use it as the block's return value. Surprisingly compact for a language with four valid characters!

As for the first ., because it is preceded by a block, it will take the block's return value and use it as its own. It is followed by another block, so it will do one two things: if its return value is 0, the block will be skipped. Thus, only 0 will be outputted and the program will terminate.

However, if its return value is 1, the block will be looped. Within the block are two operators: .,. The . will have a return value of 1, as it follows the beginning of a block. The , will behave similarly to the first one, but instead of taking the number to be outputted from input, it will take it from the . (which will always be 1). The loop will run forever because the , will always set the looped block's return value to 1.

Hopefully this explanation isn't too confusing!

Pari/GP, 26 bytes

i=input;until(!i,print(i))

Try it online!

Add++, 7 bytes

+?
Dx,O

Try it online!

StupidStackLanguage, 5 bytes

htxux

Try it online!

Desmos, 33 bytes

n->ni+1,o->[1...n]0+i
i=0
o=0
n=0

The top line goes in a ticker, while the other lines are regular equations.

The input goes in variable i, while the output is shown in variable o.

Press the ticker (metronome icon) to start running the code.

Try It On Desmos!

Explanation

n->ni+1: If i=0, it becomes n->1, so n will always stay at 1. If i=1, it becomes n->n+1, so n will infinitely increment by 1.

o->[1...n]0+i: [1...n]0 creates a list of zeroes with length n. As shown with n->ni+1, if i=0, the length will always stay at 1; otherwise, it will keep increasing. +i simply converts the list of zeroes to a list of i's. So in summary, if i=0, then the list stays at length 1 and is populated with 0's. If i=1, then the list length is always increasing and is populated with 1's.

The rest of the code: It is simply to define the variables used in the actions above.

AHHH, 24 bytes

AHHHHhHHhhHHHHHHhhHHhhhh

AHHH is a somewhat more capable BF derivative in which every program consists of screaming.

Try it online!

Explanation

AHHH  Begin program
HhHH  Read int into current cell
hhHH  Write current cell's value as int
HHHH  Loop while current cell is not zero
hhHH    Write current cell's value as int
hhhh  End loop

APOL, 34 16 bytes

My original version was written back when I first made APOL and used none of the newer convenience instructions.

¿(⧣ w(T p(1)) 0)

Explanation

¿(          Returning if
  ⧣         Integer input (used as condition, 0 evaluates to false)
  w(T       While true (true condition)
    p(1)    Print 1
  )
  0         A literal 0 (false condition)
)
Implicit print (¿ returns 0 if input is 0)

Batch, 28 bytes

:1
@Echo(%1&Goto:%1
:0

uses input as output and script flow controller.

Brainfuck, 27 25 23 bytes

,.[-[->>]<++<]>>>[+[.]]

I ran it here (Uses negative cells, get around this by adding a << to the beginning)

I used modulus 2 instead of subtracting 48 to differentiate 0 and 1 which cuts down some characters. I also copied and did modulus at the same time.

Old answers:

,.[->+>+<<]>[-[<<]>[.]>-]

,.[->+>+<<]>[-[>>]>[.]<<<-]

INTERCAL, 41 bytes

Based on answer by @unrelatedstring. If you don't care for errors, won't you guys golf off the program easily?

DOWRITEIN.1DOCOMEFROM.1(1)PLEASEREADOUT.1

Try it online!

BASH

read a; [ $a -eq 0 ] && echo 0 || ( [ $a -eq 1 ] && while true; do echo 1; done ) 

Pure Bash, 32 + 1 = 33 bytes

The 1-byte penalty is for filename specification; the following program must be saved as x.

((x))||read x
echo $x
((x))&&. x

Try it online!

Tracing how it works

• The variable x is not initialized.
• ((x)) evaluates to ((0)): command is failure.
• So read x is done.
• Then echo $x.
• Final line is for branching.
  • If x is zero, the program ends.
  • If x is one, . x is done.
    • It loads the file x: the program itself.
    • First command evaluates to ((1)) so no more reading.
    • Then rest two lines are executed and it loops forever.

ErrLess, 12 10 bytes

Thanks to Aaroneous Miller for saving 2 bytes

q@#@8*1-[.

No newlines/spaces.

Explanation

q     { Input a number a number, `n` }
@#    { Output `n` }
@8*1- { Push `8*n-1` to stack (7 for 1, -1 for 0) }
[     { Jump backwards by that many instructions }
      { Goes to right after input for 7, just before halt for -1 }
.     { Halt }

ErrLess is a stack-based language I made for fun over the last few months. You can read the docs here, and I also started a tutorial.

Try it online!

Pure CPython 3.10 bytecode, 6 bytes

"Pure" means no constants and no names are allowed. As a result, the only method of input is by starting with values on the stack.

...and Python bytecode's only way to jump backwards (and therefore the only way to loop) uses "absolute" addressing, so my code assumes it is placed starting at instruction offset 3 (byte offset 6).

Hex of code: 04 00 46 00 70 03

Disassembly of code:

    >>    6 DUP_TOP
          8 PRINT_EXPR
         10 JUMP_IF_TRUE_OR_POP      3 (to 6)

Takes an integer on the stack. The easiest way to put 0 or 1 on the stack is:

          0 LOAD_ASSERTION_ERROR
          2 BUILD_TUPLE              X
          4 GET_LEN

Change X to 0 or 1. In hex, this is 4a 00 66 00 1e 00 (for 1) or 4a 00 66 01 1e 00 (for 0).

This will crash the interpreter for an input of 0 due to a buffer overflow. If this is not acceptable, add 2 bytes (append 53 00 (RETURN_VALUE)).

Attempt This Online! (0)

Attempt This Online! (1)

I'm going to use this opportunity to explain how CPython bytecode works. It's just an array of bytes, which are in opcode, oparg pairs.

For example, (hex) 01 02 03 04 is instruction_01(arg=02); instruction_03(arg=04).

The list of instructions is given in the documentation for the standard library dis module, although you sometimes need to dig about in Python's ceval.c to see exactly how they work.

In Python, bytecode is contained in a code object, which carries some metadata like source file lines, but the most important things are an array of constants (co_consts) and an array of names (co_names). In order to load a literal value, it must be loaded from co_consts; in order to lookup a global variable, its name must be in co_names. When I said I'm using "pure" bytecode, I mean that these arrays are both empty - so I can't use any literals (integers, strings, tuples, etc.), and I can't use any global variables, builtins, imports, or even look up any attributes. This allows an extremely minimal wrapper script (see the ATO link).

This leaves me with only PRINT_EXPR for output (or leaving a value on the stack), and no input at all other than taking a value already on the stack.

The truth machine is actually the easy part of this code, to be honest: it's essentially do { print x } while (x).

Loading an integer is a bit more involved: first I use LOAD_ASSERTION_ERROR to put a value on the stack. What value it is doesn't particularly matter, but this is one of only a few instructions I'm aware of that can load an object without any consts.

Then I use BUILD_TUPLE(1) to make the tuple (AssertionError,), and take its length with GET_LEN which is 1. To load 0 is a bit simpler: you only need

          0 BUILD_TUPLE              0
          2 GET_LEN

Although you can perfectly well leave the LOAD_ASSERTION_ERROR before that, to conveniently switch between loading 0 and 1.

Sidenote

GET_LEN is new in Python 3.10, so a historic method would have had to involve boolean <-> integer conversion, which is a bit more interesting IMO:

          0 LOAD_ASSERTION_ERROR
          2 DUP_TOP
          4 IS_OP                    0
          6 DUP_TOP
          8 BINARY_MULTIPLY
         10 PRINT_EXPR

This performs AssertionError is AssertionError, which is True. Then it does True * True to get the integer 1.

IS_OP(0) can be replaced with IS_OP(1) to do AssertionError is not AssertionError, which gives False, which gives 0.

Hello Hell, 34 bytes

[+^-/>]!*/*/>[+^>][+-/<]-/<[{*+}/]

Try it Online!

The first program in my new language - Hello Hell! For information on the commands, memory model, etc. check out the repo.

Explanation:

[+^-/>]                             # Set the first 6 cells to 0
       !                            # Input
        */*/                        # Set the cell to 0 or 49 depending on input
            >[+^>]                  # Move to the 13th cell
                  [+-/<]-/<         # Set cells 8-13 to 0
                           [{*+} ]  # If 1, loop forever,
                                /   #  otherwise print 0

Python 3, 35 34 bytes

def l(i):
 if i:print(i);l(int(i))

Older python 3.8 only code

i=input()
while i:print(i:=int(i))

Try me!

Explination:

While this ties the best python 3 answer thanks xnor for saving me a byte

This uses a few interesting properties to achieve what it does:

1. The input received is always a string when from a user input, thus the while-loop will start regardless if its a 1 or 0

2. Inside the loop, we print the number for the first time, and simultaneously using the walrus operator which was introduced in python 3.8, we assign the integer value to i. Using recursion, this code can now work in all versions of python 3, while it isn't a major improvement in bytes count, I'd still count making the code work in more versions an improvement!

3. Now, the value, if zero, is now converted from "0" to 0, meaning the loop will exit, otherwise if its 1, it keeps going!

I have tried hard to get lambdas to work, but every attempt ended up with more lines due to having to use recursion, if anyone has any ideas I am all ears! Meanwhile I will try to keep pushing this, the new version feels like it has more that can be pushed

Clam, 11 8 bytes

p=QrwQpQ

Try it online!

-3 bytes thanks to the Q global variable

Storing variables is a tad verbose in Clam...

Explanation

p=QrwQpQ
p            Print..
 =             Assignment..
  Q              Global variable Q
   r             Read next line of STDIN (automatically parsed to int if possible)
    w        While..
     Q         Q is truthy
      pQ         Print Q

Resulting JS code:

console.log(Q = arguments[0]);
while(Q) {
    console.log(Q);
}

Braingolf, 5 bytes

[!_];

Try it online!

Explanation

[!_];   Implicit input
[..]    Do-while, run once and loop while top of stack is >0
 !_     Print top of stack without popping
    ;   Prevent implicit output

Unlambda, 15 bytes

``c``@?1i `c`|i

Try it online!

Arduino, 133 129 117 bytes

Thanks to @tail spark rabbit ear for shaving off 12 bytes!

#define S Serial
int x=0;void setup(){S.begin(300);}void loop(){S.available()&&S.print(x=S.read()-48);x&&S.print(1);}

Arduino is basically C++, but with this bit implied:

int main() {
  setup();
  while (true) {
    loop();
  }
  return 0; // to make the compiler happy, I guess
}

The setup() and loop() functions must be implemented.
Explanation:

#define S Serial /* macro to make referencing the Serial monitor shorter */
int x = 0; // must either be global, or declared `static` inside `loop()`

void setup() {
  S.begin(300);
  // The argument to Serial.begin() is the baud rate
  // 300 is the slowest supported option, but therefore takes the fewest bytes
}

void loop() {
  S.available() &&
    // Serial.available() returns truthy when there are unread bytes from the serial input
    // Using && as a shortcut for an if statement (like minified JS)

    S.print(
      x = S.read() - 48
    );
    // Serial.read() dequeues the next byte from the input
    // 48 is ASCII '0'
    // Serial.print() converts 0 back to "0"; Serial.write() wouldn't

  x &&
    S.print(1);
}

As loop() is called indefinitely, it's impossible to terminate, so inputting "0" settles into a loop that prints nothing until something else is input.

Original:

int x=0;void setup(){Serial.begin(300);}void loop(){if(Serial.available()){x=Serial.read()-48;Serial.print(x);}if(x)Serial.print(1);}

Perl -p, with the following restrictions ppencode, 15 bytes.

• Use only keywords with lowercase alphabets only
• Separate each of them with just a space

print while sin

Try it online!

How it works

• sin(0) is zero
• sin(1) is not zero
• -p is for implicit I/O for line by line

Alternatives

sin can be replaced with one of following keywords:

abs int oct hex

n/t/roff, 27 bytes.

.de a
\\$1
.if \\$1 .a 1
..

Defines a macro a.

Usage

.a 0
.a 1

Try it online!

Flipbit, 10 bytes

?>>>>>.[.]

Try it online!

Nim-Lang, 72, 64, 49, 41 (credits to @hyper-neutrino and @Jo King) bytes

var a=readChar(stdin)
while a=='1':echo 1
echo 0

Version with if-statement, with suggested edits:

if readChar(stdin)=='0':echo 0
else:
  while true:echo 1

Mascarpone, 18.125 bytes

['1.:!]v*['0.]v*1[:!]v*'1<,>!

Try It Online!

I'm surprised to see so few Mascarpone answers even on the big questions like this. It's a shame, it's such a beautiful language even if it is a bit of a tarpit.

Dis, 49 bytes.

}{*|*^__________!||_^_____________*{___^___****!*

Usage

• Input from STDIN, as an ASCII number character.
• Output to STDOUT, in ASCII.

With comments

(
0: }{*|*^
'*'+1: ****!* 

'*'+1: * changed to 48-42or49-42 by |:
   12 10t - 11 20t is 01 20t is 15
   12 11t - 11 20t is 01 21t is 16 

'*'+2: * for * command 

'*'+1: 15or16 for ^ 

15+1: ! reaches when zero
16+1: ||^ reaches when one 

obtw '*'+3: * and '*'+4: * are for | to have the register A have 49 again 

'*'+5: ! for ^ 

After that '*'+4: '1' BUT whatever 

'!'+1: *{___^ repeatedly output one 

* 42 ! 33 

) 

(
0123456789 0123456789 0123456789 0123456789
)
}{*|*^____ ______!||_ ^_________ ____*{___^
(
0123456789 0123456789 0123456789 0123456789
)
___****!*

Try with 0!

Try with 1!

yuno, 4 bytes

ᴀ_¹¿

Try it online!

Or, using the flag to disable implicit output:

yuno d, 3 bytes

ᴀ_¿

Try it online!

Explanation

The W flag caps output at 10,000 characters just so it doesn't freeze your browser window for too long.

ᴀ_¹¿    Main Link
   ¿    While
  ¹     The element is truthy
ᴀ_      Output it
        <Implicitly output the value>

ᴀ_¿     Main Link
  ¿     While
ᴀ_      Output the element, then assess if it's truthy
        <d flag disables implicit output>

Brain-Flak, 6 bytes

{(())}

While the top of the stack is non-zero, push 1. Input to the stack is implicit, and output would also be, but if the program doesn't halt, nothing is outputted. However, one is continually pushed onto the stack, and it's the closest Brain-Flak can get to infinite output.

Try it online!

Squire, 47 bytes

x=inquire()whence l proclaim(x+" ")if"0"!=x{l:}

Whilst some languages have a goto keyword, Squire useth whence, the opposite. One might call it a comefrom. Squire also containeth a normal loop with whilst, but alas, it is impossible to useth this without enscribing proclaim twice.

If we accompany whence with if, we can create a loop that some call do-whilst.

Ungolfeth:

# Inquire a line from ye standard input
x = inquire()
# Set a whence point
whence loop
# Proclaim x, followed by a space, to ye standard output
proclaim(x + " ")
# If x is not "0"
if "0" != x {
    # Loopeth ad infinitum
    loop:
}

Methinks this language is ridiculous. 😂

sed, 13 bytes

:l;s/1/1/p;tl

Try it online!

Ocaml, 46 bytes

let a=read_int()in while print_int a;a=1 do 0

urk the functions name and the control flow takes a lot of chars. The trick since there is no do-while is to put the print directly in the condition (sometime ago when I did that in a course lab, the teach called me a "connoisseur of monstrosities" (approx tl))

The 0 in the end causes a warning, so you need to disable werror.

Red, 28 bytes

func[a][until[prin a a = 0]]

Try it online!

Makes use of the fact that until will always execute its block at least once. The loop will only terminate if the argument passed to the function is 0, otherwise it will keep printing forever.

Piet, 12 codels

Codel size 16:

Instructions:

INN
DUP (start)
DUP
OUTN
PTR (back to start if 1; continue if 0)
POP

It has the following behavior for other values:

• if n % 4 == 1, print n forever
• else, print n once and terminate

if n % 4 == 2, there will be a stack underflow error, as the code path is as follows:

INN
DUP 
DUP
OUTN
PTR
SWITCH (empties the stack)
PTR (error)
POP (error)

2D Deadfish, 7 bytes

(o^)>o<

It is a new 2D esolang based on Deadfish~ I made recently. Read more on it in the link in header.

Explanation

IP starts at the beginning with direction right. Statements inside parentheses is only executed if accumulator is 0. And input is set to the accumulator, or else 0.

So if you give input 0,

• Parentheses block will start
• o will output accumulator (which is 0)
• ^ will change direction to up
• It will eventually hit EOF token
• And terminate soon!

And for input 1,

• Skip the parentheses and jump to >
• > changes direction to right (It keeps moving right)
• o outputs accumulator (which is 1)
• < changes direction to left (back)
• o outputs 1 again
• > changes direction to right
• IP dances and repeats outputting 1

How to run it?

No online interpreter for now. but coming soon.

Until then clone the repo, and run interpreter.py. It will prompt you for the program first. When done typing program, hit CTRL+D (linux) or CTRL+Z (windows). And provide your input (if you don't want to give keep it blank) and hit enter. The program will start to run.

Barrel, 10 bytes

This makes use of the fact that the input will be only 0 or 1:

λn?a:#∞n

Explanation:

λ        // input into the accumulator
 n       // print the accumulator
  ? :    // if-else statement (auto-closes to '?a:#∞n::')
   a     // if the accumulator evaluates to truthy (i.e. non-zero)...
     #∞  // ...loop forever...
       n // ...implicitly print the accumulator...
         // ...else do nothing

In other news, I really should make a custom charmap for barrel. With a custom charmap, I could shave off 3 bytes.

Knight, 13 11 bytes

New method with suggestions from the language's author:

I+0P W1O1O0

Try it online!

# Read a string, coerce to number by adding 0, and check if non-zero
: IF (+ 0 PROMPT) {
    # if it was non-zero, loop printing 1 forever
    : WHILE 1 {
        : OUTPUT 1
    }
    # else output 0 and exit.
    {
        : OUTPUT 0
    }

Old version which I wrote on my own:

;=wP;W+0wO1O0

There are a few ways to do this. Decided this way because of a certain theme.

Ungolfed version:

# Read string into input
; = input PROMPT
# Coerce input to a number by adding 0, and loop while not 0
; WHILE (+ 0 input) {
    # Output 1 and a new line
    : OUTPUT 1
    # this is an infinite loop
}
# Otherwise, output 0 and a new line, and quit
: OUTPUT 0

If we allow excess newlines, this is an arguably superior program:

;=wP;W+0wOwOw

However, this prints two new lines because PROMPT includes the trailing newline. 😔

Stax, 4 bytes

Wq|c

Run and debug it

W    - loop over rest of program forever
 q   - print without popping, with no newline
  |c - exit if value at the top of stack is truthy without popping

Subleq (8-bit), 15 bytes

-1 15   3
15 16   6
15 -1 -48
16  8  -1
15  8   6

Explanation

• 0: -1 15 3 Input character to 15:, goto 3
• 3: 15 16 6 16: = 16: - 15: (16: = -15), goto 6
• 6: 15 -1 -48 Output 15: (-48 is unused in instruction and used for memory)
• 9: 16 8 -1 8: = 8: - 16: , if 8: <= 0 exit; exit for all characters "0" and before
• 12: 15 8 6 8: = 8: - 15: (back to -48), if 8: <= 0 goto 6

Starry, 16 bytes

, +'. '` +. +' `

Try it online!

Pretty simple, it reads the input onto the stack, if it's zero, it prints it, and if it's non-zero, prints it forever.

Duocentehexaquinquagesimal, 2 bytes

RÃ

Try it online! Takes input as a character, and outputs in unary using characters.

Vyxal, 4, 3 bytes

-1 thanks to @Aaron Miller (uses implicit input for the 1s)

[{₴

Try it Online!

Pxem, 0 bytes (content) + 13 bytes (filename).

Filename is:

._.c.n.w1.o.a

Try it online!

As verbose pseudocode

push numeircal integer input
dup
unless empty: printf "%d", $(pop)
while one of
  1. empty
  2. $(pop) != 0
do
  push "1", a character
  unless empty: printf "%c", $(pop)
done

CASL II, 72 bytes.

Tested here.

A START
 IN B,1
D OUT B,1
 LAD GR1,48
 XOR GR1,B
 JNZ D
 RET
B DS 1
 END

If you are familiar with assembly languages, you would get it well. It uses standard i/o. It uses ASCII-compatible encoding.

CSASM v2.3.1, 54 bytes

func main:
in ""
conv i32
.lbl a
dup
dup
print
brtrue a
ret
end

Explanation:

func main:
    ; Get the input and convert it to an integer
    in ""
    conv i32

    .lbl a
        ; Duplicate the input twice
        ; Both the "print" and "brtrue" instructions pop a value from the stack
        ;   so this is necessary to keep a 1 on the stack when looping
        dup
        dup
        print

        ; Truthy values are a non-zero integer or a non-null object
        brtrue a
    ret
end

Pinecone, 41 bytes

n:"".input;n="1"?(tru@print:1)|(print:0)

V (vim), ¹⁸ 13 bytes

xqqp/1
@qq@qx

Try it online!

Somehow, there was no existing vim answer for this. I was happy to oblige.

-5 bytes from Aaron Miller.

Explanation

xqqp/1
x      delete the input char 
 qq      start macro q
   p     paste the input
    /1   find 1 (exits if 0 isn't matched)

@qq@qx    
@q       recursively call macro q
  q    end macro q
   @q  call macro q
     x delete last char (never gets executed in the case of 1)

Grok, 10 bytes

:}1j
z}zhq

Explanation:

:}      # If input is 0, goes down and to the left, outputs 0, 
z}  q     wraps to the right, and terminates.

:}1j    # If input is non-zero, goes to the right, pushes 1,
 }zh      prints 1, and loops indefinitely.

Python - 40 bytes

a=int(input())
while a:
  print(a)
print(a)

This is simple but effective. A fun thing about this is that while we could put a condition that a==1 in, this is more fun because it reuses a, and a will be 1 causing the loop to run forever (works with any a != 0)

Turing Machine Code, 32 22 bytes

Using the rule table syntax found here.

0 0 0 * halt
0 * 1 r 0

x86_16 machine code - 20 bytes

3E A0 82 00   MOV AL, DS:[82H]
8A D0         MOV DL, AL
          _LOOP:
B4 02         MOV AH, 02H
CD 21         INT 21H
80 FA 31      CMP DL, "1"
74 F7         JZ _LOOP
             
B8 00 4C      MOV AX, 4C00H
CD 21         INT 21H

Tested in DOSBox :

Input 0

Input 1

If input 1 gives infinite loop

Python 3, 47 bytes

Not a winner, but I like the method.

set(iter(lambda x=input():(print(x),x)[1],'0'))

Try it online!

Built-out, 5 bytes

truth

Yay, built-ins! ...just kidding.

Before running: push input to stack 2

truth

t      - not last 't': swap stacks 1 and 2
 r     - convert character (1-9) at top of stack 1 to integer
  u    - toggle EOF loop if top item of stack 1 is falsy (0)
    h  - duplicate top of stack 1
       - implicit: pop item of stack 1 if not empty, then go to previous 't' if stack 1 is still not empty AND 'u' did not toggle it off, terminate otherwise
   t   - last 't': return here if stack 1 is not empty

Try it online! (fork the project)

v³, 6 bytes

;@=.$#

Unwrapped:

  ;
@ = . $
  #

The IP starts at the top cell. ; takes the input as a numeric value. The IP then falls to =, printing the value. It hits ground (#) and starts moving to the right. . is a no-op. $ ignores the next command if the value is not zero. The IP wraps around to @, which terminates the program. The program repeats from = if it hasn't terminated.

convey, 10 bytes

{,!"}
 >"^

Try it online!

There's a few ten-byters i've found, but I can't see any way to get lower. I was thinking of this. but unfortunately that doesn't parse.

BRASCA, 11 bytes

x48S-:n[:n]

Explanation

<implicit input> - Take input from STDIN
x                - Clean up the linefeed from STDIN
 48S-            - Remove 48 from the digit's ascii code
     :n          - Output the number
       [:n]      - While non-zero: Output the number

Language Link

Github Repo

Python 3, 35 bytes

n=input()
while 1:print(n);0/int(n)

05AB1E, 3 bytes

i[?

Try it online!

i[?  # full program
i    # if...
     # implicit input...
i    # is 1...
  ?  # output...
     # implicit output...
  ?  # without trailing newline...
 [   # forever
     # implicit end loop
     # implicit end if
     # implicit output

Fugue, 120 bytes

00000000: 4d54 6864 0000 0006 0001 0002 0001 4d54  MThd..........MT
00000010: 726b 0000 002b 0090 4040 0290 3e40 0190  rk...+..@@..>@..
00000020: 3a40 0090 4040 0190 4740 0190 4340 0090  :@..@@..G@..C@..
00000030: 4440 0190 3e40 0190 3740 0190 3740 00ff  D@..>@..7@..7@..
00000040: 2f4d 5472 6b00 0000 2f00 9040 4001 9037  /MTrk.../..@@..7
00000050: 4001 903f 4001 9040 4002 903c 4000 9044  @..?@..@@..<@..D
00000060: 4001 903e 4002 9045 4001 9046 4001 904e  @..>@..E@..F@..N
00000070: 4001 9047 4000 ff2f                      @..G@../

Since the Fugue compiler does not support voice wrapping, a direct translation of Martin Ender's Prelude answer turns out to not be the shortest possible solution. This program is equivalent to the Prelude program:

 v6(1-)#
?!^ 8- (^!)

See my Hello World answer for more information on how to use the compiler. Finally, here's a valid MIDI version of the program:

00000000: 4d54 6864 0000 0006 0001 0002 0001 4d54  MThd..........MT
00000010: 726b 0000 002c 0090 4040 0290 3e40 0190  rk...,..@@..>@..
00000020: 3a40 0090 4040 0190 4740 0190 4340 0090  :@..@@..G@..C@..
00000030: 4440 0190 3e40 0190 3740 0190 3740 00ff  D@..>@..7@..7@..
00000040: 2f00 4d54 726b 0000 0030 0090 4040 0190  /.MTrk...0..@@..
00000050: 3740 0190 3f40 0190 4040 0290 3c40 0090  7@..?@..@@..<@..
00000060: 4440 0190 3e40 0290 4540 0190 4640 0190  D@..>@..E@..F@..
00000070: 4e40 0190 4740 00ff 2f00                 N@..G@../.

Prelude, 6 bytes

Prelude is a bit tricky here. The language specification says I/O is via characters' byte values. That's what the C implementation does. Then there's the Python interpreter, which uses bytes for input but prints decimal integers. And then there's my own fork of that interpreter which does both input and output numerically (which I've published a few months ago). Since languages on PPCG are defined by their implementations, all of these constitute valid Prelude variants.

My fork gives the shortest solution at 6 bytes:

?(1!)!

? pushes the input. (...) is a Brainfuck-style while loop, which is skipped for 0 input. Then ! prints the zero. If the input was 1, we enter the loop, push another 1 and print that with ! (we need to push a new 1, because ! pops the top of the stack).

Next up is the original Python interpreter at 14 bytes:

?6^+^+^+-(1!)!

Since output is the same as in my fork, all we need to do is map the character codes to 0 or 1 which we do by subtracting 48. There are several ways to get 48 in 7 bytes, but I don't think it's possible to do it in less. This one pushes 6 and then doubles it 3 times, by duplicating it with ^ and adding the two copies with +.

Finally, the solution that works with the original C interpreter needs 16 bytes:

?^(#^!^6^+^+^+-)

This one has a slightly different structure. Since we also need to output 48 or 49 respectively, we now remember the input and obtain the 0 or 1 only for the loop condition. This also let's us get a way with a single ! because we can easily turn the loop into do-while. Again, ? reads the input and ^ makes a copy which we only need because the first thing in the loop is #, which discards the top of the stack (we need this to discard the condition from a previous iteration). Now ^! prints a copy of the input. Then ^6^+^+^+- computes input - 48 as before. If that is 0, we leave the loop immediately and exit after printing a single number. Otherwise, the loop will keep going, printing the input 49 each time.

NDBall, 57 chars, 8 cells in 2 dimentions

(0)>0
(1)%
(2)Y[1,>0,>1]
(3)P
(4)E
(2,1)>1
(2,2)P
(2,3)<1

Visual representation of code (hand made by me)

Checked in NDBallSim V1.0.1

MarioLang, 25 bytes

   >:<
   "==
 ;[!:
===#=

Acrostic, 89 45 bytes

-44 bytes by running the initial input command backwards to output the zero (thanks Jo King for the idea!).

     R
DOUBLE
  N  A
PROVIDED
R
I
NIL
T
END
D

Try it online...? (This esolang has no official online interpreter; that link takes you to a repl.it link with my own unofficial Python interpreter loaded in, complete with the truth machine program. If I can find/make a more proper online interpreter, I'll link that instead.)

Acrostic is an esolang designed by Mercerenies for which programs take the form of crosswords, which are traversed word-by-word during program execution.

First, END is run backwards, which starts the program. PRINTED is then run backwards, which will take a numerical input and push it onto the stack. If the top of the stack is 0, the PROVIDED branch is not taken, and instead NIL is run (which does nothing). Because there are no other words to run from there, PRINTED is executed forwards, and then END is executed, ending the program. If, however, the top of the stack is nonzero, the PROVIDED branch is taken, READ is run backwards (outputting the number), DOUBLE is executed backwards (pushing -2), UNO is executed forwards (pushing 1), and PROVIDED is executed (because the top of the stack is nonzero), looping this section forever.

It took me much trial and error to get an Acrostic truth machine this short, though IMHO it is a very clean and compact example. If only this language were easier to golf...

Poetic, 137 bytes

TRUTHFUL MACHINE
A:I=true,O=false
B:get a number or get a value
C:if falsy,a zero
D:if truthy,a one
D.a:repeat it if value=I
E:suspend it

Try it online!

sed 4.2.2, 8 bytes

Uses the -n flag to suppress printing without an explicit p command.

:
p
/1/b

Try it online!

Commented:

#create an unnamed label
:
#print pattern space
p
#If pattern space contains 1, branch to beginning
/1/b

Arn, 4 bytes

“l○|

Explained

Unpacked: &&[{1

Takes advantage of the fact that Arn's interpreter is written in Javascript. This means the && and || operator can be used as control flow.

  _     % Variable initialized to STDIN. Implied
&&      % Boolean AND
  [     % Sequence
    {   % Block; used to calculate future entries in a sequence
      1 % Literal one
    }   % End block. Implied
  ]     % End sequence. Implied

1+, 10 bytes

."#:[#":1#

Yay for comment abuse in a normal challenge (instead of a source-layout or polyglot one)! In 1+, the [ character that begins a comment is actually an instruction so it can be skipped with the goto command #.

For input 0:

.          Take input
 "#        Jump to the 0th hash tag
   ：      Output 0
    [      Comment the rest of the program out

For input 1:

.          Take input
 "#        Jump to the 1th hash tag
     #     The 1th hash tag
      ":   Duplicate and output
        1# Jump to the 1th hash tag

I can replace the 1 with " as well so that we get a 1+ program without a 1 instruction... Wow!

Naive solution, 14 bytes

.1##":"1+1<1+#

A simple do-while loop.

Turing Machine Code, 19 29 19 bytes

0 0 * * h
0 * 1 r 0

Try it online!

Saved 10 bytes thanks to @Laikoni

RAKIAC machine language, 6 bytes (34 real for asm)

00000100
00000011
00110100
00100001
00000001
00000010

Representing the assembly:

in
s: out
jez v
jmp s
v: hlt
end

Tried out one of my things for fun (definitely not made for golf).

Python3, 40Bytes

a=input()
while int(a):print(a)
print(a)

• If input is 0 it will be printed once.
• If input is 1 it will be printed forever.

AWK, 17 bytes

{while($0)print}1

Try it online!

Comp, 6 or 8 bytes

The first golfing language (sort of :) ) from 2020!

;{^&}&

That could be a mistake. An alternative program is:

;{^£}£

Explanation

;      Take an input from the console as an integer
 {^£}  While that's nonzero, duplicate & print
     £ If that's zero, directly print

Wren, 55 bytes

Fn.new{|x|
while(x){
System.print(x)
if(x==0)Fn.x()
}
}

Try it online!

Explanation

Fn.new{|x|      // As usual, new anonymous function x
                // Newline as we are entering statements, not an expression
while(x){       // While the input x is true:
                // (Everything other than false, the null string, and the
                // empty list is true)
System.print(x) // Output x to the console with a newline
if(x==0)Fn.x()  // If the input is 0 then exit the program
}
}

Shakespeare Programming Language, 123 120 bytes

(Whitespace added for readability)

T.Ajax,.Puck,.Act I:.Scene I:.[Exeunt][Enter Ajax and Puck]
Ajax:Listen tothy.Open heart.
     Am I worse you?If solet usAct I.

Try it online!

I make use of a trick to reuse Scene I. For some reason, it doesn’t error to keep taking input, so I do that. Then I just compare the input to zero, and loop if it’s greater. Saved 3 bytes by comparing to I instead of zero because characters initialize to zero—thanks Robin Ryder!

JavaScript, 39 32 Bytes

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

x=+prompt() gets input from user, and transforms it from a string to a number

do{alert(x)}while(x) is a post test loop, so it always alerts X, then executes again if x not = 0

tq, 3 bytes

?(?

Explanation

?,   # Take an input
  (? # Extend the array while
     # the input is not false

W s, 1 byte

The s flag forces a read from STDIN. This flag can be appended to the end of the command-line.

w

No, I didn't just make a built-in for the question.

Here is the expanded program (because w requires two inputs)

aaw

This decodes into:

mywhile(a[0],'a[0]',a)

Which means:

while a[0]:
    print(a[0])

The print is implicit in every while iteration. Since a[0] is always 1 once it is defined as 1, this will print 1 forever (the body is the same as the condition).

So you might say that this prints nothing if the input is 0. You are wrong, the w instruction returns the condition 0 after the while statement is done. Therefore it gets returned and gets outputted.

W s, 4 bytes

W was designed to be very powerful so that while loops are unneccecary. This program avoids this at the cost of being significantly longer. (Please don't use the while loop (which is simply for presentation purposes) in your W programs. Thank you.)

ibE&

Explanation

   & % Perform logical AND between the input and the code block.
     % If the input is 1, execute the following code block:
i E  %     Count to infinity,
 b   %     Printing the input in every iteration
     % Otherwise (part of the AND logic):
     %     Return 0, exit the program.

Python 3, 35 bytes

a=input()
while a:a=int(a);print(a)

This is the best I can do, don't know if it's the optimal solution though.

Explanation

In Python 3, input() stores the input as a string, so even if the user types 0, it will be stored as '0', which is truthy. This allows me to make a kind of do-while loop, which will always run at least once since '0' and '1' are both truthy. However, I then convert a to an integer ('0' becomes 0 and '1' becomes 1). Now, if the user typed 0, it will not run again since the while loop is now while 0 and 0 is falsy. However, if the user typed 1, it will run forever since the while loop is now while 1 and 1 is truthy.

Keg, 12 8 7 4 bytes

{:|④

Try it online!

Explanation

# Implicit input
{:|  # While the duplicated item is nonzero:
   ④ # Output the item without popping
     # After that, Output the item remaining on the stack and stop the program

Gaia, 3 bytes

:p↺

Try it online!

Explanation

  ↺  While...
:    Duplicating the top of stack leaves a true value on top:
 p   Print the top of the stack

Input is taken implicitly in Gaia. Every iteration leaves the stack empty, but if there is no input left when it attempts to grab some, it simply takes the most recently given input again.

Jasmin, 355 321 bytes

As with the other answers I've written in Jasmin, there isn't a whole lot of golf going on here. This code is (almost) exactly the code obtained from running javap on the class file generated by intrepidcoder's java submission. The one neat golfing trick I found was avoiding the usual .limit locals line by reusing local variable 0.

Some code golf four years later

1. Shorten the invocation of print by extending PrintStream
2. ldc 2 is shorter than iconst_2
3. Manipulating the stack with dup and swap is shorter than using locals variables with iload_0 and istore_0.

After these changes, the compiled class file needs to be executed with java -noverify.

.class L
.super java/io/PrintStream
.method public static main([Ljava/lang/String;)V
.limit stack 4
getstatic java/lang/System/out Ljava/io/PrintStream;
getstatic java/lang/System/in Ljava/io/InputStream;
invokevirtual java/io/InputStream/read()I
ldc 2
irem
dup2
invokevirtual L/print(I)V
dup
ifgt $-5
return
.end method

MathGolf, 5  4  3 2 bytes

-1 for dropping block marker

q▲

Explanation

Implicit input
Starts a block
q  Output TOS without a newline.
 ▲ Execute the code block while the TOS is true. Executes at least once.
Implicit output

Try it online!

Cascade, 10 bytes

?1/
#?
&#|

Try it online!

My first submission with my new language Cascade! Cascade is a tree-like esolang, similar to Pyramid Scheme, but a bit terser and with wrapping boundaries. Ungolfed, this looks more like:

 @ |
 ? /
 #|
 &|
  ^
 # |
 1 |

First, the ? checks if the printed (#) input (&) is positive. If not, it goes left and terminates since it finds no more instructions. If so, it goes right to the ^, which first executes the left (#1, print 1), then goes to the right, which wraps around back to the ^ for an infinite loop. In the golfed code we use another ? which does a similar thing except with the center and the right, since we know the return value of # is always positive.

Verbosity v2, 290 bytes

IncludeTypePackage<OutputSystem>
IncludeTypePackage<InputSystem>
IncludeStructurePackage<Loops>
input=InputSystem:NewInput<DEFAULT>
outpu=OutputSystem:NewOutput<DEFAULT>
condi=InputSystem:ReadEvaluatedLineOfInput<input>
Loops:ConstructLoop<Do;condi>[OutputSystem:DisplayAsText<outpu;condi>]

Try it online!

First non-trivial Verbosity v2 answer! Although how it works is very trivial, as you can see from the ungolfed version:

IncludeTypePackage<OutputSystem>
IncludeTypePackage<InputSystem>
IncludeStructurePackage<Loops>

input  = InputSystem:NewInput<DEFAULT>
output = OutputSystem:NewOutput<DEFAULT>

condition = InputSystem:ReadEvaluatedLineOfInput<input>

Loops:ConstructLoop<Do; condition> [
	OutputSystem:DisplayAsText<output; condition>
]

Try it online!

Simply enter a do...while loop, which prints the input at least once, then terminates if it's falsey (i.e. 0).

Rust compiler (nightly), 86 bytes

#![feature(log_syntax)]macro_rules!t{(0)=>{log_syntax!{0}};(1)=>{log_syntax!{1}t!{1}}}

(playground)

Readable version:

#![feature(log_syntax)]

macro_rules! truth_machine {
    (0) => {
        log_syntax!(0);
    };
    (1) => {
        log_syntax!(1);
        truth_machine!(1);
    };
}

truth_machine!(0);
truth_machine!(1);

Explanation

As the only way to iterate over anything other than the inputs of a macro is recursion, an infinite loop will always end in a stack overflow. I'm considering this error message "constant output of your language's interpreter that cannot be suppressed," as there's no other way to "infinitely" loop. The time for this to occur is dependent on the stack size, and thus most real-world macros will attempt to perform multiple operations per iteration to avoid this. Since this takes more space, I didn't do this. The only ways for a macro to give output are:

• compile_error!, a builtin which will immediately terminate compilation with a message, and is thus not valid for this challenge
• log_syntax!, an unstable builtin which will print its input to the compiler's stdout, with a newline appended
• Returning a value from the macro directly, which directly conflicts with the concept of an infinite loop

I chose to use log_syntax!, as I decided it was the only option that would follow the rules of the challenge. However, it requires a nightly compiler, and 23 additional characters in the source to enable. The syntax of macros is pretty fixed, but one trick I found is that macros called with macro!{} instead of macro!(); do not require a semicolon after, and are thus one character shorter.

Unsuspected-hangul, 187 bytes

ㅀㄱ ㄱㅇㄱ ㅅㅅㅎㄴ ㄳㅎㄴㅎ ㄱㅀㄷ ㄱㅇㄱ ㅁㅈㅎㄴ ㅈㅀㄴ ㄱㅇㄴ ㄴㅇㅎㄴ ㅂㄱㅎㄱ ㄳㅎㄴ ㄱㅇㄴ ㄴ ㄴㅎㄷㅎㄷㅎ ㄱㅀㄷㅎ ㄱㅀㄷ

You can try it here

Note that it use pop-up for standard output, and you have to close tap to terminate the program.

How does it work?

ㄹ ㅎㄱ [ㄱㅇㄱ ㅅㅅㅎㄴ ㄱㅅㅎㄴ ㅎ] ㄱㄹㅎㄷ bind(input(), int)
    [def print_and_recursion(x) num -> IO(nil)
    ㄱㅇㄱ ㅁㅈㅎㄴ ㅈㄹㅎㄴ print(str(x))
        [def recursion_part(not_used) nil -> IO(nil)
        (ㄱㅇㄴ ㄴㅇ ㅎㄴ) print_and_recursion(x)
        (ㅂㄱㅎㄱ ㄱㅅㅎㄴ) IO(nil)
        (ㄱㅇㄴ ㄴ ㄴㅎㄷ) ㅎㄷ if(x == 1) then... else...
    ㅎ]
    ㄱㄹㅎㄷ bind(print(str(x)), recursion_part)
ㅎ]
ㄱㄹㅎㄷ bind(bind(input(), int), print_and_recursion)

Unsuspected-hangul(평범한 한글) is Korean character-based functional esolang.

JavaScript, 32 bytes

do{alert(x=x||prompt())}while(x)

Befunge, 4 bytes

&:.%

Try it online!

Please note: this answer is no longer valid with this particular interpreter. At the time of writing, the interpreter used had a quirk where trying to read more integers when there weren’t any would return the last integer. I believe that this was “fixed” in some interpreter update. (Thanks to @osuka_ for realizing that this answer no longer works)

Explanation:

&       Take number input
 :.     Duplicate and print input
   %    Mods the second from-the-top with the top number in the stack
        This means that if the top is 1, it will yield 0 % 1 = 0,
        But if it is a 0, it errors out and stops execution because you are
        trying to divide by 0
        
&       The program wraps back around if it didn't error, and the & takes
        the last number in the input if it has already taken them all, yielding
        the original 1 or 0

Coincidentally, this doesn't also work for /, because it strangely asks you what you want the answer to be.

Runic Enchantments, 6 bytes

i:?@:$

Try it online!

? is a conditional jump command that skips n instructions where n is a value popped from the top of the stack. If that value is 0, we dump the stack and terminate. If its 1 we skip that instruction and print the value, leaving a copy on the stack, then loop. i does nothing if there is no more input to read.

Befunge-93, 7 bytes

&>:.:_@

Try it online!

_ is the horizontal if in befunge - conveniently, it sends the IP right if the top of the stack is 0 (so it hits @ to end the program), and left if the top of the stack is nonzero (which puts it in an infinite loop).

33, 4 bytes

O[o]

Explanation:

0 input:

O    | Get input
  o  | Print it
 [ ] | Loop ends because accumulator is 0

1 input:

O    | Get input
 [ ] | While the accumulator is 1 (forever)
  o  | Print it

Pip, 7 bytes

IqW1P1i

Try it online!

explanation:

If(q) // q is input
    While(1) {
        print(1);
    }
output 0  // i is initialized to 0, but this stops it from being confused for "10"

Pyramid Scheme, 166 156 131 123 bytes

Saved 10 bytes thanks to Pavel! Saved 25 33 bytes thanks to Khuldraeseth na'Barya!

   ^       ^
  / \     / \
 /set\   /do \
^-----^ ^-----^
-    ^- -^   / \
    /l\ /#\ /out\
   /ine\---^-----
   -----   -

Try it online!

Try it online!

Old answer and explanation (functionally equivalent)

    ^        ^
   / \      / \
  /set\    /do \
 ^-----^  ^-----^
/a\   /#\/a\   / \
---  ^------  /out\
    /l\      ^-----
   /ine\    /a\
   -----    ---

Hehe. I love this language.

Explanation

There are two pyramid chains. The first is:

    ^
   / \
  /set\
 ^-----^
/a\   /#\
---  ^---
    /l\
   /ine\
   -----

This sets variable a to line (a line read from STDIN), as a value (#).

The second:

    ^
   / \
  /do \
 ^-----^
/a\   / \
---  /out\
    ^-----
   /a\
   ---

This is a do while loop, with the left pyramid being the condition, and the right one being the body. Equivalent to:

do {
    out(a);
} while(a);

which is what we want.

Enterprise, 128 bytes

/©©//NDANDA/final disruptive class fdcBit{final immutable void main(){var Money i=read();;;write(i);;;while(i==1){write(i);;;}}}

It's really annoying how the specification isn't very clear, so I had to guess a lot of things.

EZLang, 105 bytes

MEM(0)
SET(-1)
MEM(1)
GET()
SET(-1, 1)
JLZ(12)
SET(1, 1)
MEM(1)
PRT()
MEM(0)
JLZ(8)
SET(1, 1)
PRT()
HLT()

Self-made esolatic language.

Aheui, 28 bytes

붕박누망홰
차봇멍보

Try it online!

Additionally, I found bug of TIO with Aheui : Aheui is befunge-like, but initial direction is up-to-down, but TIO's initial direction is right-to-left, so my original code got error.

Ruby + -np, 16 12 bytes

p 1while~/1/

Try it online!

~/1/ matches the last line of input to the regular expression /1/

Edit: replaced ;p 0 with the -p flag making the answer -np complete, thanks to @ValueInk

GolfScript, 13 bytes

~{.}{.p}while

Explanation

~       # convert STDIN to an integer

{.}     # while loop condition: remains the same--the input
{.p}    # while loop body: print the input
while

^{This is one of my first golfs!}

NuStack, 82 bytes

putchar(c:char):int;f(i:int):int{if(i>0)putchar('1');else while(1>0)putchar('0');}

Been working on this compiler for a month and a half. Still very much a WIP, but finally at a point where I can do some PPCG with it :D

Unlike all of my other languages, this isn't some toy, esoteric, interpreted language.
It's a serious language that compiles directly to assembly (nasm syntax).

I'll probably opt to get NuStack on TIO once it's notably more feature-complete than it currently is.

Explanation:

Ungolfed version:

putchar(c: char): int;

f(i: int): int {
    if(i > 0)
        putchar('1');
    else 
        while(1 > 0)
            putchar('0');
}

The first line is a function prototype that allows you to call a function defined elsewhere (think C header files)

putchar in particular is currently the only function in libns, the language's standard library. It takes a single char, and outputs it to stdout. libns is currently available for 64bit linux, so it just makes a syscall using sys_write(), and 32bit "raw", ie not running on a kernel or operating system, where putchar will use the int 0x10 interrupt to print the character in TTY mode

NuStack uses post-fix types, similar to TypeScript, and there is no type inference, so types must always be explicitly declared.

NuStack also doesn't have type casts yet, or do..while loops, so this is, as far as I know, the golfiest way to do it.

VSL, 36 32 bytes

fn main(){do{print(i)}while i>0}

This is probably familiar to anyone who knows any C-esque language but this takes input using a global variable i.

Try it online!

Malbolge, 257 bytes

(aONMLKJIHGFEDCBA@?>=<;:98765FD21dd!-,O*)y'&v5#"!DC|Qzf,*vutsrqpF!Clk|ih
gfed9(T&6KoOHZYXWVUTSRQPONM]KJIHGFEDCBA@?>=<;:9876"'~g|edybav_zyxwvotsrq
pSnPlOjibKfedcba`_XA??ZYRW:UTSLQ3ONMLK.IHGFE>CBA@?"=<;:38765432s0/.n,+*)
j!&%f{"!~}|_zyxZvYnsrqpRnmlkjML:f_^GF!

Try it online!

From esolangs.org

Quite the abomination, isn't it?

In fact, this language is so horrible, I don't think anyone "programmed" this in the traditional sense. If I'm remembering correctly, this was found by a search program that basically brute-forced for possible Malbolge programs that worked as a truth machine.

INTERCAL, 89 bytes

DOWRITEIN.1PLEASE.3<-#1$.1DOCOMEFROM(2)DOREADOUT.1(2)PLEASE(1)NEXT(1)DO(1022)NEXTDOGIVEUP

Try it online!

Looking at some answers to this challenge, I noticed that the current INTERCAL answer was barely golfed at all, with 141 bytes 30 of which are whitespace. Not hard to outdo!

Uses native INTERCAL-72 integer I/O, that is, the input is ZERO or ONE (or some translation thereof) with a trailing newline, and the output is in "butchered Roman numerals".

Explanation:

DO WRITE IN .1

Inputs a number to the 16-bit variable .1.

PLEASE .3 <- #1 $ .1

Sets .3's value to 1 mingled with .1's value. Since .1 holds either 0 or 1, .3 is set to either 2 or 3.

DO COME FROM (2)

If execution would move on normally from statement (2), it goes here instead.

DO READ OUT .1

Prints the value in .1.

(2) PLEASE (1) NEXT

This is statement (2). It places itself on the NEXT stack and moves execution to statement (1). It does not trigger the COME FROM unless RESUMEd to.

(1) DO (1022) NEXT

This is statement (1). It NEXTS to statement (1022) in syslib, which then itself NEXTS to statement (1023) in syslib, which reads PLEASE RESUME .3. This pops a non-zero number of entries equal to .3 off the NEXT stack and resumes execution at the last one popped. Since there are at this point three entries on the NEXT stack, corresponding to (2), (1), and (1022) (RESUME works just fine without labels, it just so happens that all of the NEXTs here have them), and .3 is 2 or 3 depending on whether .1 is 0 or 1, this goes to and moves on from either (1) if .1 is 0, or (2) if .1 is 1. If this RESUMEs to (2), the COME FROM takes effect and begins an infinite loop (and since this outcome leaves the NEXT stack empty, the program does not disappear into the black lagoon after 80 loops).

DO GIVE UP

If (1) was RESUMEd to, execution moves here, and this terminates the program without an error.

(I'll edit in a version with Turing Tape string I/O some time later.)

AlgiX with -x, 3 bytes

[.]

Explanation

AlgiX takes each character of input (converts it to charcode if it's not a digit) and runs the entire code for each value, initializing the accumulator to that value each run.

In this case, there's only 1 input, a 1 or a 0, so the code runs once.

[.] - Implicit a = input
[   - If a == 0, skip to ]
 .  - Print value of a
  ] - If a != 0, jump back to [
    - Implicit output value of a

Normally, the implicit output after each run would output a as a character, however the -x flag overrides that and outputs its value instead.

VTL-2, 25 bytes

1 A=?
2 ?=A
3 #=4-2*A

Line numbers always take up two bytes in VTL, hence the byte count discrepancy.

This should work in VTL-1 as well, but I don't have an interpreter to ensure that is the case. I've tested this under a VTL-2 interpreter running on an Altair 8800 simulator, both sourced from here. Here's a PDF manual for VTL-2.

VTL was a small (<800 bytes!) and simple language for the Altair 8800 and 680 machines. Its creative use of system variables helped to keep it small. ? represents both input and output. Note that this truth machine outputs no line breaks, as those always need to be manually printed (by printing an empty string, ?=""). # represents line number, and can be used to retrieve the current line number or assigned to form a goto. That should be enough to make this truth machine make sense...

1 A=?         ) Put input into variable A
2 ?=A         ) Print the contents of variable A
3 #=4-2*A     ) Goto 4-(2*A)... So, (nonexistent) line 4 if input was 0
              ) Or back to line 2 if input was 1. Yes, `)` is the comment character.

Python 3, 41 bytes

a=input()
while(a=='1'):print(1)
print(0)

Try it online!

C++ (gcc), 65 bytes

#include<cstdio>
int main(){for(int c=getchar();putchar(c)-48;);}

Try it online!

Rockstar, 34 Bytes

Rockstar is a quite new computer programming language, designed for creating programs that are also song lyrics. Rockstar is heavily influenced by the lyrical conventions of 1980s hard rock and power ballads.

Listen to your heart
Say your heart
While your heart is not empty
Scream it

But yes, you are right, it's longer than 34 bytes, but so poetic, I couldn't resist get some lyrics in. You could even sing it!. Here's the golfed version:

Listen to X
Say X
While X
Say X

C (gcc), 52 bytes

main(i){for(scanf("%d",&i);i;)puts("1");puts("0");}

-27 bytes thanks to JoKing
-2 bytes thanks to Jonathan Frech
Try it online!
I though I'd try something other than my primary language (Java).

Tamsin, 19 bytes

main="0"|{print 1}.

Explanation

The main production first tries to read a 0. If it succeeds, it is returned, and, because this is the main production, printed.

Otherwise, it ignores the input and tries the alternative, which is {print 1}. The { } brackets denote a loop that continues running as long as its content succeeds, and a print statement always succeeds, so this loops forever.

Deoxyribose, 18 bytes

Updated for the new v3 spec

ATGGAGAAGAGCATAAAT

Explanation:

ATG                         ATA (*)
GAG Glu     Dupe            TGG Trp     Power
AAG Lys     Pop             AGA Arg     Unipop
AGC Ser     Jump if <= 0    AGA Arg     Unipop
ATA *                       GCA Ala     Modulo
AAT Asn     Loop            TAA End

• Execution starts at the initial ATG.
• The top element of the main stack is duplicated & printed, then If the value is less than or equal to zero, jump to the ATA formed by the Asn and the start codon (remember, the code is circular), then run through a series of no-ops, including printing some non-printable characters. If the value is greater than 0, loop back to the start.

If you don't like the ugly sequence of no-ops, adding ATG to the end to make the loop target explicit results in a clean termination immediately after the jump, for three more bytes.

Deoxyribose 2, 21 bytes

ATGTGAGAAAAATCTAACTTA

Explanation:

ATG Start                           TAA Stop ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┐
TGA Block size = 56               ┏ TGT Cys     Destination of Asn ┆
GAA Glu     Duplicate             ┃ GAG Glu     Duplicate          ┆
AAA Lys     Pop as int            ┃ AAA Lys     Pop as int         ┆
TCT Ser     If >= 0, jump to Thr ┐┞ AAT Asn     Jump back to Cys   ┆
AAC Asn     Jump back to Cys ────┼┘                                ┆
TTA                              └─ ACT Thr     Destination of Ser ┆
                                     └┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┘

This is the first challenge on this site ever answered in this language (since it's only a week old), but I think it's a good showcase of what the language can do so I'll provide a bit of an explanation of what's going on. If you happen to be really interested, the spec, a Python-based interpreter, and additional (less golfed) examples are on GitHub.

Deoxyribose is a stack-based language with a small instruction set and a syntax based on DNA. Execution takes place on a circular stretch of DNA, translating 3-digit "codons" into proteins, each of which corresponds to either

• an operation on one or both of the stacks, or
• a (perhaps conditional) jump to a particular sequence elsewhere in the code.

These jumps can lead to frameshifts, where the read head is moved a non-integer number of codons and the same bit of code ends up doing two totally different things at different times. The degenerate nature of the genetic code makes it possible (and fun!) to use this to your advantage.

Gol><>, 5 bytes

IZh1n

Thanks to JoKing for helping golf this down further!!!

Try it online!

Alchemist, 24 bytes

_->In_a+Out_a
a->a+Out_a

Try it online!

I couldn't figure out a shorter way using only one output section. The closest I came was 25 bytes

Explanation:

_->In_a            # a = input
       +Out_a      # Output a
a->a               # While a
    +Out_a         # Output a

Turing Machine But Way Worse, 139 bytes

0 0 0 1 1 0 0
0 1 0 1 2 0 0
1 2 1 1 3 0 0
1 3 1 1 4 0 0
0 4 0 1 5 0 0
0 5 0 1 6 0 0
0 6 0 1 7 0 0
0 7 0 1 8 1 1
1 7 1 0 8 1 0
0 8 0 1 7 1 0

Try it online!

Lua, 38 bytes

x=io.read()repeat print(x)until x~='1'

Try it online!

bitch, 5 bytes

This infinitely outputs 1 for an input of 1 and outputs 0 once for an input of 0.

\>/;<

Explanation

\         Input of an integer (restricted by challenge to 0 or 1)
 >        Loop marker #1
  /       Output
   ;<     If not equal to 0, jump to loop marker #1
          (Implicit end of program)

!@#$%^&*()_+, 10 bytes

*0_+!#(!#)

Try it online!

Explanation

*0_+!#(!#)
*             take byte of input
 0            push 48
  _+          subtract
    !#        duplicate and output
      (  )    while the top of the stack is not 0:
       !#     duplicate and output

brainfuck (portable), 29 28 bytes

>>>,.[[->+<<+>]>-]<+[<<]>[.]

Try it online!

(Improved by 1 byte thanks to Jo King, who found a terser way to start the [<<] loop.)

I know that on PPCG it's normally sufficient for an answer to work on one interpreter, but as this is a catalogue, I wanted a demonstration of a brainfuck answer that should work on any interpreter, and which exits without error on input 0. This program makes no assumptions about cell size, EOF behaviour, wrapping, tape extension to the left, etc. It's the shortest brainfuck truth-machine I'm aware of with these properties.

Explanation

>>>,.[[->+<<+>]>-]<+[<<]>[.]
>>>,                            Input a character to the fourth cell
    .                           Output that character
     [           ]              While the current cell is nonzero:
      [->+<<+>]                   Move the value to the next and previous cells
               >                  Make the next cell current
                -                 and decrement it
                  <+            Starting behind the current cell, at value 1
                    [<<]        Move back two cells at a time until we find zero
                        >[ ]    If the cell to the right is nonzero:
                          .       Output it forever

The basic idea here is to create a range on the tape, containing all values from the input's ASCII code down to 0. (So for example, if the input is 0, we get 48 in the third cell, 47 in the fourth cell, 46 in the fifth cell, etc..) Once we've done that, we look at alternate values of the range until we end up at a tape element before the start of the range. If the range has an even length (i.e. the input has an even ASCII code), we'll end up two cells to the left of it, so moving to the right we'll end up in a cell we've never written to (and thus still has the value zero). If the range has an odd length, we'll end up only one cell to its left, so >[.] will move to the first cell of the range (i.e. the user input) and output it in a loop forever.

F# (.NET Core), 54 bytes

let x=stdin.Read()
while x=49 do printfn"1"
printfn"0"

Try it online!

brainfuck, 28 bytes

>>,.[[>]+<[-<]<+>>]>[<]<<[.]

Try it online!

This should be portable to almost all implementations of brainfuck. If you don't mind negative cells, you can save 2 bytes by removing the initial >>.

Explanation:

 >>                # Go right
 ,.                # Get input and print it once
 [[>]+<[-<]<+>>]   # Convert the number to binary while preserving it
 >[<]<<            # If the last digit of the binary is odd
 [.]               # Print the input forever

Backhand, 9 bytes

{I>{@:1O_

Try it online!

A little convoluted, but that's Backhand's way.

Explanation:

{I>{@:1O_
{           # Step left, bouncing off the wall and changing directions
 I          # Get input as a number
  >         # Enter loop by setting the direction to right
     :      # Dupe input
        _   # Step left if 1, otherwise right and change directions
       O    # Both output here, but are going in different directions
    @       # Terminate if 0
  >{  1     # Otherwise push 1 to the stack and restart the loop again

Little Man Computer, 19 bytes (4 instructions)

INP
OUT
BRZ 4
BRA 1

Which, when assembled into RAM, is:

901 902 704 601

Annoyingly, BRP means branch if positive or zero, making it useless for distinguishing between the two possible inputs. Therefore we have to use two seperate branching commands: BRZ (branch if zero) to escape the program, followed by a BRA (branch always) to continue the loop if the number is non-zero.

An online interactive interpreter can be found here.

Assembly (nasm, x64, Linux), 119 bytes

mov eax,3
mov ebx,0
mov ecx,i
mov edx,1
int 80h
l:mov eax,4
mov ebx,1
int 80h
cmp byte [i],49
je l
section .data
i:db 0

Try it online!

I was surprised that, while there is a 128 byte submission in as, there isn't a nasm submission, despite it being shorter!

Literally a port of the as submission into nasm.

Pascal (FPC), 54 bytes

var a:word;begin read(a);repeat write(a)until a<1 end.

Try it online!

Flobnar, 10 bytes

<1._
|@&
0

Try it online!

Z80Golf, 9 bytes

00000000: cd03 80ff fe30 20fb 76                   .....0 .v

Try it online!

Disassembly

start:
  call $8003
loop:
  rst $38
  cp $30
  jr nz, loop
  halt

The Z80Golf machine initializes whole memory and all registers to zero before loading the program.

call $8003 calls getchar, which takes a byte from stdin to register a. On EOF, the register a does not change and the carry flag is set.

rst $38 simulates a call to putchar which prints the register a. The function is actually at $8000, so PC slides through $00 bytes (NOPs) in the memory until it hits the address $8000.

The rest is just a straightforward do-while loop in assembly, no tricks involved.

Z80Golf, Byte IO, 8 bytes

00000000: cd03 80ff b820 fc76                      ..... .v

Try it online!

Disassembly

start:
  call $8003
loop:
  rst $38
  cp b
  jr nz, loop
  halt

The only difference is the use of cp b, where b is used in place of constant zero.

Z80Golf, Byte IO, Tricky version, 8 bytes

00000000: cd03 80b8 2002 ff76                      .... ..v

Try it online!

Disassembly

start:
  call $8003
  cp b
  jr nz, infinity
  rst $38
  halt
infinity:

If the input is zero, rst $38 and then halt is executed, exiting the program normally. Otherwise, something weird happens:

• PC goes to infinity:, slides through NOPs, and then putchar is executed.
• The putchar has a ret instruction, so sp becomes 2 and execution is returned to the address $03cd.
• Then putchar is executed again. sp becomes 4, pc is $b880.
• Now pc wraps around and comes to $0000, the start of the program.
• call $8003 is run, which overwrites the program so $80b8 becomes $0300.
• getchar sets the carry flag, but we don't care anyway. EOF is hit so a is untouched.
• Now cp b became nop, but jr nz, infinity is intact. Again putchar is run, sp becomes 6, pc is $0220. putchar again, sp = 8, pc is $76ff, putchar again, sp = 10 = $000a, pc = $0000.
• The call $8003 became call $0303, which now effectively calls putchar instead. No problem, now one loop just prints a twice. Note that a call leaves $0300 to the memory, but fortunately $00 is NOP and $03 is inc bc, which does not affect the program's logic. (Single-byte inc does affect the flags, but double-byte ones don't, so jr nz isn't affected either.)
• The call is now a heat wave filling the memory with $0300. Eventually, sp wraps around to $0002 again, and finally overwrites $cd03 into $0300, deleting the call .

The heat wave is finally over, and the only thing left is:

  jr nz, infinity
  rst $38
  halt
infinity:

The conclusion is that we have an infinite loop printing 1 as a byte.

Note that putchar is NOT an actual piece of code in memory. It is "simulated" when the PC hits $8000, along the ret instruction.

Acc! - 54 50 48 49 Bytes

N
Write _
Count q while _-48 {
Write _
}

Self-modifying Brainfuck, 30 19 bytes

Similar method to my BF answer. Input and print, subtract the 0 (the source's last byte) from the input, so cell is 0 or 1. Loop printing if input cell is 1. Tested on my Python interpreter.

,.<[->-<]>[<<.>>]10

You can also run it on TIO.

Pepe, 15 bytes

REeErEErReEEree

Try it online!

Explanation:

REeErEErReEEree  # Full program
REeE             # Take input as number
    rEE          # Create label 0
       rReEE     # Output number -r (preserve)
            ree  # Goto label 0 if [input] != 0

Python 2.7, 45 bytes

I just had the Eureka of this code:

x=int(raw_input())
print x
while x: print 1

I am proud of this one, though it may not look very impressive.

PowerShell, 16 15 bytes

for(;$args){1}0

Try it Online!

Edit:
-1 byte thanks to @AdmBorkBork

PUBERTY, 369 bytes

It is May 1, 2018, 3:01:04 PM.Y is in his bed, bored.His secret kink is J.Soon the following sounds become audible.oh yeah yeah yeah hrg fap yeah yeah yeah fap yeah fap yeah yeah mmf yeah yeah yeah hrg yeah hrg fap yeah yeah yeah yeah fap yeah fap yeah mmf yeah yeah yeah yeah yeah yes yeah yeah yeah yeah yeah hrg fap yeah fap yeah fap yeah yeah yeah yeah mmf yeah mmf

Ungolfed

It is May 1, 2018, 3:01:04 PM.
Yhprum is in his bed, bored.
His secret kink is humaninteraction.
Soon the following sounds become audible.

oh yeah yeah yeah
hrg
    fap yeah yeah yeah fap yeah fap yeah yeah
mmf

yeah yeah yeah

hrg
    yeah
    hrg
       fap yeah yeah yeah yeah fap yeah fap yeah
    mmf
    yeah yeah yeah yeah yeah

    yes

    yeah yeah yeah yeah yeah
    hrg
        fap yeah fap yeah fap yeah yeah yeah yeah
    mmf
    yeah
mmf

This was very much harder than I expected it to be using this language.

Explanation

PUBERTY is a wonderful language. It has 6 registers (A, B, C, D, E, F) and one register pointer, all initialized to 0. At the end of each instruction, REGPTR %= 6 and REG[REGPTR] %= 256.

These are the commands used in this program:

• oh reads an ASCII character and stores its value into the current register
• yeah increments REGPTR by 1
• hrg...mmf loops until the current register has a value of zero
• fap increments the current register by 1
• yes prints the ASCII char corresponding to the value of the current register

The program starts with the header - the first four lines

It is May 1, 2018, 3:01:04 PM.

This sets $D to the Unix timestamp of the date % 256. In this case, we set it to 48. This statement is required

Yhprum is in his bed, bored.

This initializes $C to 6, the number of chars in the name, but we don't use this at all. This statement is required.

His secret kink is humaninteraction.

This line is where you declare all your kinks, if you want to learn about what they do, check out the esolang page since we don't use them here. This statement is required.

Soon the following sounds become audible.

Required line, does nothing.

oh yeah yeah yeah
hrg
    fap yeah yeah yeah fap yeah fap yeah yeah
mmf

yeah yeah yeah

read in a 0 or 1, then loop until $D is zero while incrementing $A and $B. This leaves us with $A containing ASCII value 0 or 1, depending on what was inputted and $B containing 208. Then move REGPTR back to A

hrg
    yeah
    hrg
       fap yeah yeah yeah yeah fap yeah fap yeah
    mmf
    yeah yeah yeah yeah yeah

    yes

In the inner loop, move REGPTR to $B (which has the value 208) and loop until it is zero while incrementing $A and $F. This leaves us with $A containing 48 or 49 (the ASCII codes for 0 or 1) and F containing 48. Then print $A, which will output a 0 or 1 depending on which one was inputted.

    yeah yeah yeah yeah yeah
    hrg
        fap yeah fap yeah fap yeah yeah yeah yeah
    mmf
    yeah
mmf

Now we move REGPTR to $F and loop until that is zero while incrementing $A and $B. This leaves us with $A containing the ASCII value 0 or 1 and $B containing 208, just like it had at the start of the loop. The loop then exits if $A == 0 or loops infinitely if $A == 1.

This is my first codegolf answer so excuse any mistakes I made pls.

MATL, 4 bytes

`GtD

Relevant MATL features ^*

To explain the code, the following MATL features need to be presented first.

• ` ...] is a "do ...while" loop. The top of the stack is consumed at the end of each iteration, and used to decide whether to go on with a new iteration or not. The last ] can be omitted if it's at the end of the program (loops are implicitly closed).
• G works as follows:
  • When there has been no user-input it does nothing;
  • When there has been one user-input it pushes it onto the stack
  • When there has been more than one user-input it takes a numeric argrument and pushes one of those user-inputs onto the stack
• t by default duplicates the top element of the stack
• D by default displays the top element of the stack, and consumes it.
• If a function requires more inputs than currently are in the stack, user-input is implicitly triggered. The entered elements are placed below the current bottom of the stack.

Code explanation

` enters the loop. At the first iteration, G does nothing. t implicitly asks for user input and duplicates it. D displays and consumes the duplicate, leaving the original input on the stack. If this input is 0 the loop is exited and the program finishes (a single 0 has been displayed). If the input is 1, control goes to the beginning of the loop again. Now G pastes the input, t duplicates it, D displays and consumes that duplicate, and again there's a 1 to be used as loop condition, so the loop begins again, indefinitely (an infinite number of 1 is displayed).

_{^* at the time of writing. The behaviour of G has changed since then: G now triggers implicit input when there has been no user-input yet. However, this doesn't affect the code, which works the same. The only difference is that in the first iteration the implicit input is now triggered by G, not by t.}

FerNANDo, 37 bytes

_ _ _ 1 _ _ _ _ C
C
0 0 1 1 0 0 0 C
C

Try it online!

2DFuck, 32 30 bytes

,.,.,.,.,.,.,.,.[!..!..!...!.]

Try it online!

Explanation:

,.,.,.,.,.,.,.,. Read and print a byte, accumulator is last bit = 0 or 1
[!..!..!...!.]   While the accumulator is 1, print 1

ABAP, 61 bytes

Hardcoded VALUE 1 for variable i, replace with 0 to not trigger the infinite loop.

DATA x TYPE I VALUE 1.
WHILE i=1.
WRITE i.
ENDWHILE.
WRITE i.

Rust, 90 bytes

use std::io::*;fn main(){let
b=&mut[0];stdin().read(b);while{stdout().write(b);b==b"1"}{}}

Try it online!

Ahead, 10 bytes

IsO@
~>1O~

Try it online!

Lua, 41 bytes

a=io.read()while q~="0"do print(a)q=a end

Explanation:

a=io.read(): read input from user and store in variable a

while q~="0"do: compares q to the string "0", q starts as nil, which isn't "0" so the loop runs at least once. Because the input is a string we have to compare with the string "0", not the number 0

print(a)q=a: prints a (1 or 0) and sets q to a, so if a = "1" the loop continues, if a = "0" the loop stops

end: end of loop, like } in other languages

Whitespace is not needed after parenthesis/quotation marks, for example print(a)q=a is equivalent to print(a) q=a

Charm, 42 bytes

getline " 1 " eq put [ dup ] [ put ] while

Try it online!

You strangely can't cast to an integer in Charm, so I had to check for equality with 1 instead.

brainfuck, 25 bytes

Note: This is a different "language" than this answer, because it requires a brainfuck variant that exits when the memory pointer is moved left of the initial position, whereas this needs a brainfuck variant that can read and write left of the initial position.

,.[[<+>->+<]>-]<+[<<]>[.]

Try it Online!

Explanation

,.             Read and print a character.
[[<+>->+<]>-]  Write the range from the code point of the character down to one.
<+[<<]>        Go to the first element in the sequence if the length is odd, otherwise
                go to the cell before.
[.]            Print the value at the pointer forever if the input is odd, determined by
                if the pointer is on or outside the sequence of numbers in memory.

Here are two other interesting solutions i found, which may be golfable (29 bytes each):

,.+++[->+>+++++<<]>--->+[<.>]
,.[->+>+>--[<+>--]<<<]>>[<.>]

TIS -n 1 1, 29 bytes

@0
ADD UP
L:MOV ACC ANY
JGZ L

Try it online!

ADD UP is a shorter form of MOV UP ACC, since the accumulator starts at zero, and we only ever see one value on the input (if that is not desired +4 bytes to add HCF after the last line).

MOV ACC ANY simply does the output. This line is also labelled L.

JGZ L jumps to L if the accumulator is greater than zero. (JNZ L, jump if non-zero, would work identically here.)

In the case where we have a zero for input, we do not jump, but instead wrap around to the first line (ADD UP). Since there is no more data to be had, the system goes quiescent.

In the case of a one, we will endlessly jump to L, outputting a 1 on every third cycle (writing to a neighbor actually takes two cycles in TIS).

Whitespace, 46 37 bytes

Thanks to Kevin Cruijssen for golfing 1 byte off the first instruction, and 8 bytes by removing the last 2 instructions, which makes the program jumps to non-existent label and terminates with error but still output correctly in the output stream.

SS SL  # push 0
SLS    # dup
TLTT   # readn
TTT    # load
LSS L  # label L
SLS    #   dup
SLS    #   dup
TLST   #   prtn
LTS TL #   jmpz TL
LSL L  # jmp L

Demo on ideone

Previous safe version of the program which terminates normally has a proper label and the standard triple new line to end the program:

LSS TL # label TL
LLL    # end

Demo on ideone

Notation explanation:

• # starts comment
• L is newline
• S is space
• T is tab

I used this interpreter to develop the program and generate the comments.

Didn't expect the code to be this long. Whitespace requires the input to be read into heap, heap instructions consumes stack, printing instruction consumes the stack and even jump instruction consumes the stack, so it bloats the code with all the "duplicate top stack" instructions.

Fortran (GFortran), 42 bytes

READ*,I
DO
PRINT*,I
IF(I==0)EXIT
ENDDO
END

Try it online!

Quarterstaff, 12

49-?{49!}49! 

explanation

(value = 0 to start)

49 - add 49 to value

- - invert value (value = -49 now)

? - take a character of input (49 for "1", 48 for "0"), and add it to the value (value = 0 or -1 now)

{ - begin while not loop. will only be entered if input is 1 or starts with 1 (it should only start with 1 if it is 1).

49 - add 49 to value. value is now 49

! - print value, set value to 0.

} - end while not loop.

49 - add 49 to value (which was -1). value is now 48

! - print value, set value to 0 (not relevant to the program, but all ! do this)

it looks like it could be golfed by assigning 49 to something, but it would take 2 more bytes to assign it, then 2 more bytes to use it in the first part, then only byte saving of 2 for the other two occurences of 49

Previous version of Quarterstaff, 11

I removed %, so this isn't valid in the new version

?1%{49!}47!

? - input a character (49 for "1", 48 for "0") add to value

1 - add 1 (value is 50 or 49 now)

% - value = value %2 (0 if "1" was inputted, 1 if "0" was inputted)

{ - begin while not value loop

49 - add 49 to value

! - print value, value = 0

} - end while not value loop

47 - add 47 to value

! - print value, value = 0

Momema, 9 bytes

i0-8_Ii_I

Try it online! Requires the -i interpreter flag.

The provided Momema interpreter has a -i flag which enables interactive mode. In interactive mode, expressions can have holes, which evaluate to a value read from STDIN. Normally, this would just be equivalent to *-8, but it also allows holes to be named with a string of capital letters. When a named hole is evaluated, its value is cached, and when a hole with the same name is evaluated again it is reused. This is intended to be for debugging purposes, but it also means that we can refer to input without having to assign it.

Explanation:

                                                 #  i = input num
i   0   #  label i0: jump past label i0 (no-op)  #  do {
-8  _I  #            output num _I               #    print num i
i   _I  #  label i1: jump past label i(_I)       #  } while i

QUARK, 11 bytes

This is 6.75 bytes in QUARK's encoding, but that's not finished yet (no encoder), so I'll score this in UTF8 until then.

i‶{p}⟲

As QUARK became capable of doing a truth machine (implementation wise) less than a minute ago (from when I started writing this answer), it obviously needs an explanation, so here you go:

i Get input from the user (as a number)
 ‶ Pin the input to the stack (Pinning is QUARK's way of avoiding a million and one dupes, by simply making the value undeletable until you run the pin command on it again.)
  { Begin a block
   p Print a value off the stack. Because the input is pinned, it's not consumed.
    } End the block, and push it to the stack (when the program reaches this point)
     ⟲ Execute the block. If the top of the stack is not after the first execute 0, execute the block until it is. As the input is pinned, it will always be either 0 or 1. So the block either executes once, or infinitely.

Linotte, 52 bytes

a:
e est un nombre
début
demande e
e!
tant que e,e!

Linotte is a french programming language aimed at beginners. Translated into English:

a:
e is a number
start
ask for e
e!
while e, e!

e! is shorthand for affiche e, which means "display e".

You can find a download here.

Python 2, 59 51 49 33 bytes

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

Explanation:

input()             # take input from STDIN
while i:print 1     # print 1 if the argument is anything other than 0... input() evaluates the string and returns a value
print 0             # print 0 and exit if input() returns 0

EDIT: Saved 8 bytes thanks to @EsolangingFruit

EDIT 2: Coupla more bytes thanks to @HyperNeutrino

EDIT 3: Saved 16 bytes thanks to @HyperNeurtrino

ShinyLisp, 22 bytes

+:Ge _&^:Pu~:I:P^~N:Qx

I figure now is as good a time as any to introduce my new golfing language. It's still largely a work in progress, but it's usable.

Ungolfed:

(= (gets))
(loop '% (puts) (cond (p %) () (quit)))

Explanation:

(= (gets))       -- Reads a line of user input and assigns it %
(loop '% ...)    -- Loop forever using % as the (constant) loop value
(puts)           -- Print the value of %
(cond (p %) ...) -- If % (treated as a number) is nonzero then...
()               -- Do nothing
(quit)           -- Else exit the program

Yabasic, 36 bytes

Another basic answer that takes input as integer, n and outputs to the console.

Input""n
If n Then Do?1Loop Else?0Fi

Try it online!

Reflections, 26 bytes

  _:#_: _<
/#_v     /
\: /

Test it!

Explanation:

The _ at position (2|0) reads a line from input, : doubles the first character. Then, # redefines zero and _ at (1|0) prints that character. : doubles the first character again, _ at (4|0) converts a digit to a number. < tests this number, if it's 0, the IP is directed upwards (out of the program). Else it's directed downwards, then left by the /, and down again by the v, left by the /. The : doubles the character again. Then, the \ reflects the IP upwards and the / right again, where # redefines zero and the _ at (1|0) prints the character. The v then directs it down into the loop again.

Stax, 5 4 3 bytes

_{Crossed out 4 is still 4 ;(}

wQc

Try it at staxlang.xyz!

 w      Until popping results in a falsy value:
  Q       Peek and print with a newline.
   c      Copy the value atop the stack.

I'm loving this new language.

Thanks to @Weijun Zhou for reminding me of implicit input.

R, 29 27 bytes

2 bytes brilliantly saved by @Giuseppe

x=scan();while({cat(x);x})1

Kotlin Script, 41 bytes

readLine().let{while(it=="1")print("1")}

Pretty Printed:

readLine()
    .let{
        while(it=="1")
            print("1")
    }

Brachylog, 4 bytes

Thanks to Fatalize for saving 1 byte.

w?1↰

Try it online!

Explanation

w     Write the input to STDOUT.
 ?1   Check whether the input equals 1.
   ↰  If so, recursively call the main predicate with 1 again.

Aheui, 33 bytes

방챵뱍벅나명희멍터벅벅

You can test it with jsaheui, or rpaheui.

How does it works?

// When input is 0
방챵뱍벅나명희멍터벅벅
ⓐⓑ　　　　ⓖⓕⓔⓓⓒ

// When input is 1
방챵뱍벅나명희멍터벅벅
ⓐⓑⓓⓒⓔⓕ
　　　ⓖ

ORK, 395 bytes

There is such a thing as a m.
A m can p a word.

When a m is to p a word:
I have a scribe called W.
W is to write the word.
I have a linguist called C.
C's first operand is the word.
C's second operand is "1".
C is to compare.
If C says it's equal then I am to loop.

When this program starts:
I have a inputter called R.
I have a word called N.
R is to read N.
I have a m called M.
M is to p N.

Try it online!

Here's the ungolfed version, which is not a whole lot different:

There is such a thing as a truth machine.
A truth machine can process a word.

When a truth machine is to process a word:
There is a scribe called Keymaker.
Keymaker is to write the word.
There is a linguist called Chomsky.
Chomsky's first operand is the word.
Chomsky's second operand is "1".
Chomsky is to compare.
If Chomsky says it's equal then I am to loop.

When this program starts:
I have an inputter called Dave.
I have a word called Input.
Dave is to read Input.
I have a truth machine called Hal.
Hal is to process Input.

The first paragraph defines a truth machine class with one member function, process, which takes a string (i.e. word).

The second paragraph defines process: write the string out, and then compare it against "1". If it's equal, loop.

The third paragraph defines our main function: read a string in, instantiate a truth machine, and have the machine process the string.

Simple, really.

Draw, 21 bytes

start 0 1 start start

This is the version of the program where 1 is input. To change the input to 0, replace the 1 with a 0. The program where the 1 is there will produce an infinite line of marked squares towards y=+∞ starting at x=0, y=1; if the 1 was replaced, there will be only one marked square, at x=0, y=0.

Zephyr, 41 bytes

input n
print n
while"1"=n
print n
repeat

Try it online!

A main design goal of Zephyr was that code should be readable and understandable. Looks like this holds true even when the code is maximally golfed. Mission accomplished.

Forked, 22 21 bytes

^{-1 thanks to BMO}

v >%&
$ |
>-:
  |
 %<

The IP path looks like this if the inputted integer is truthy:

v
|
>-v
  |
 %<

Upon hitting % (print as integer), it goes off the edge of the playing field and wraps around, running >% infinitely.

It takes this path if the inputted integer is falsy:

v >%&
| |
>-^

It prints % 0 and then exits &.

Wumpus, 6 bytes

Iv=O=:

Try it online!

Explanation

In Wumpus, the IP gets reflected off the program boundary (instead of wrapping around or terminating). Since there is no redirecting control flow in this program, the IP simply bounces back and forth, executing a loop with loop body

Iv=O=:=O=v

Let's go through this:

I   Read an integer N from STDIN. On subsequent iterations, this will push a zero.
v   Bitwise OR. On the first iteration this ORs the input with an implicit zero
    which does nothing. On subsequent iterations, this gets rid of the zero that
    was just pushed.
=   Duplicate the input.
O   Print it to STDOUT.
=   Duplicate it again.
:   Compute N/N. For input 0, this ends the program, due to the attempted division
    by zero. For input 1, this just gives back 1.
=   Duplicate the input.
O   Print it to STDOUT.
=   Duplicate the input.
v   Bitwise OR. Just gets rid of one copy of the input.

C (gcc) , 42 bytes

main(t){gets(&t);do puts(&t);while(t-48);}

Try it online

Forte, 49 60 bytes

3LET5=5+(0*4)
4INPUT0:LET6=6-(0*4)
5PRINT0:LET3=3+(0*4)
6END

Try it online!

Forte is a weird and wonderful language with BASIC-like syntax and an execution model based on redefining integers. It has no conditional or looping constructs; to get conditional or looping behavior, you have to redefine the line numbers your program uses.

How?

Here's the code with better spacing:

3 LET 5=5+(0*4)
4 INPUT 0 : LET 6=6-(0*4)
5 PRINT 0 : LET 3=3+(0*4)
6 END

If the user inputs a zero to this program, the three LET statements don't change anything, and the program boils down to PRINT 0 : END.

If the user inputs a one... it gets interesting.

3 LET 5=5+(0*4)

The first time around, no numbers have been redefined yet; this line calculates 5+(0*4) and assigns that to 5. Nothing changes.

4 INPUT 0 : LET 6=6-(0*4)

INPUT 0 reads a number from the user and redefines 0 as that number. Suppose the user enters a 1. Every time 0, or a value of zero, occurs from now on, it will be changed to 1. For instance: LET 6=6-(0*4) now is calculated as LET 6=6-(1*4), which redefines 6 to be 2. This changes the END statement's line number to 2, which moves it out of the way of the program, allowing an infinite loop.

Redefinitions: 0->1; 6->2

5 PRINT 0 : LET 3=3+(0*4)

First, this line prints 1 (the value that 0 now represents). Then, 0*4 is now 1*4, so we have LET 3=7.

Redefinitions: 0->1; 6->2; 3->7

Next, we increment the instruction pointer and execute the command on line 3 7:

3 LET 5=5+(0*4)

which redefines 5 to be 5+4...

Redefinitions: 0->1; 6->2; 3->7; 5->9

... and we execute line 5 9:

5 PRINT 0 : LET 3=3+(0*4)

which should be read (with substitutions) as 9 PRINT 1 : LET 7=7+(1*4). We print another 1 and change 7 to 11, which means we execute the original line 3 again, and so forth.

For those who are still confused, read the Esolangs article or ping ais523 (the language's inventor!) in chat.

AWK, 20 bytes

{do{print}while($0)}

This is the first thing I came up with. I tried to come up with something clever more clever but they were all longer.

Try it online!

FALSE, 12 11 bytes

^'0-[$.$]$#

Dreaderef, 11 bytes

5*1 1 5?8-1

Takes input from the command-line arguments. Try it online!

Explanation

This program consists of eight numbers. These numbers are grouped into instructions; each instruction consists of a label, which is the first number, and zero or more arguments, which follow the label. Instructions with different labels can have different numbers of arguments, but the parsing of instructions happens at execution time (which allows self-modification). The numbers in the program are written to the tape from position 0 at the beginning of the program; each label and argument occupies its own cell, and the instruction pointer occupies the cell at location -1.

5 *
1 1  5
? 8 -1

Dreaderef's preprocessor allows you to write aliases that stand in for numbers representing instruction labels. Using aliases makes the program look like this:

0.   numo  *
2.   deref 1  5
5.   ?     8 -1

(The leading numbers are position labels and are treated as comments.) Before the program executes, * is replaced with the input integer.

0.   numo  *

The first instruction is numo, which outputs its argument (either 0 or 1) in decimal without a trailing newline.

2.   deref 1  5

deref reads the tape at the position indicated by its first argument. It then writes that value to the tape at the position indicated by its second argument. This means that here deref copies cell 1 (the input integer and argument to numo) to cell 5 (part of the next instruction).

5.   ?     8 -1

This instruction is interesting in that the label is dynamically generated by the previous instruction (? is an alias for 0 in Dreaderef, but it is intended to convey that a given cell is uninitialized and will not be read until it is written to). During execution, it will be set to either 1 or 0 depending on the input integer. Proceeding from here requires some knowledge about what labels map to what instructions:

• The instruction with label 0 is end, which terminates execution.
• The instruction with label 1 is deref.

If the input integer was 0, the end instruction causes the program to terminate, and the other two numbers are ignored.

If the input integer was 1, the instruction looks like this:

5.   deref 8 -1

Cell 8 is past the end of the program, meaning that its value defaults to 0. The 0 is copied into cell -1, which is Dreaderef's instruction pointer. This means that execution jumps back to position 0, which is the start of the program. Because * is read before execution of the program, the same input (1) is reused, and the program outputs and loops again.

Retina, 9 7 bytes

/1/+>G`

Try it online!

Explanation

The stage G` itself is really a no-op (it's a Grep stage with an empty regex, which always matches). So it's all in the configuration. > prints the result of this stage (which is just the input) and /1/+ wraps it in a loop which runs as long as the string contains a 1. There's also implicit output at the end of the program. So we go through these two possibilities:

• If the input is 0, the /1/ condition fails, so the loop is never run. Instead, the program terminates, and the 0 is printed at the end.
• If the input is 1, the /1/ condition matches, so the loop gets executed. The loop iteration itself does nothing but print that 1, so the string's value won't change and the loop will continue indefinitely.

Acc!!, 39 37 bytes

N
Count i while _%2-i%2+1 {
Write _
}

Try it online!

This takes input through N, then prints the input _ until the equation _%2-i%2+1 is 0. This looks like:

48
  48%2-0%2+1 => 1
  48%2-1%2+1 => 0
  48%2-2%2+1 => 1
  48%2-3%2+1 => 0
49
  49%2-0%2+1 => 2
  49%2-1%2+1 => 1
  49%2-2%2+1 => 2
  49%2-3%2+1 => 1

This is shorter than the easy approach (39 bytes):

N
Write _
Count i while _%2 {
Write _
}

Try it online!

;#+, 28 bytes

;;;;;;;;~*~-(;~;;;;;;~)~p(p)

Try it online!

;;;;;;;;~*~-(;~;;;;;;~)~p(p)
;;;;;;;;                      set acc0 = 8
        ~*~                   set acc1 = input
           -(;        )       while(acc0--)
              ~;;;;;;~            acc1 -= 6
                              this leaves us with a `0` or `1` values for character input
                       ~p     print acc1
                         ( )  while(acc1)
                          p       print acc1

Pyt, 5 bytes

`Đƥłŕ

Explanation:

`  ł     (Do ... while top of stack is true)
 Đ       Duplicate top of stack
  ƥ      Print top of stack
    ŕ    Pop top of stack and discard

Try it online!

SNOBOL4 (CSNOBOL4), 38 bytes

	N =INPUT
L	OUTPUT =N
	GT(N) :S(L)
END

Try it online!

	N =INPUT	;* read input as n
L	OUTPUT =N	;* print input
	GT(N) :S(L)	;* if n > 0, goto L
END

Evil, 74 bytes

fjzaeeeaeeawbmxruuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuusbaeeeaeew

A program that will request for a character of input. Every lowercase letter corresponds to a different instruction. Here's an analysis.

f: goes Forward in the program and searches for the closest marking character, or m. This skips all of the code that will continuously output 1 to stdout.

jzaeeeaeeawb: Continuously output 1 to stdout. The character b searches Backwards for the marking character. However, at this point the marking mode is set to 'alternate', so instead of searching for m, it's searching j, which is at the beggining. The random amount of es with a and z set the counter, or accumulator, to the ASCII representation of 1. w would do what you might think: Write the value of the accumulator to stdout.

mxr: This is executed right after f. The marking character has now been found, and we continue with x, which switches the marking mode from 'standard' (m) to 'alternate' (j). Then, r Reads stdin for a character and sets the accumulator to the ASCII representation of the input, which would be either 48 for 0 or 49 for 1.

uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuusb: Each u decrements the accumulator. The whole operation brings the accumulator down from 48 to 0 or 49 to 1. This is crucial for the following command; the letter s will Skip the next command only if the value of the accumulator is 0. That next command searches backwards for j, which goes all the way back to outputting 1 to stdout. Note that I could probably shorten the amount of bytes here by replacing some us with es, which weave the accumulator.

aeeeaeew: Now, if the accumulator had hit 0, this snippet puts the accumulator back to 48, or 0, and w Writes the accumulator value to stdout.

Original interpreter in Java: http://web.archive.org/web/20070906133127/http://www1.pacific.edu/~twrensch/evil/evil.java

Whispers, 34 bytes

> Input
>> Output 1
>> DoWhile 1 2

Try it online!

JavaScript, 26 bytes - Variation of Solomon Ucko's answer

I find it weird how I can't comment, but I can edit his answer...

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

Swift, 55 bytes, 54 bytes, 53 bytes

if readLine()=="1"{while 1>0{print(1)}}else{print(0)}

I tried to use ternary for a while but couldn't get it compiling. Maybe someone else will or it is just impossible. I'm open for tips or advice :)

GolfScript - 13 bytes

~{.}{.p}while

Basically a

while(arg){
    print(arg)
}
print(arg)

GolfScript doesn't have a real-time STDOUT, everything is printed from the stack to the console at the end of the execution, it has to be stopped manually.

Husk, 5 bytes

¶?∞;I

Try it online!

Explanation

 ?  I  -- if the input is truthy
  ∞    --   repeat it infinitly many times
   ;   --   else create singleton list
¶      -- join by newlines

Thanks @H.PWiz for golfing off 1 byte!

><>, 6 Bytes

::n?!;

Input is assumed to be on the stack. It's duplicated twice, printed, and checked if it's non-zero. If it's non-zero, skip the end program command and loop around.

Note that this does not print any spacing between the 1s.

Bitwise, 52 46 38 bytes

^{Oh, that's right, I made the interpreter not care about the return value for I/O. It was definitely not for code golf.}

IN 1 &1
OUT 1 &1
XOR 1 &48 2
JMP &-3 2

Try it online!

Translated to C (labels added instead of literal jumps for clarity):

IN 1 &1        mem[1] = getchar();
LABEL &1       label_1:
OUT 1 &1         putchar(mem[1]);
XOR 1 &48 2      mem[2] = (mem[1] ^ 48);   // ^ is equivalent to !=
JMP @1 2       if (mem[2]) goto label_1;

JavaScript (ES5), 40 bytes

function(x){x?while(1)alert(1):alert(0)}

Java, 126 bytes

public static void main(String[]a){int n=new Scanner(System.in).nextInt();while(n==1)System.out.print(n);System.out.print(n);}

Ungolfed (+ comments with explanation)

public static void main(String[]a){
    int n=new Scanner(System.in).nextInt();//Create the scanner and get the next integer input
    while(n==1)System.out.print(n);//if n == 1, print 1
    //else exit. If there is nothing that happens the java program automatically exits
    System.out.print(n);//But first print out 0
}

The reason behind using a scanner is me not being able to get the desired behaviour using System.in.read(). Typing 1 exited the program as if it was something else being typed. System.in.read() returns an int as 0-255 representing the byte it received, meaning 1 != 1 with that method.

Duck Duck Goose, 911 bytes

duck duck duck goose

duck

duck duck duck duck duck duck goose

duck

duck duck duck duck duck duck

duck duck duck duck duck duck duck duck duck duck duck goose

duck

duck duck duck duck duck duck duck duck

duck duck duck duck duck duck duck duck duck duck duck goose

duck duck

duck duck duck

duck duck duck duck goose

duck duck duck

duck duck

duck duck duck goose

duck



duck duck duck duck duck duck duck duck duck goose

duck duck

duck

duck duck duck duck duck duck duck duck duck duck duck goose

duck duck duck

duck duck

duck duck duck goose

duck

duck

duck duck duck duck duck duck duck duck duck goose



duck

duck duck duck duck duck duck duck duck duck duck goose

duck

duck duck duck

duck duck goose

duck duck duck

duck

duck duck goose

duck

duck goose



duck duck duck duck duck duck duck duck duck duck goose

duck

duck duck

duck duck goose

duck duck duck

duck goose

Includes 2 trailing newlines. I can't remove the newlines, they are instructions.

Implicit, 5 4 bytes

$(%)

Try it online! Prints 00, which is equal to 0 Pretty simple:

$(%)
$      « integer input               »;
 (.)   « do..while top of stack true »;
  %    «  print top of stack         »;
       « implicit integer output     »;

Java (OpenJDK 8), 103 bytes

interface J{static void main(String[]a){int n=Integer.decode(a[0]);do System.out.print(n);while(n>0);}}

Try it online!

ungolfed (although Java doesn't need it that much):

interface J{
    static void main(String[]a){
        int n=Integer.decode(a[0]);
        do System.out.print(n);
        while(n>0);
    }
}

Using Interface, as since Java 8 interfaces can have function bodies. Because they are always public we are saving some chars. The question states

take input from STDIN or an acceptable alternative

and for me the run arguments are an acceptable alternative.

Note that Integer.decode() throws a NumberFormatException, but input will always only be 0 or 1.

Python 2, 50 39 bytes

Don't know why nobody mentioned I could just write input()

i=input()
while(int(i)):print 1
print 0

Very simple, if the input is 1, will continuously print 1 and cannot reach the print 0. If it is 0, the while will never fire.

Try it online!

JavaScript, 62 34 33 31 bytes

Golfed:

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

Ungolfed:

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

-1 byte thanks to JimmyJazzx's answer
-2 bytes and bug fix thanks to kamoroso94's comment

MATLAB, 39 37 bytes

Two years later, two bytes golfed off.

disp(input('')),while ans disp(1),end

This was a bit shorter than the original one, since it avoid having anything after end, thus saving a comma or semicolon, and it saves one more byte by avoiding the separate call to disp(0).

CMD, 30 bytes

:a
echo %1
if %1==1 (goto a)

Pretty straight-forward

4, 28 bytes

3.61448701501132011483250194

Try it online!

Explanation:

3.            Start Program
6 14 48       Set the value of memory cell 14 to 48 (the ASCII code of '0')
7 01          Read in one byte to memory cell 01
5 01          Print byte from memory cell 01
1 32 01 14    Set the value of memory cell 32 to cell 01 - cell 14
8 32          Start loop: if cell 32=0, skip to the end
5 01          Print byte from memory cell 01
9             End loop
4             End program

INTERCAL, 141 bytes

PLEASE WRITE IN .1
DO (1020) NEXT
DO (1) NEXT
DO COME FROM (3)
(3)DO READ OUT #1
(2)PLEASE RESUME .1
(1)DO (2) NEXT
DO READ OUT #0
DO GIVE UP

Try it online!

Pyth, 5 bytes

Like my Python answer, but in Pyth

WQ1)0

Explanation:

WQ1)      While Q, print 1. 1 = true, 0 = false; end While
0         Print 0

If input is 1, 0 is never reached, if input is 0, 1 is never reached.

Try it online!

Thotpatrol, 311 219 bytes

Credit to @MickyT for shaving 92 bytes off

📡JACKING IN📡
💦DM💦 THAUGHTY JO
🕵 📧🍆 JO
🕵 🍑📧 JO
❤PRIME ASSETS❤ JO INTERROGATE ©1©
🕵 🍑📧 JO
🎧INTERCEPT MALIGNANT COMMUNICATIONS🎧
🇺🇸REPORT UNPATRIOTIC ACTIVITY🇺🇸

This is a fairly uninteresting truth machine the core structure is as follows:

input a
print a
while a == 1
    print a
end while

Here is a link to an implementation in Java: https://github.com/MindyGalveston/thotpatrol-

Whitespace, 40 bytes

Note that the only valid characters are space, tab, and linefeed, so they are represented here with S, T, and L, respectively. Comments are also given.

I used this interpreter to write and test this program (warning: crashes browser window upon input of 1).

SS L   # push 0
SLS    # duplicate
TLTT   # readi
TTT    # retrieve
LSS L  #label "" (blank label name, why not?)
SLS    # duplicate
SLS    # duplicate
TLST   # printi
SS STL # push 1
TSST   # subtract
LTS L  # jz label "" (jump to blank label if input-1=0)

Three consecutive linefeeds (LLL) are usually required to end program execution at a point, but that interpreter doesn't seem to mind if you leave them out. If they have to be added in, the score would instead be 43 bytes.

Excel VBA, 20 Bytes

Anonymous VBE immediate window function that takes input from range [A1] and output 1, infinitely if [A1] else 0

While[A1]:?1:Wend:?0

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

HP48's RPL, 22.5 bytes

« WHILE DUP REPEAT DUP END »

Since there is no such thing as STDIN or STDOUT on the HP48, the input is taken on the stack, and one "0" or an infinity of "1"s are pushed back on the stack.

If you try it, you will have to kill the program in order to see the "1"s since the stack is not refreshed while the program is running (Just press the "ON" button).

PS: The HP48's memory is made of 4 bits words, hence the non-integer bytes size

8th, 58 bytes

Code

: f getc '0 - dup 0 1 between if repeat dup . while then ;

Explanation

: f - Start of word definition

getc - Get input from STDIN

'0 - - Subtract 0's ASCII code to determine numeric input

dup - Duplicate result to be used to run loop

0 1 between if - Check if input is either 0 or 1

repeat dup . while - Print either 0 once or 1 ad infinitum

then ; - Exit word

If input is not either 0 or 1, exit with no output. At the end of the program the stack is not empty.

Assembly (as, x64, Linux), 128 bytes

.data
i:.byte 0
.text
mov $3,%eax
mov $0,%ebx
mov $i,%ecx
mov $1,%edx
int $128
l:mov $4,%eax
mov $1,%ebx
int $128
cmp $49,i
je l

Try it online!

Explanation

.data
i:.byte 0       ;Declare variable i with type byte

.text
mov $3,%eax
mov $0,%ebx
mov $i,%ecx
mov $1,%edx
int $128        ;Make system call read(eax=3) from stdin(ebx=0) with an address(ecx) and length in bytes(edx)

l:mov $4,%eax   ;Declare section/label l
mov $1,%ebx
int $128        ;make system call write(eax=4) to stdout(ebx=1). There is no need to reassign ecx or edx
cmp $49,i       ;compare the value at the address i to 49(ascii value of "1")
je l            ;jump to label l if equal

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.

Python 2, 50 bytes

a=bool(input())
print int(a)
while a: print int(a)

Try it online!

Cubically, 29 28 bytes

$!7{%0&}U3D1R3L1F3B1U1D3(%1)

Try it online! (May not work for a little while after posting due to TIO's version) Explanation:

$                             read integer as input
 !7{...}                      if falsy
    %0                         print 0th face
      &                        exit
        U3D1R3L1F3B1U1D3      quickest way to get 1 onto a face
                        (..)  forever
                         %1    print the first face

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

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

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

Lean Mean Bean Machine, 18 bytes

 O
 i
 ?
 _
u $
  ~

Explanation:

 O    - Spawns a marble at program start
 i    - Fetch input and assign to marble's value
 ?    - If marble's value is truthy, spin right, else spin left
 _    - Move in direction of spin
u $   - u terminates marble and prints value, $ prints value
  ~   - Trampoline, move marble to top of field on same column

Yep, Mayube's at it again making another language that'll probably be abandoned in a week. This one's not at all golfy though, and inspired by this challenge

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

Noether, 5 bytes

0(IP)

This works very simply:

0 - Push 0 to stack
( - Pop value of stack and loop until top of stack equals popped value
I - Push user input to stack
P - Print top of stack
) - End loop

Unless you want your browser to freeze, I would advise against testing this online at https://beta-decay.github.io/noether

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.

Decimal, 32 bytes

81D301110D412D590D5111D91D30191D

Pretty simple. Explanation:

81D   ; builtin to read INT to stack
301   ; print
110D  ; push INT 0
412D  ; compare for equality, pop values used, push result
5     ; if truthy
90D   ;  exit
5     ; endif
111D  ; push INT 1
91D   ; declare jump 1
301   ; print
91D   ; exit

Try it online!

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

Taxi, 617 bytes

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Crime Lab.1 is waiting at Writer's Depot.Go to Writer's Depot:s 1 r 1 l 2 l.Pickup a passenger going to Crime Lab.Go to Crime Lab:n 1 r 2 r 2 l.Switch to plan "z" if no one is waiting.Pickup a passenger going to Cyclone.Go to Cyclone:n 4 l 2 l.[r]Pickup a passenger going to Cyclone.Pickup a passenger going to Post Office.Go to Post Office:s 1 l 2 r 1 l.Go to Zoom Zoom:s 1 r 1 l 2 r.Go to Cyclone:w.Switch to plan "r".[z]0 is waiting at Writer's Depot.Go to Writer's Depot:n 4 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.

Try it online!

There are shorter programs but they kept running out of gas. Here's the ungolfed version:

Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to Crime Lab.
1 is waiting at Writer's Depot.
Go to Writer's Depot: south 1st right 1st left 2nd left.
Pickup a passenger going to Crime Lab.
Go to Crime Lab: north 1st right 2nd right 2nd left.
Switch to plan "z" if no one is waiting.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 4th left 2nd left.
[r]
Pickup a passenger going to Cyclone.
Pickup a passenger going to Post Office.
Go to Post Office: south 1st left 2nd right 1st left.
Go to Zoom Zoom: south 1st right 1st left 2nd right.
Go to Cyclone: west.
Switch to plan "r".
[z]
0 is waiting at Writer's Depot.
Go to Writer's Depot: north 4th left 2nd left.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.

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.

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;);

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 *

REXX, 33 bytes

pull n
do while n
  say n
  end
say n

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.

Deadfish i, 16 bytes

0<+I]
1<.
2<+.[2

As this language does not support input, you must replace I with either an empty string (=0) or + (=1). The program works on my interpreter, which may or may not work like the author of the language intended.

I'm not sure how to score this program. Currently the byte count is for 1-variant.

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.

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.

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

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

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

Chip, 6 bytes

e*faAs

Chip is a 2D language that behaves a bit like an integrated circuit. It takes input, one byte at a time, and breaks out the bits to individual input elements. Output stitches the values of output elements back together into bytes.

Let's break this down:

* is a source signal, it will send a true value to all adjacent elements. e and f correspond to the fifth and sixth bit of the output. So, e*f produces binary 00110000, which is ASCII char "0".

Now, A is the first bit of input and a is the first bit of output, so aA copies that bit from input to output. So, when combined with e*f, an input of ASCII "0" produces "0", and "1" produces "1". (There is no interaction between f and a, since neither produce any signal.)

The s on the end, when activated by a true signal, will prevent input from advancing to the next byte, meaning that the whole thing will run again with the same input.

Since the first byte of "0" is zero, it won't activate this element and the program will print "0", and thereby exhaust its input, which allows it to terminate. "1", however, activates this element, which means that "1" is output, but not consumed on the input, allowing the cycle to repeat indefinitely.

If values 0x0 and 0x1 are used for output, rather than ASCII, we can eliminate the e*f part, resulting in only 3 bytes:

aAs

If the zero must terminate itself, rather than expecting stdin to close, we get the following, which inverts the first byte with ~, and passes the result to t, which terminates the program (10 bytes):

aA~te*f
 s

(t also produces no signal, so there is no interaction between t and e.)

Threead, 5 bytes (Noncompeting)

I[o]o

read, while not 0 output, output

Try it online!

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]

Japt, 4 bytes

ÿ ©ß

As of 25 Oct 2016, I have implemented the recursion feature ß, which calls the entire program as a function. This is used here like so:

      // Implicit: U = input integer
ÿ     // Since there's no value to work on, use U here. Alert U and return it.
  ©   // If U is truthy (1),
   ß  //   run the program again with the same inputs.

Test it online!

PlatyPar, 2 Bytes

wA

Explanation:

Implicit: push input to the stack.

w: while last item. A: alert last item.

If you give it something truthy, while(stack[-1]) goes on infinitely. If not, it skips that, and alerts the last item of the stack implicitly (falsy).

Try it online! Press cancel instead of ok on the alert if you want to stop the loop after giving a 1.

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.

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

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

stacked, 10 bytes

[:out]loop

Assumes input is on TOS. Try it here!

Loops [:out] while TOS is truthy, repeating at least once. Surround with [] for a proper function.

PHP, 24 25 27 bytes

<?=do{echo$i;}while($i); // Also 24b
<?=$i;for(;$i&1;)echo$i; // 24b, added PHP's short echo, actually made it less

echo$i;for(;$i&1;)echo$i; // 25b
echo$i;while($i&1)echo$i; // 25b, based on 0/1 as truthy/falsy

for(;$i&1;){echo$i;}echo$i; //27b

This works by setting register_globals=on (which you shouldn't) and that going to the page with ?i=1 or ?i=0 in the url.

The logic is that the first echo will always output the input, and if it's one it'll loop until something gives in (because of & returning 1 (=truthy) for 1).

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

T-SQL, 22 bytes

s:print @ if @>0goto s

requires a variable with the name @, e.g.:

DECLARE @ BIT = 0

s:print @ if @>0goto s

BrainInt, 5 bytes

&^[!]

Explanation:

&     # Take user input, and store in current cell
 ^    # Boolean-ate current cell (nonzero -> 1, 0 -> 0)
  [ ] # Loop (while cell != 0)
   !  # Print current cell as integer

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.

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.

Doxical, 11 bytes

[^]A{AdA}dA

First answer in Doxical!

Doxical is my new language, which is designed to be difficult to program in, and is grid-based. Also, there aren't any newlines in Doxical code, so every Doxical program is a one-liner.

Explanation (note that there are no comments in Doxical, this is just for clarification):

[^]         # Asks for user input, if input = 1, puts 1 into the Value,
            # If 0, puts 0 into the Value
   A        # Declares variable A as the Value
    {A  }   # While A > 0:
      dA    # Output A in decimal (1 forever)
         dA # Outside the while loop, output A in decimal (0 once)

Yes, "Value" is meant to be capitalised, see docs for more details.

D - 87 bytes

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

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.

Dip, 6 bytes

?_1p?0

^{Body must be at least 30 characters; you entered 19.}

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)

JAISBaL, 15 6 bytes

˗Y1˄N0

Explanation:

# \# enable verbose parsing #\
while               \# [0] start while loop #\
    printnumln 1    \# [1] print 1 #\
end                 \# [2] end current language construct #\
printnum 0          \# [3] print 0 #\

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]);

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.

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.

ABCR, 7 bytes

iAo7ox

ABCR is a stack-based programming language that allows a few simple operations on any of its three stacks and a single register.

Explanation:

i        Numerical input.  Places result in register.
 A       Queue register value to queue a.
  o      Output peek(a) as a number.
   7     while(register){
    o      output peek(a) again
     x   }

Moorhen 1 (or original creators version 1 here), 38 bytes

The original language creator has decided to add new instructions, which would change the existing ones. Hence, this language is in Moorhen version one

op pa id el pa id el ai op id ai pi ai

Note this doesn't print if input is 1, because printing only happens at halting, so it just puts infinite ones on stack

Explanation:

Commands can be (most of) all english words, and the command they execute depends on md5 hash mod 7. I used some length two words that corresponded to each of the seven commands

re: push 0

op: increment ToS

pa: decrement ToS

el: rotate stack (place ToS on BoS)

pi: dupe ToS

id: peek TOS, skip if it is non-zero

ai: flip pointer direction

there are two main segments of code

op pa id el pa id el 

ai op id ai pi ai

op pa id el pa id el

This code, when run forwards, will have the pointer leave to the right side, with the initial value on the stack, minus one (0 -> -1, 1 -> 0). When run backwards, with [-1] as stack, it leaves the to the left side with [0] as the stack. When it leaves to the left, it will print the stack, items joined with spaces, so it will print 0. It uses "nops", commands that don't do anything under certain circumstances, or are a pair of inverses.

(the reason the comments look funny is because the interpreter ignores non-words, including real words that are hyphenated)

op pa                nop-when-running-forwards
      id el          nop-with-only-one-value-on-stack-and-running-forward
            pa       decrement-
               id el nop-with-only-one-value-on-stack-and-running-forward
                     [go to next part of code]

with all these nops forward, its essentially pa when running forward. However, backwards, with -1 on stack:

el                   nop-with-only-one-value-on-stack
   id pa             skip-pa,when-TOS-nonzero(-1,is-non-zero)
         el          nop-with-only-one-value-on-stack
            id pa    skip-pa,when-TOS-nonzero(-1,is-non-zero)
                  op increment-
                 [end,print-stack(with,-1,coming-in,print-0)]

With -1, backwards, it's essentially op (then implicit print)

The code that is at the right of that code:

ai op id ai pi ai

given -1, it will just reflect it back. Given 0, it will increment it, then enter a loop of duping ToS, which will be 1.

ai            reflect-pointer-direction-if-TOS-non-zero
   op         increment-
      id      skip-next-command-if-non-zero. This-command-skips-into-the-middle-of-a-loop:

        ai pi ai    this-is-the-loop. pointer-starts-on-pi,because-it-skipped-the-first-ai

           Here is a visualisation of how it executes
           pi       dupe-TOS (1)
              ai    reverse-if-ToS-is-nonzero (it is)
           pi       dupe-TOS (1) -again
        ai          reverse-if-ToS-is-nonzero (it is)
           pi       dupe-TOS (1) -again
           ...      this keeps happening

LI, 4 bytes

?iRP

Explanation:

?i       if input is truthy (1):
  RP      Recurse the program with the printed (implied) input
         Else (0 is the only falsy value in LI) return (implied) input, 
              which is implicitly printed.

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

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.

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

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.

Turtlèd, 7 bytes

Turtlèd cannot output without halting, so the truth machine writes down infinite ones, like a turing machine's implementation might, onto the grid if input is 1.

!.{1r.}

Explanation:

!                  input into string variable

 .                 write current char of string var (by default the first char)
                   for a single char input, this will be the entire input

  {1  }            while the current char is 1
                   this loop is never run if input is zero, but if it is one, it will run
                   forever, as the last action of the loop writes 1 to the current cell

    r              move right, so that we constantly move right to write ones to infinite
                   cells

     .             write current char of string var (still by default the first char)
                   this is 1 if the loop was run at all. because the loop runs while the
                   current cell is one, this will cause the loop to rerun every time.

       [implicit]  output grid at end of program, program will only end if input isn't 1

dc, 13 12 bytes

?[pd1=@]ds@x

Run:

dc -f truth_machine.dc <<< "1"

Adding to the diversity of languages used, I present a dc solution that works as follows:

?              # reads the input and pushes it on top of the stack
[pd1=@]ds@x    # stores the macro command [pd1=@] into register '@' and executes it
   p           # prints the value on top of the stack
   d           # makes a duplicate that is pushed on top
   1=@         # pushes 1, pops two numbers and if they are equal, the macro from
               #register '@' is executed (again), thus making an infinite cycle

Straw, 17 bytes

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

Cubix, 5 6 bytes

Cubix is @ETHproductions new 2 dimensional language where the commands are wrapped around the faces of a cube. Online interpreter Thanks to @ETHproductions for the saving.

!I\@O

This ends up expanded out to the cube

  !
I \ @ O
  .

This starts with the I command. Input an integer onto the stack.
\, redirects the instruction pointer down over the no op.
O, outputs the numeric value of top of stack.
!, skip the next command (@) if top of stack true. This will jump the \ redirect if 1
\, redirects the instruction pointer to the @ exit program.

This takes advantage of the fact the stack isn't popped by the O ? ! commands.

Woefully, 266 bytes

First answer in this language!

It's called woefully because the bytecounts are saddening

Woefully is a 2d language with no conditionals, except for the notz/bool command (pop a, push 1 if not zero, else push zero), and combining this with the move char pointer command yields control flow. In a truth machine, the values entered are already zero or one, and are only of two values, so is less complex than some other conditional programs, which kind of defeats the purpose of the truth machine :P

There are two pointers, the instruction pointer (ip), and the char pointer (cp), and it's hard to explain in one post, but the ip goes through the paths, cp stays stationary unless moved by instructions the ip executes.

Woefully has 2 stacks, all pushing is to A, except dupe and AtoB

| || ||||| |
|| |||||| |
||| |||| |
|||| || |
||||| || |
||||| ||| |
||||| |||| |
||||| ||||| |
||||| |||||| |
||||| |
|||||| |
||||||| |
|||||| |
||||| |
|||| |
||| |
|| |
| |
|| |
||| |
||| |
|||| |
||| |
|| |
| |
| |
| |
| |
| |
|| |
||| |
|||| |
||||| |
|||||| |

Try it online!

Explanation (difficult from the size) Execution starts at the v, at the A path:

V   FI    \/  V shows initial char pointer pos, F the pos after movement
|A||X|||||Z|   if input is zero, I if it is 1. The path marked by \/ won't
||A||||||Z|    be executed until the first part has been done, and then only
|||A||||Z|  #X path halts program                          if input is zero 
||||A||Z|   # A path pushes input     #Z path pushes one
|||||A||O|
|||||E|||O|
|||||E||||O|   #E path dupes, by peeking top of a stack, pushing to b stack
|||||E|||||O| #O path outputs TOS of A
|||||E||||||O|
|||||E|    ^End of path, go back to char pointer, still over this path
||||||F|      #F path pops a, moves the char pointer
|||||||F|
||||||G|
|||||G|
||||G|
|||G|      #G path pushes 4
||G|
|G|
||H|   #H pops a, moves char pointer by a. the char pointer is (again)
|||H|  #now over F or I, depending on input
|||X|  X are nops
||||X|
|||L|   L path pushes 1
||L|
|L|
|V| V path multiplies both TOS (A and B), pushes to A
|V|
|V|
|V|
||O|
|||O|    O path outputs tos of A
||||O|
|||||O|
||||||O|
End of path, go back to the char pointer. If input was zero, the char
pointer will be over the halting path, so program over, otherwise it's over
the next char, and goes to the infinite one river

Note this is somewhat simplified: paths overlap on the corners they meet at.

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"));
    }
}

Seriously, 4 3 bytes

_{Crossed-out 4 is still 4 :(}

,W■

, reads a value from STDIN. W starts a loop that runs while the value on top of the stack is truthy, with the body ■. ■ prints the top stack element without popping. The loop is implicitly closed at EOF.

On input of 0, the loop never executes (since 0 is falsey), and the program ends at EOF, automatically popping and printing every value on the stack. On input of 1 (or any value that is not 0, "", or []), the loop runs infinitely.

In Actually, the leading , is not needed (thanks to implicit input), bringing the score down to 2 bytes.

Python 2, 33 bytes

Golfing suggestions welcome :)

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

Ru, 11 9 bytes

»Ϟα;¿{»α}

This look way too long

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

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

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($_)}

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.

Churro, 100 95 bytes

{========={o}{*}======}{*}======}{={*}{={o}{={o}{={*}{={o}{======={*}{==={*}{======={*}{===={*}

Explanation

Churro is a stack-based esolang where the only syntax element is, well, churros! Or rather, ASCII-art representations of churros. An example of such a churro is {o}====}.

In Churro, each churro has three characteristics:

1. Its orientation; whether it's facing left ({o}====}) or right ({===={o}).
2. Its filling; whether it's filled ({*}==}) or not ({o}==}).
3. Its tail length; the number of =s in the churro is the length of its tail.

Left-facing churros are integer literals; their tail length is their value, while their filling status is their sign. Filled churros are negative, while unfilled churros are positive.

Right-facing churros are operators; their tail length is which operator they represent, according to this table:

{{o}           pop A; discard A
{={o}          pop A, B; push B + A
{=={o}         pop A, B; push B - A
{==={o}        pop A; if A == 0, jump to churro after matching occurrence of {==={o}
{===={o}       pop A; if A != 0, jump to churro after matching occurrence of {==={o}
{====={o}      pop A, B; store B in memory location A
{======{o}     pop A; push the value in memory location A to stack
{======={o}    pop A; print A as an integer
{========{o}   pop A; print A as an ASCII character
{========={o}  read a single character from STDIN and push it to the stack
{=========={o} exit the program

Filled operator churros have the same behaviour, but peek at the stack instead of popping from it.

With that, here's the ungolfed, explained version of the Churro truth-machine:

{========={o}    read char from stdin
{*}======}       push -6
{*}======}       push -6
{={*}            push -6 + -6 = -12
{={o}            pop -6, -12; push -6 + -12 = -18
{={o}            pop -6, -18; push -6 + -18 = -24
{={*}            push input + -24
{={o}            pop -24, input + -24; push input + -48 (convert char to int)
{======={*}      print input as integer
{==={*}          if input == 0 jump to matching churro
{======={*}      print input as integer
{===={*}         if input != 0 jump back to matching churro

I'm using TheLastBanana's Haskell interpreter to interpret this. Installation instructions can be found there.

Finally, here's the "pure" version (no comments, line length 80, spaces between churros), as output by purify truth.ch:

{========={o} {*}======} {*}======} {={*} {={o} {={o} {={*} {={o} {======={*} 
{==={*} {======={*} {===={*} 

Saved 5 bytes thanks to Martin Ender!

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

Perl 6, 28 bytes

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

Shakespeare Programming Language, 189 bytes

.
Ajax,.
Ford,.
Act I:.
Scene I:.
[Enter Ajax and Ford]
Ford:
Listen to thy heart.
Scene II:.
Ford:
Open thy heart.Is cat as big as you?If so, let us return to scene II.
[Exeunt]

Ungolfed:

The Construction of a Truth-Machine in Denmark.

Hamlet, the input.
Ophelia, who orders him around.

Act I: A truth-machine.

Scene I: In which Hamlet learns that all he needs, he can find in his heart.

[Enter Hamlet and Ophelia]

Ophelia:
  Listen to thy heart.

Scene II: In which Ophelia proclaims her doubts about Hamlet.

Ophelia:
  Open thy heart. Is my lover as fair as thee?
  If so, let us return to scene II.

[Exeunt]

I'm using drsam94's SPL compiler + GCC to compile this.

To test:

$ python splc.py tm.spl > tm.c
$ gcc tm.c -o tm.exe
$ echo 0 | ./tm
0
$ echo 1 | ./tm
1111111111111111111111111111111111111111111111...

MarioLANG, 11 8 bytes

;:
[^
=:

This prints a space after each 0 or 1 (as has been clarified is acceptable). The program was tested in the Ruby interpreter. It's not clear whether this behaviour of ^ is according to spec, but it works consistently in this implementation.

As usual, = is just some ground for Mario to walk on.

• ; reads an integer from STDIN into the current tape cell.
• [ is a conditional. If the tape cell is 0, Mario skips the next cell (the ^), which will make him fall through the : (printing the 0), off the bottom edge and terminate the program (poor Mario). If the tape cell is 1, this does nothing, and execution continues.
• ^ is a jump command. It stops Mario from moving forward and sends him straight up one cell before he falls back down. For some reason (at least in this implementation) Mario can jump in mid-air provided there's another cell (even a space) below the jump. That means Mario repeatedly jumps into the top :, printing the 1, falls back down onto the ^ and performs another jump. This must be a feature from the popular Super Ninja Brothers spin-off.

Gaot++, 125 bytes

bleeeeeeeeeeet
bleeeet bleeeeeet
bleeeeeeeeeeeeet
bleeeeeeeeeeeeet
bleeeeeeeeeeeeet
bleeeeeeeeeeeeet
bleeeeeeeeet
bleeeeeeeet

Compressed: 11e4e6e13e13e13e13e9e8e6e

Try it online!

JQuery, 63 57 Bytes

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

Try it!

Racket, 36 bytes

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

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>

Sesos, 2 bytes

V0

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.

set numin  ; Switch to numeric input.
set numout ; Switch to numeric output.

get        ; Read an integer from STDIN and save in in the current cell.
nop        ; Set an entry marker.
    put    ; Print the integer in the current cell.
           ; (implicit jnz)
           ;     If the integer in the current cell is non-zero,
           ;     jump to the previous instruction.

Silicon, 3 bytes

I[]

Explanation:

I          Get input
[          While the top of the stack is 1
           Implicit output
]          End while
           Implicit output

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.

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);

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.

Scratch, 12 bytes

I love how Scratch can be so self-explanatory in the right contexts.

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())

Pyth, 4 3 2

Wp

There is a no! trailing space (thanks isaac :) ). The space used to be required to make the while loop compile, but Pyth has since been updated. Normally that would disqualify using it, but since this is a catalog it should be valid.

Explanation:

Wp        : implicit Q = eval(input)
W         : while
 p        : print and return the value of Q, to be evaluated as the while condition
          : Functions without enough arguments automatically use Q now
          : do nothing in the body of the while loop

Pyke, 4 bytes

​
I1r

Explanation:

print(top_of_stack) (if first run, print input())
if pop(stack):
    top_of_stack = 1
    goto_start()

Try it here!

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!

JavaScript, 27 29 bytes

for(x=prompt();alert(x),+x;);

The only interesting part is the +x which converts x to a number, otherwise the string '0' would return true.