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

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

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.

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" 

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.

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.

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 

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.

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

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 

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.

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

Turing Machine Code, 19 29 19 bytes

0 0 * * h 0 * 1 r 0 

Try it online!

Saved 10 bytes thanks to @Laikoni

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 

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 

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!

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)

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.

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.

sed, 13 bytes

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

Try it online!

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> 

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!

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.

n/t/roff, 27 bytes.

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

Defines a macro a.

Usage

.a 0 .a 1 

Try it online!

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 

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.

BASH

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

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) 

Pari/GP, 26 bytes

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

Try it online!

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.