Swift, 187 bytes

import Foundation let i = Int("\(String(data: NSFileHandle.fileHandleWithStandardInput().availableData, encoding: NSUTF8StringEncoding)!.characters.first!)")! print(i) while i>0{print(i)} 

Sadly this has to read from stdin if it can :( Would be so much smaller if I could just declare it inside...

Atari Basic, 47 bytes

If I remember the syntax correctly, it will be something like this:

1 input a$ 2 IF a$="0" THEN end 3 ? a$ 4 goto 3 

Please correct me if I'm wrong.

Python 2, 46 bytes 34 bytes

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

Basically, it takes in the input, when 1, prints forever (while loop), but if it isn't 1 (when it is zero) it prints and then exits.

This is my first answer! Yay!

PHP, 33 37 39 29 bytes

Pretty straight forward:

for($f=fgetc(STDIN);$f&print$f;); 

Runs from command line:

php truth.php 1 

Edits

• Added 10 bytes as the program must take input from STDIN if possible. Thanks to Martin Büttner for pointing it out. :)
• Saved 2 bytes by using if and for instead of while. Thanks to BLackhole
• Saved 2 bytes by placing everything into the for-loop. Thanks to fschmengler.
• Saved 2 bytes by rewriting the 2nd expression of the for-loop.

DStack, 7 bytes

04KKCKT 

I invented the language after the challenge began, but before I see it.

Java, 90 97 bytes

class T{public static void main(String[]a){while(a[0].equals("1"))System.out.println(1);}} 

I'm not sure if this counts because it takes 1 or 0 as an argument rather than STDIN. It's been emotional, either way.

Edit: The above does not print zero, the below does:

class T{public static void main(String[]a){do System.out.println(a[0]);while(a[0].equals("1"));}} 

VB.NET, 106 Bytes

Imports c=System.Console Module m Sub Main i=c.readline 1:c.Write(i) if i=1 then goto 1 end sub end module 

Straightforward, using goto instead of a loop. Compiles with Option Explicit and Option Strict Off, and Option Infer On

STATA, 31 bytes

di _r(a) m do{$a }while($a) end 

First, get input from the user and store it in global variable a. Then switch to Mata for better commands. Print the value of a and then if it is truthy (i.e. 1), go to the start of the loop. If the end keyword is omitted, unexpected end of file (end statement missing) is output to standard error. I'm not sure if that's okay.

Staq, 5 chars

'[:]: 

Explanation

' input number, put it on top of the active stack [ jump to corresponding ] if the top stack value = 0 or nonexistent : output top stack value as number ] jump back to corresponding [ if top stack value >0 : output top stack value as number 

Cardinal, 8 chars

%:> J.jN 

Explanation

% create pointer : enter number, put it on top of stack > redirect pointer to the right NOP J skip next instruction if top stack value is > 0 . output number to STDOUT j skip next instruction if top stack value is = 0 N reflect pointer to the left 

The original interpreter, written by Madk, is buggy, and some instructions are missing. I fixed the errors and recompiled the interpreter.

You can clone the fixed interpreter and readme from my GitHub repository.

Mouse16, 10 bytes

?0+[1!4\]0 

Asks for input, then coerces it to an int and tests its truthiness. Then, if it's truthy, 1 is printed and the execution jumps to the 4th byte, where 1 is printed again, and so on forever (until the stack overflows), otherwise, 0 is printed.

Pike, 94 bytes

Looks like C, but isn't C. Is interpreted. Is fast.

int main(){int x=(int)Stdio.stdin->gets();if(x!=0){for(;;){write("1");}}write("0");return 0;} 

Ungolfed:

int main() { int x = (int)Stdio.stdin -> gets(); if (x != 0) { for(;;) { write("1"); } } write("0"); return 0; } 

CJam, 16 bytes

qi1={"1o_~"_~}&0 

AnnieFlow, 6 bytes

010[!" 

Here is the decompressed and more readable program:

010101101100000110111111 

Breakdown:

010 there are two characters, 0 and 1 1 input is accepted, first symbol popped will be whatever it is 011 there are two stacks, 0 for output, 1 for input 011 1 push occurs when 0 is popped from 1 00 that push is symbol 0 on stack 0 (output 0) 0 pop from the output (halt) when 0 is popped from 1 0011 2 pushes occur when 1 is popped from 1 01 the first push is symbol 1 on stack 0 11 the second push is symbol 1 on stack 1 (replaces the symbol we popped) 1 pop from stack 1, which we just put 1 on, so we loop forever, outputting 1 11 loop forever doing nothing if the input is empty, won't matter 

Note: under some interpretations of the language, the trailing 1s can be omitted, and the advanced interpreter does this automatically, also added 0 to the end if there are any trailing 1s. The actual decompression is

01010110110000011 

Pylons, 7 bytes.

izwp,1} 

How it works:

i # Get command line input. z # Skip the next instruction if the top of the stack is 0. wp,1} # While 1 is truthy, print the stack. 

ForceLang, 52 bytes

set a io.readln() label l io.write a if a="1" goto l 

Fission, 12 bytes

This is about the shortest I can do at the moment.

*;R?[ X!@J 

Try it online

 R # Create a atom heading right ? # Set atom mass to input char [ # Set direction right X # Clone atom and sending one back ! # Print the character @ # Swap mass and energy on atom J # Jump (48 for 0, 49 for 1) * # Kill program. Landing spot for 0 ; # Kill atom. Landing spot for 1 

The length of this program is quite dependent on the landing spots for the Jump command. There is also a requirement for a bit of space between the [ direction setter and the X linear cloner. Otherwise an extra 0 will get printed. The input must be either 0 or 1 for this to work. The input is not validated.

Originally I was going to put up a 18 byte program which is more forgiving on invalid inputs.

R?@YI@0'L O0'&[X'1 

Javascript, 33 31 chars

while(alert(x=x||+prompt()),x); 

Common Lisp, 34 32 bytes

(if (= 1(read))(loop (print 1))) 

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 

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. 

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 } 

Dip, 6 bytes

?_1p?0 

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

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.

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 

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 

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

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.

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.

REXX, 33 bytes

pull n do while n say n end say n