text:
Simple cat program
One of the most common standard tasks (especially when showcasing esoteric programming languages) is to implement a "cat program": read all of STDIN and print it to STDOUT. While this is named after the Unix shell utility cat it is of course much less powerful than the real thing, which is normally used to print (and concatenate) several files read from disc.
Task
You should write a full program which reads the contents of the standard input stream and writes them verbatim to the standard output stream. If and only if your language does not support standard input and/or output streams (as understood in most languages), you may instead take these terms to mean their closest equivalent in your language (e.g. JavaScript's prompt and alert). These are the only admissible forms of I/O, as any other interface would largely change the nature of the task and make answers much less comparable.
The output should contain exactly the input and nothing else. The only exception to this rule is constant output of your language's interpreter that cannot be suppressed, such as a greeting, ANSI color codes or indentation. This also applies to trailing newlines. If the input does not contain a trailing newline, the output shouldn't include one either! (The only exception being if your language absolutely always prints a trailing newline after execution.)
Output to the standard error stream is ignored, so long as the standard output stream contains the expected output. In particular, this means your program can terminate with an error upon hitting the end of the stream (EOF), provided that doesn't pollute the standard output stream. If you do this, I encourage you to add an error-free version to your answer as well (for reference).
As this is intended as a challenge within each language and not between languages, there are a few language specific rules:

If it is at all possible in your language to distinguish null bytes in the standard input stream from the EOF, your program must support null bytes like any other bytes (that is, they have to be written to the standard output stream as well).
If it is at all possible in your language to support an arbitrary infinite input stream (i.e. if you can start printing bytes to the output before you hit EOF in the input), your program has to work correctly in this case. As an example yes | tr -d \\n | ./my_cat should print an infinite stream of ys. It is up to you how often you print and flush the standard output stream, but it must be guaranteed to happen after a finite amount of time, regardless of the stream (this means, in particular, that you cannot wait for a specific character like a linefeed before printing).

Please add a note to your answer about the exact behaviour regarding null-bytes, infinite streams, and extraneous output.
Additional rules

This is not about finding the language with the shortest solution for this (there are some where the empty program does the trick) - this is about finding the shortest solution in every language. Therefore, no answer will be marked as accepted.
Submissions in most languages will be scored in bytes in an appropriate preexisting encoding, usually (but not necessarily) UTF-8.
Some languages, like Folders, are a bit tricky to score. If in doubt, please ask on Meta.
Feel free to use a language (or language version) even if it's newer than this challenge. Languages specifically written to submit a 0-byte answer to this challenge are fair game but not particularly interesting.
Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.
Also note that languages do have to fulfil our usual criteria for programming languages.
If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainfuck derivatives like Headsecks or Unary), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.
Unless they have been overruled earlier, all standard code-golf rules apply, including the http://meta.codegolf.stackexchange.com/q/1061.

As a side note, please don't downvote boring (but valid) answers in languages where there is not much to golf; these are still useful to this question as it tries to compile a catalogue as complete as possible. However, do primarily upvote answers in languages where the author actually had to put effort into golfing the code.
Catalogue
The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:
## [><>](http://esolangs.org/wiki/Fish), 121 bytes

 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Shortest Solution by Language

Language	User	Score

Leaderboard

	Author	Language	Size

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Do we have to support multibyte characters?

@AlexA. Yes. Any byte-stream should work.

Bash, 3 bytes: cat

@TheDoctor I guess this would fall into the "don't use a builtin which does exactly what is needed" rule.

@PaŭloEbermann There is no such rule, and the corresponding standard loophole is no longer accepted. (In fact, there is already a sh answer using cat which also contains a shorter solution using dd.)

Would it be acceptable to create this by taking the input from the user char by char instead of line by line?

@JAtkin Sure, many infinite-stream answers do that. You can read it in chunks as well, just don't wait for a specific character to appear.

Do command line arguments count as STDIN?

@dorukayhan no, sorry.

If only it used standard methods of input and output: ///, 0 bytes.

@SparklePony Except, you'd have to escape slashes and backslashes.

@MartinEnder I always miss those sort of things.

If my language of choice cannot distinguish 0xFF bytes from EOF, can it halt on those instead of NUL bytes?

@Dennis Seems fine.

sed, 0

The empty sed program does exactly what is required here:
$ printf "abc\ndef" | sed ''
abc
def$

What happens if one writes yes | tr -d \\n | sed ''?

@BenGoldberg By default sed works on a per-line basis, so in this case it will continue slurping up yeses into one pattern buffer until it runs out of memory.  A caveat I suppose...

POSIX mandates that the pattern space must have a size of at least 8192 bytes, IIRC.  I know the GNU implementation has a dynamic pattern space, limited only by the available memory, so you're fairly safe on that one.

Ziim, 222 201 196 185 182 bytes
    ↓ ↓

 ↓ ↓     ↓
 ↗ ↗↙↔↘↖ ↖
 ↓↓⤡⤢  ⤢↙
↘ ↖⤡ ↖
  ↙
  ↕↘ ↑ ↙
→↘↖↑ ↙ ↑
→↖   ↑
→↖↘ ↙
  ↑↓↑

   ⤡

This will probably not display correctly in your browser, so here is a diagram of the code:

I can't think of a simpler structure to solve the problem in Ziim, but I'm sure the actual code is still quite golfable.
Ziim cannot possibly handle infinite streams because it is only possible to print anything at the end of the program.
Explanation
Since Ziim has a rather unique, declarative control flow model an imperative pseudocode algorithm won't cut it here. Instead, I'll explain the basics of Ziim and the present the tidied up structure of the above code (in a similar graphical manner) as ASCII art.
Control flow in Ziim happens all over the place: each arrow which isn't pointed at by another arrow initialises a "thread" which is processed independently of the others (not really in parallel, but there are no guarantees which order they are processed in, unless you sync them up via concatenation). Each such thread holds a list of binary digits, starting as {0}. Now each arrow in the code is some sort of command which has one or two inputs and one or two outputs. The exact command depends on how many arrows are pointing at it from which orientations.
Here is the list of the commands, where m -> n indicates that the command takes m inputs and produces n outputs.

1 -> 1, no-op: simply redirects the thread.
1 -> 1, invert: negates each bit in the thread (and also redirects it).
1 -> 1, read: replaces the thread's value by the next bit from STDIN, or by the empty list if we've hit EOF.
2 -> 1, concatenate: this is the only way to sync threads. When a thread hits one side of the arrow, it will be suspended until another thread hits the other side. At that point they will be concatenated into a single thread and continue execution.
2 -> 1, label: this is the only way to join different execution paths. This is simply a no-op which has two possible inputs. So threads entering the "label" via either route will simply be redirected into the same direction.
1 -> 2, split: takes a single thread, and sends two copies off in different directions.
1 -> 1, isZero?: consumes the first bit of the thread, and sends the thread in one of two directions depending on whether the bit was 0 or 1.
1 -> 1, isEmpty?: consumes the entire list (i.e. replaces it with an empty list), and sends the thread in one of two direction depending on whether the list was already empty or not.

So with that in mind, we can figure out a general strategy. Using concatenate we want to repeatedly append new bits to a string which represents the entire input. We can simply do this by looping the output of the concatenate back into one of its inputs (and we initialise this to an empty list, by clearing a {0} with isEmpty?). The question is how we can terminate this process.
In addition to appending the current bit we will also prepend a 0 or 1 indicating whether we've reached EOF. If we send our string through isZero?, it will get rid of that bit again, but let us distinguish the end of the stream, in which case we simply let the thread leave the edge of the grid (which causes Ziim to print the thread's contents to STDOUT and terminate the program).
Whether we've reached EOF or not can be determined by using isEmpty? on a copy of the input.
Here is the diagram I promised:
              +----------------------------+   {0} --> isEmpty --> label <--+
              |                            |                    n    |      |
              v                            |                         v      |
    {0} --> label --> read --> split --> split ------------------> concat   |
                                 |                                   |      |
                           n     v     y                             |      |
 inv --> label --> concat <-- isEmpty --> concat <-- label <-- {0}   |      |
  ^        ^          |                     |          ^             |      |
  |        |          v                     v          |             |      |
 {0}       +------- split ---> label <--- split -------+             |      |
                                 |                                   |      |
                                 +-------------> concat <------------+      |
                                                   |                        |
                                              y    v                        |
                         print and terminate <-- isZero --------------------+

Some notes about where to start reading:

The {0} in the top left corner is the initial trigger which starts the input loop.
The {0} towards the top right corner is immediately cleared to an empty list an represents the initial string which we'll gradually fill with the input.
The other two {0}s are fed into a "producer" loop (one inverted, one not), to give us an unlimited supply of 0s and 1s which we need to prepend to the string.

How can you even write a program like that without your brain exploding into a million little chunks of tissue.

Hexagony, 6 bytes
This used to be 3 bytes (see below), but that version no long works since the latest update of the language. As I never intentionally introduced the error that version made use of, I decided not to count it.

An error-free solution (i.e. one which works with the fixed interpreter) turns out to be much trickier. I've had some trouble squeezing it into a 2x2 grid, but I found one solution now, although I need the full 7 bytes:
<)@,;.(

After unfolding, we get:

Since the initial memory edge is 0, the < unconditionally deflects the instruction pointer into the North-East diagonal, where it wraps to the the grey path. The . is a no-op. Now , reads a byte, ) increments it such that valid bytes (including null bytes) are positive and EOF is 0.
So on EOF, the IP wraps to red path, where @ terminates the program. But if we still read a byte, then the IP wraps to the green path is instead where ( decrements the edge to the original value, before ; prints it to STDOUT. The IP now wraps unconditionally back to the grey path, repeating the process.

After writing a brute force script for my Truth Machine answer, I set it to find an error-free 6-byte solution for the cat program as well. Astonishingly, it did find one - yes, exactly one solution in all possible 6-byte Hexagony programs. After the 50 solutions from the truth machine, that was quite surprising. Here is the code:
~/;,@~

Unfolding:

The use of ~ (unary negation) instead of () is interesting, because a) it's a no-op on zero, b) it swaps the sides of the branch, c) in some codes a single ~ might be used twice to undo the operation with itself. So here is what's going on:
The first time (purple path) we pass through ~ it's a no-op. The / reflects the IP into the North-West diagonal. The grey path now reads a character and multiplies its character code by -1. This turns the EOF (-1) into a truthy (positive) value and all valid characters into falsy (non-positive) values. In the case of EOF, the IP takes the red path and the code terminates. In the case of a valid character, the IP takes the green path, where ~ undoes negation and ; prints the character. Repeat.

Finally, here is the 3-byte version which used to work in the original version Hexagony interpreter.
,;&

Like the Labyrinth answer, this terminates with an error if the input stream is finite.
After unfolding the code, it corresponds to the following hex grid:

The . are no-ops. Execution starts on the purple path.
, reads a byte, ; writes a byte. Then execution continues on the salmon(ish?) path. We need the & to reset the current memory edge to zero, such that the IP jumps back to the purple row when hitting the corner at the end of the second row. Once , hits EOF it will return -1, which causes an error when ; is trying to print it.

Diagrams generated with Timwi's amazing HexagonyColorer.

The 6-byte version is very, very clever. Brute-forcers can be incredibly awesome.

Do you have a link to your brute-forcer?

@MDXF I don't keep the various versions around, but it's always some modification of this Ruby script.

TeaScript, 0 bytes
TeaScript is a concise golfing language compiled to JavaScript

In a recent update the input is implicitly added as the first property.
Try it online

Alternatively, 1 byte
x

x contains the input in TeaScript. Output is implicit

I was about to post this :)

Hah, I thought "Alternatively" was a language name...

Brian & Chuck, 44 bytes
#{<{,+?+}_+{-?>}<?
_}>?>+<<<{>?_}>>.<+<+{<{?

I originally created this language for Create a programming language that only appears to be unusable. It turns out to be a very nice exercise to golf simple problems in it though.
The Basics: Each of the two lines defines a Brainfuck-like program which operates on the other program's source code - the first program is called Brian and the second is called Chuck. Only Brian can read and only Chuck can write. Instead of Brainfuck's loops you have ? which passes control to the other program (and the roles of instruction pointer and tape head change as well). An addition to Brainfuck is { and } which scan the tape for the first non-zero cell (or the left end). Also, _ are replaced with null bytes.
While I don't think this is optimal yet, I'm quite happy with this solution. My first attempt was 84 bytes, and after several golfing sessions with Sp3000 (and taking some inspiration from his attempts), I managed to get it slowly down to 44, a few bytes at a time. Especially the brilliant +}+ trick was his idea (see below).
Explanation
Input is read into the first cell on Chuck's tape, then painstakingly copied to the end of Brian's tape, where it's printed. By copying it to the end, we can save bytes on setting the previous character to zero.
The # is just a placeholder, because switching control does not execute the cell we switched on. {<{ ensures that the tape head is on Chuck's first cell. , reads a byte from STDIN or -1 if we hit EOF. So we increment that with + to make it zero for EOF and non-zero otherwise.
Let's assume for now we're not at EOF yet. So the cell is positive and ? will switch control to Chuck. }> moves the tape head (on Brian) to the + the _ and ? passes control back to Brian.
{- now decrements the first cell on Chuck. If it's not zero yet, we pass control to Chuck again with ?. This time }> moves the tape head on Brian two cells of the right of the last non-zero cell. Initially that's here:
#{<{,+?+}_+{-?>}<?__
                   ^

But later on, we'll already have some characters there. For instance, if we've already read and printed abc, then it would look like this:
#{<{,+?+}_+{-?>}<?11a11b11c__
                            ^

Where the 1s are actually 1-bytes (we'll see what that's about later).
This cell will always be zero, so this time ? won't change control. > moves yet another cell to the right and + increments that cell. This is why the first character in the input ends up three cells to the right of the ? (and each subsequent one three cells further right).
<<< moves back to the last character in that list (or the ? if it's the first character), and {> goes back to the + on Brian's tape to repeat the loop, which slowly transfers the input cell onto the end of Brian's tape.
Once that input cell is empty the ? after {- will not switch control any more. Then >}< moves the tape head on Chuck to the _ and switches control such that Chuck's second half is executed instead.
}>> moves to the cell we've now written past the end of Brian's tape, which is the byte we've read from STDIN, so we print it back with .. In order for } to run past this new character on the tape we need to close the gap of two null bytes, so we increment them to 1 with <+<+ (so that's why there are the 1-bytes between the actual characters on the final tape). Finally {<{ moves back to the beginning of Brian's tape and ? starts everything from the beginning.
You might wonder what happens if the character we read was a null-byte. In that case the newly written cell would itself be zero, but since it's at the end of Brian's tape and we don't care where that end is, we can simply ignore that. That means if the input was ab\0de, then Brian's tape would actually end up looking like:
#{<{,+?+}_+{-?>}<?11a11b1111d11e

Finally, once we hit EOF that first ? on Brian's tape will be a no-op. At this point we terminate the program. The naive solution would be to move to the end of Chuck's tape and switch control, such that the program termiantes: >}>}<?. This is where Sp3000's really clever idea saves three bytes:
+ turns Chuck's first cell into 1. That means } has a starting point and finds the _ in the middle of Chuck's tape. Instead of skipping past it, we simply close the gap by turning it into a 1 with + as well. Now let's see what the rest of Brian's code happens to do with this modified Chuck...
{ goes back to Chuck's first cell as usual, and - turns it back into a null-byte. That means that ? is a no-op. But now >}<, which usually moved the tape head to the middle of Chuck's tape, moves right past it to the end of Chuck's tape and ? then passes control to Chuck, terminating the code. It's nice when things just work out... :)

Haskell, 16 bytes
main=interact id

interact reads the input, passes it to the function given as its argument and prints the result it receives. id is the identity function, i.e. it returns its input unchanged. Thanks to Haskell's laziness interact can work with infinite input.

sh + binutils, 3 2 bytes
dd

Well, not quite as obvious. From @Random832
Original:
cat

The painfully obvious... :D

I'll do one better: dd.

I was going to do cat... D:

Yes, this is great and all... but 170 rep for typing cat???

@MDXF what about who knows how much rep from a segfault? ;)

Motorola MC14500B Machine Code, 1.5 bytes
Written in hexadecimal:
18F

Written in binary:
0001 1000 1111

Explanation
1   Read from I/O pin
8   Output to I/O pin
F   Loop back to start

The opcodes are 4 bits each.

-1 no screenshot, example or Try It Online link :P (jk)

+1. The only way I can think of to optimise this further would be to just solder the input pin to the output pin and take the chip out of it's socket :P

Funciton, 16 bytes
╔═╗
╚╤╝

(Encoded as UTF-16 with a BOM)
Explanation
The box returns the contents of STDIN. The loose end outputs it.

Mornington Crescent, 41 bytes
Take Northern Line to Mornington Crescent

I have no idea whether Mornington Crescent can handle null bytes, and all input is read before the program starts, as that is the nature of the language.

Brainfuck, 5 bytes
,[.,]

Equivalent to the pseudocode:
x = getchar()
while x != EOF:
    putchar(x)
    x = getchar()

This handles infinite streams, but treats null bytes as EOF. Whether or not BF can handle null bytes correctly varies from implementation to implementation, but this assumes the most common approach.

DARN! You beat me to it by 5 mins!

If the first character is NULL then this won't run correctly. So it should be +[,.] right?

@Shel This is using 0x00 as the EOF byte. If the first character is EOF, it prints nothing, working as expected.

"pseudocode" oh come on that's clearly just un-bracketed, un-semicolon-ed C :P

Labyrinth, 2 bytes
,.

If the stream is finite, this will terminate with an error, but all the output produce by the error goes to STDERR, so the standard output stream is correct.
As in Brainfuck , reads a byte (pushing it onto Labyrinth's main stack) and . writes a byte (popping it from Labyrinth's main stack).
The reason this loops is that both , and . are "dead ends" in the (very trivial) maze represented by the source code, such that the instruction pointer simply turns around on the spot and moves back to the other command.
When we hit EOF , pushes -1 instead and . throws an error because -1 is not a valid character code. This might actually change in the future, but I haven't decided on this yet.

For reference, we can solve this without an error in 6 bytes as follows
,)@
.(

Here, the ) increments the byte we read, which gives 0 at EOF and something positive otherwise. If the value is 0, the IP moves straight on, hitting the @ which terminates the program. If the value was positive, the IP will instead take a right-turn towards the ( which decrements the top of the stack back to its original value. The IP is now in a corner and will simply keep making right turns, printing with ., reading a new byte with ., before it hits the fork at ) once again.

X86 assembly, 70 bytes
Disassembly with objdump:
00000000 <.data>:
   0:   66 83 ec 01             sub    sp,0x1
   4:   66 b8 03 00             mov    ax,0x3
   8:   00 00                   add    BYTE PTR [eax],al
   a:   66 31 db                xor    bx,bx
   d:   66 67 8d 4c 24          lea    cx,[si+0x24]
  12:   ff 66 ba                jmp    DWORD PTR [esi-0x46]
  15:   01 00                   add    DWORD PTR [eax],eax
  17:   00 00                   add    BYTE PTR [eax],al
  19:   cd 80                   int    0x80
  1b:   66 48                   dec    ax
  1d:   78 1c                   js     0x3b
  1f:   66 b8 04 00             mov    ax,0x4
  23:   00 00                   add    BYTE PTR [eax],al
  25:   66 bb 01 00             mov    bx,0x1
  29:   00 00                   add    BYTE PTR [eax],al
  2b:   66 67 8d 4c 24          lea    cx,[si+0x24]
  30:   ff 66 ba                jmp    DWORD PTR [esi-0x46]
  33:   01 00                   add    DWORD PTR [eax],eax
  35:   00 00                   add    BYTE PTR [eax],al
  37:   cd 80                   int    0x80
  39:   eb c9                   jmp    0x4
  3b:   66 b8 01 00             mov    ax,0x1
  3f:   00 00                   add    BYTE PTR [eax],al
  41:   66 31 db                xor    bx,bx
  44:   cd 80                   int    0x80

The source:
sub esp, 1
t:
mov eax,3
xor ebx,ebx
lea ecx,[esp-1]
mov edx,1
int 0x80
dec eax
js e
mov eax,4
mov ebx,1
lea ecx,[esp-1]
mov edx,1
int 0x80
jmp t
e:
mov eax,1
xor ebx,ebx
int 0x80

So, objdump disassembled it as 32-bit code, while you seem to have compiled as 16-bit. What to believe? Since you use int 0x80, I guess it's meant for Linux, but why compile as 16-bit then?

@Ruslan I didn't even realize it was compiled in 16-bit...

Universal Lambda, 1 byte
!

A Universal Lambda program is an encoding of a lambda term in binary, chopped into chunks of 8 bits, padding incomplete chunks with any bits, converted to a byte stream.
The bits are translated into a lambda term as follows:

00 introduces a lambda abstraction.
01 represents an application of two subsequent terms.
111..10, with n repetitions of the bit 1, refers to the variable of the nth parent lambda; i.e. it is a De Bruijn index in unary.

By this conversion, 0010 is the identity function λa.a, which means any single-byte program of the form 0010xxxx is a cat program.

But ! is 0x21, not 0x4_?

Fixed. --------

><>, 7 bytes
i:0(?;o

Try it here.
Explanation:
i:0(?;o
i        Take a character from input, pushing -1 if the input is empty
 :0(     Check if the input is less than 0, pushing 1 if true, 0 if false
    ?;   Pop a value of the top of the stack, ending the program if the value is non-zero
      o  Otherwise, output then loop around to the left and repeat

If you want it to keep going until you give it more input, replace the ; with !.

Aww man, I was hoping to post the ><> answer... :P (+1!)

io (2 bytes) does the same, but crashes and writes something smells fishy... to STDERR at the end of execution, which is allowed.

@Mauris the online interpreter just outputs null bytes instead of ending with an error.

C, 40 bytes
main(i){while(i=~getchar())putchar(~i);}

main(){while(255-putchar(getchar()));} is a couple of bytes shorter.

Sadly, that exits prematurely on 0xFF bytes and appends a 0xFF byte to the input if it doesn't contain it.

What about the following, 36 bytes:
main(){for(;;putchar(getchar()));};

@user2943932 When it hits EOF, getchar returns -1, so your code will print an infinite stream of 0xFF bytes after the (finite) input.

Cubix, 6 5 bytes
Now handles null bytes!
@_i?o

Cubix is a 2-dimensional, stack-based esolang. Cubix is different from other 2D langs in that the source code is wrapped around the outside of a cube.
Test it online! Note: there's a 50 ms delay between iterations.
Explanation
The first thing the interpreter does is figure out the smallest cube that the code will fit onto. In this case, the edge-length is 1. Then the code is padded with no-ops . until all six sides are filled. Whitespace is removed before processing, so this code is identical to the above:
  @
_ i ? o
  .

Now the code is run. The IP (instruction pointer) starts out on the far left face, pointing east.
The first char the IP encounters is _, which is a mirror that turns the IP around if it's facing north or south; it's currently facing east, so this does nothing. Next is i, which inputs a byte from STDIN. ? turns the IP left if the top item is negative, or right if it's positive. There are three possible paths here:

If the inputted byte is -1 (EOF), the IP turns left and hits @, which terminates the program.
If the inputted byte is 0 (null byte), the IP simply continues straight, outputting the byte with o.
Otherwise, the IP turns right, travels across the bottom face and hits the mirror _. This turns it around, sending it back to the ?, which turns it right again and outputs the byte.

I think this program is optimal. Before Cubix could handle null bytes (EOF was 0, not -1), this program worked for everything but null bytes:
.i!@o

I've written a brute-forcer to find all 5-byte cat programs. Though it takes ~5 minutes to finish, the latest version has found 5 programs:
@_i?o   (works as expected)
@i?o_   (works in exactly the same way as the above)
iW?@o   (works as expected)
?i^o@   (false positive; prints U+FFFF forever on empty input)
?iWo@   (works as expected)

Please don't edit a dozen posts at once. You're flooding the front page. 3 at a time is not an issue, but if you have to do more than that then please do your edits in small batches every 12 hours or so.

@MartinEnder Sorry, I just noticed that. I'll space them out in the future.

PowerShell, 88 41 30 Bytes
$input;write-host(read-host)-n

EDIT -- forgot that I can use the $input automatic variable for pipeline input ... EDIT2 -- don't need to test for existence of $input
Yeah, so ... STDIN in PowerShell is ... weird, shall we say. With the assumption that we need to accept input from all types of STDIN, this is one possible answer to this catalogue, and I'm sure there are others.1
Pipeline input in PowerShell doesn't work as you'd think, though. Since piping in PowerShell is a function of the language, and not a function of the environment/shell (and PowerShell isn't really solely a language anyway), there are some quirks to behavior.
For starters, and most relevant to this entry, the pipe isn't evaluated instantaneously (most of the time). Meaning, if we have command1 | command2 | command3 in our shell, command2 will not take input or start processing until command1 completes ... unless you encapsulate your command1 with a ForEach-Object ... which is different than ForEach. (even though ForEach is an alias for ForEach-Object, but that's a separate issue, since I'm talking ForEach as the statement, not alias)
This would mean that something like yes | .\simple-cat-program.ps1 (even though yes doesn't really exist, but whatever) wouldn't work because yes would never complete. If we could do ForEach-Object -InputObject(yes) | .\simple-cat-program.ps1 that should (in theory) work.
Getting to Know ForEach and ForEach-Object on the Microsoft "Hey, Scripting Guy!" blog.
So, all those paragraphs are explaining why if($input){$input} exists. We take an input parameter that's specially created automatically if pipeline input is present, test if it exists, and if so, output it.
Then, we take input from the user (read-host) via what's essentially a separate STDIN stream, and write-host it back out, with the -n flag (short for -NoNewLine). Note that this does not support arbitrary length input, as read-host will only complete when a linefeed is entered (technically when the user presses "Enter", but functionally equivalent).
Phew.
1But there are other options:
For example, if we were concerned with only pipeline input, and we didn't require a full program, you could do something like  | $_ which would just output whatever was input. (In general, that's somewhat redundant, since PowerShell has an implicit output of things "left behind" after calculations, but that's an aside.)
If we're concerned with only interactive user input, we could use just write-host(read-host)-n.
Additionally, this function has the quirk feature of accepting command-line input, for example .\simple-cat-program.ps1 "test" would populate (and then output) the $a variable.

don't forget your built in aliases!

rs, 0 bytes

Seriously. rs just prints whatever it gets if the given script is completely empty.

MarioLANG, 11 bytes
,<
."
>!
=#

I'm not entirely sure this is optimal, but it's the shortest I found.
This supports infinite streams and will terminate with an error upon reaching EOF (at least the Ruby reference implementation does).
There's another version of this which turns Mario into a ninja who can double jump:
,<
.^
>^
==

In either case, Mario starts falling down the left column, where , reads a byte and . writes a byte (which throws an error at EOF because , doesn't return a valid character). > ensures that Mario walks to the right (= is just a ground for him to walk on). Then he moves up, either via a double jump with ^ or via an elevator (the " and # pair) before the < tells him to move back to the left column.

INTERCALL, 133 bytes
wat
INTERCALL IS A ANTIGOLFING LANGUAGE
SO THIS HEADER IS HERE TO PREVENT GOLFING IN INTERCALL
THE PROGRAM STARTS HERE:
READ
PRINT
GOTO I

It looks like someone really golfed in a purely anti-golfing language... 133-116=17

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Since the cat program is pretty simple, this is'nt the case of all programs... http://codegolf.stackexchange.com/a/82748/53745

The person who made the language intended to use roman numerals, but if it was the case to print 500 (not sure), it would be PRINT D, right? (excluding the header)

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Nope, INTERCALL can only print ASCII characters and use a stack, so for example to print the caracter with ascii value 20 the code is PUSH XX<newline>PRINT or PUSH XX AND PRINT. Oh and i am the creator of INTERCALL

Vitsy, 2 bytes
zZ
z gets all of the input stack and pushes it to the active program stack. Z prints out all of the active stack to STDOUT.
Alternate method:
I\il\O
I\      Repeat the next character for input stack's length.
  i     Grab an item from the input.
   l\   Repeat the next character for the currently active program stack's length.
     O  Output the top item of the stack as a character.

^_^ Have a +1 anyway! :)

Pity votes, my favorite!

Why the downvotes? This seems to be a perfectly valid entry

It is valid by all specs.

V, 0 bytes
Try it online!
V's idea of "memory" is just a gigantic 2D array of characters. Before any program is ran, all input it loaded into this array (known as "The Buffer"). Then, at the end of any program, all text in the buffer is printed.
In other words, the empty program is a cat program.

Half-Broken Car in Heavy Traffic, 9 + 3 = 12 bytes
#<
o^<
 v

Half-Broken Car in Heavy Traffic (HBCHT) takes input as command line args, so run like
py -3 hbcht cat.hbc -s "candy corn"

Note that the +3 is for the -s flag, which outputs as chars. Also, HBCHT doesn't seem handle NULs, as all zeroes are dropped from the output (e.g. 97 0 98 is output as two chars ab).
Explanation
In HBCHT, your car starts at the o and your goal is the exit #. ^>v< direct the car's movement, while simultaneously modifying a BF-like tape (^>v< translate to +>-<). However, as the language name suggests, your car can only turn right – any attempts to turn left are ignored completely (including their memory effects). Note that this is only for turning – your car is perfectly capable of driving forward/reversing direction.
Other interesting parts about HBCHT are that your car's initial direction is randomised, and the grid is toroidal. Thus we just need the car to make it to the exit without modifying the tape for all four initial directions:

Up and down are straightforward, heading directly to the exit.
For left, we wrap and execute < and increment with ^. We can't turn left at the next < so we wrap and decrement with v, negating out previous increment. Since we're heading downwards now we can turn right at the < and exit, having moved the pointer twice and modifying no cell values.
For right, we do the same thing as left but skip the first ^ since we can't turn left.

Edit: It turns out that the HBCHT interpreter does let you execute just a single path via a command line flag, e.g.
py -3 hbcht -d left cat.hbc

However, not only is the flag too expensive for this particular question (at least 5 bytes for " -d u"), it seems that all paths still need to be able to make it to the exit for the code to execute.

Seed, 3883 3864 10 bytes
4 35578594

Try it online!
This is one of the stupidest things I have ever done.

i like that you probably could have just gone through the programs sequentially and found this one within a reasonable time

@JoKing This is pretty much exactly what I did.

GolfScript, 3 bytes
:n;

The empty program echoes standard input. The language cannot possibly handle infinite streams. However, it appends a newline, as @Dennis mentioned. It does so by wrapping the whole stack in an array and calling puts, which is defined as print n print, where n is a newline. However, we can redefine n to be STDIN, and then empty the stack, which is precisely what :n; does.

Isn't GolfScript in TIO?

Minkolang, 5 bytes
od?.O

Try it here.
Explanation
o reads in a character from input and pushes its ASCII code onto the stack (0 if the input is empty). d then duplicates the top of stack (the character that was just read in). ? is a conditional trampoline, which jumps the next instruction of the top of stack is not 0. If the input was empty, then the . is not jumped and the program halts. Otherwise, O outputs the top of stack as a character. The toroidal nature of Minkolang means that this loops around to the beginning.

Grar! You beat my language! UNACCEPTABLE! +1

Which one is yours?

Snowman 1.0.2, 15 chars
(:vGsP10wRsp;bD

Taken directly from Snowman's examples directory.  Reads a line, prints a line, reads a line, prints a line...
Note that due to an implementation detail, when STDIN is empty, vg will return the same thing as it would for an empty line. Therefore, this will repeatedly print newlines in an infinite loop once STDIN is closed. This may be fixed in a future version.
Explanation of the code:
(        // set two variables (a and f) to active—this is all we need
:...;bD  // a "do-loop" which continues looping as long as its "return value"
         // is truthy
  vGsP   // read a line, print the line
  10wRsp // print a newline—"print" is called in nonconsuming mode; therefore,
         // that same newline will actually end up being the "return value" from
         // the do-loop, causing it to loop infinitely

05AB1E, 50 38 bytes
[“€¬((a=IO.‚Ø 9)!=:eof)€· IO.‡í€…„–“.E

Try it online or test an infinite stream.
Explanation
This is probably the first real 05AB1E cat posted here. While my previous answer (?) mostly worked...

If it is at all possible in your language to support an arbitrary infinite input stream (i.e. if you can start printing bytes to the output before you hit EOF in the input), your program has to work correctly in this case.

And while there seems to be no way of doing this in 05AB1E, making ? the shortest possible answer, there is one not very commonly used command that does the trick. .E pops a string and runs it as an Elixir program.
In this case, we use the following Elixir code:
a = IO.read(x)
if a != :eof do
    IO.write(a)
end

…where x is the number of bytes to read each time — the greater it is, the faster the program runs. It can be anything but :all, as that would be equivalent to my previous submission, invalidating it.
We can golf this down to:
if((a=IO.read x)!=:eof)do IO.write a end

By now, you might've realized that this program only ever outputs the first x bytes of input. But running the Elixir code isn't the only thing the program does. It runs it over and over in an infinite loop ([)!
The weird symbols you see in the 05AB1E program are dictionary compression – compressing English words or other common letter combinations into just two bytes each. By substituting in 9 for x in the Elixir program (making the program as fast as it can be while not raising the bytecount), we get the final program!

Vyxal, 0 bytes

Try it Online!
Implicitly inputs then implicitly outputs. Stretching the rules a teeny bit. Specifically the following rule:

The only exception being if your language absolutely always prints a trailing newline after execution.

In Vyxal, "printing after execution" (implicit, not explicit printing) always prints with a newline.

FireType, 7 bytes
,
&
_
=

Requires some changes I just pushed. The rules say:

Unlike our usual rules, feel free to use a language (or language version) even if it's newer than this challenge.

so I'm in the clear!

Fission, 4 bytes
R?J!

Isn't it nice when you beat the sample programs in language's own repository? :) For reference, it has the 7-byte solution
R?J0;0!

Explanation
So, R starts the control-flow with a right-going atom. ? reads a character from STDIN into the atom's mass. As long as we're reading characters, the energy remains zero, so the Jump is a no-op and ! prints the character. The atom loops back to the start (R is now a no-op) and repeats the whole process.
When we hit EOF, ? will set the atom's energy to 1, so the Jump will now skip the print command. But when an atom hits ? after EOF has already been returned, it will destroy the atom instead, which terminates the program.
(The solution from the language's author uses an explicit ; to terminate the program, which is skipped with two 0-portals otherwise.)

Piet, 3 codels

First Piet program! Quick explanation: input chars, output chars.

Stack Cats, 0 bytes
The language cannot handle infinite input/output streams (since the program doesn't start until EOF is encountered, and output is printed from a finite memory source at the end of the program). It does handle null bytes.

Try it online!
This is not a case of "let's assign a random task to the empty program as a special case for golfing". Instead, the fact that this works is actually a result of several design decisions and is completely consistent with the overall language semantics.
Mainly, Stack Cats is a very pure reversible programming language, which means that every piece of code can be cleanly undone within the language. I/O does not fit within this model, because once you've printed something to STDOUT you can't undo it. In theory you could undo reading input by pushing it back to some buffer, but for symmetry reasons, input and output are treated the same. To make I/O work, we read all input at the beginning of the program and push it onto the initial stack, and at the end of the program, the contents of the final stack are printed to STDOUT.
Secondly, to undo any piece of code, we simply mirror it (reverse characters, swap all brackets and slashes). Furthermore, every program has to be symmetric itself. This implies that every even-length program is a valid cat program, provided it terminates, since even-length programs necessarily consist of some code together with the code that inverts it. It just so happens that the shortest even-length program is empty.

gs2, 0 bytes

The empty program echoes standard input. The language cannot possibly handle infinite streams.

CJam, 1 byte
q

CJam has three ways to read from the input stream:

q reads it all as one big string.
l reads a single line, up until a newline.
r reads a token, which is a sequence of non-whitespace characters.

As such, it has no way to handle an infinite stream of non-whitespace characters. This should make q a valid solution.

C++, 65 61 bytes
#include<ios>
int main(){while(int i=~getchar())putchar(~i);}

Basically Dennis's C answer adapted for C++. g++ and clang++ give warnings, for me, but compile it just fine.
Saved some bytes thanks to Zereges!

I'm not surprised that clang is ringing warning bells.

Same amount of bytes, but if you change the second line to int main(){for(int i;i=~getchar();)putchar(~i);} you get one less warning.

You can #include<ios> instead of <cstdio>. Also, change int main(int i){while(i=~getchar())putchar(~i);} to int main(){while(int i=~getchar())putchar(~i);}. It removes warnings and saves bytes.

Lazy K, 1 0 bytes
As CatsAreFluffy pointed out, the empty program has the same semantics as the program I. From the grammar:
  Program  ::= CCExpr                     CCExpr

  CCExpr   ::= CCExpr Expr                (CCExpr Expr)
             | epsilon                    (lambda (x) x)

Old explanation (1 byte)
I

A Lazy K program is a function on Church lists of Church numerals, expressed in SKI combinator logic. I is the identity function, which simply equates the output with the input. As such, a cat program is essentially the "simplest" Lazy K program. If your Lazy K interpreter is any good, it even handles infinite streams!

Doesn't the empty program work?

Wow, you’re right. Thanks!

So now we have sed, gs2, TeaScript, and LazyK with 0byte answers. Yay!

Beam, 8 bytes
>rnH
\@/

Fairly simple and a little shorter than the one on the esolangs page.

Retina, 3 1 byte

That's a single linefeed.
Try it online!
The empty Retina program would count the number of matches of the empty regex in the input, so it can't compete with rs and sed here. There are several ways to implement a cat program, the shortest being a Replace stage that doesn't actually replace anything.
Retina cannot handle infinite streams (as it waits for EOF before starting any processing).

awk, 9 1 byte
(thanks to a suggestion rewrite in the comments by Mauris)
1

Example:
echo "hello\nworld" | awk '1'

Does this/can awk handle infinite input?

@MartinBüttner yes infact... yes | awk '{print$0}'

awk '1' works as a 1-byte solution.

@Mauris awk 1 is a "shorter" still 1-byte solution. Quotes are useless here.

@smpl yes | awk '1' only works because yes outputs a newline after each "yes" and awk's default record separator is a newline. This doesn't work for streams that contain no newlines, like yes | tr -d \\n | ./my_cat in the question, so it doesn't qualify.

One workaround would be to use awk + GNU coreutils: fold -1 | awk -vORS= 1

@ThisSuitIsBlackNot, but this will strip newlines

In fact, using any number from 1 to 9 will make this work.

This is the shortest version I've come up with that suppresses the final LF if the input doesn't have one.  {printf x"%s",$0;x="\n"}

And my previous comment was wrong...  That code DOES avoid printing a final trailing LF when the input doesn't have one.  But it also skips the trailing LF is there is one. :)  I'm leaving in place though, since I'm curious if any has found a way in AWK to tell if the last line has a trailing LF or not?  I can't find a way to do that.

Ouroboros, 9 4 bytes
i.)o

The program outputs the exact input, with no extraneous characters. It theoretically would work on null bytes and infinite streams, but as the only interpreter for the language is HTML/JavaScript and the input comes from a text box, neither concept is really applicable.

i reads a character code or -1 for end of input.
. duplicates it.
) is an absolutely nasty hack.

Control flow in Ouroboros is accomplished via the ( and ) commands, which swallow and regurgitate characters from the end of a line. The program ends when the instruction pointer is swallowed. Normally, this means you'll need a ( instruction somewhere, or else the code is an infinite loop. However, in the current implementation, if you use a negative number as the argument to ) (regurgitate), it actually swallows characters. (I.e., regurgitates backwards??)
So: if i read a character and pushed its nonnegative character code, ) regurgitates a number of characters equal to that value--which does nothing, because the snake is already at its maximum possible size. But if i hit EOF and pushed -1, ) "regurgitates" -1 characters, meaning it actually swallows one.
On EOF, the o gets swallowed. The program does not output anything and loops again; i again gives -1, and another character is swallowed--this time, the ). Now the program halts, since the instruction pointer was swallowed.

If nothing was swallowed, o outputs the character from the stack. Control then loops back to the beginning of the line.

See it in action:

// Define Stack class
function Stack() {
  this.stack = [];
  this.length = 0;
}
Stack.prototype.push = function(item) {
  this.stack.push(item);
  this.length++;
}
Stack.prototype.pop = function() {
  var result = 0;
  if (this.length > 0) {
    result = this.stack.pop();
    this.length--;
  }
  return result;
}
Stack.prototype.top = function() {
  var result = 0;
  if (this.length > 0) {
    result = this.stack[this.length - 1];
  }
  return result;
}
Stack.prototype.toString = function() {
  return "" + this.stack;
}

// Define Snake class
function Snake(code) {
  this.code = code;
  this.length = this.code.length;
  this.ip = 0;
  this.ownStack = new Stack();
  this.currStack = this.ownStack;
  this.alive = true;
  this.wait = 0;
  this.partialString = this.partialNumber = null;
}
Snake.prototype.step = function() {
  if (!this.alive) {
    return null;
  }
  if (this.wait > 0) {
    this.wait--;
    return null;
  }
  var instruction = this.code.charAt(this.ip);
  var output = null;
  console.log("Executing instruction " + instruction);
  if (this.partialString !== null) {
    // We're in the middle of a double-quoted string
    if (instruction == '"') {
      // Close the string and push its character codes in reverse order
      for (var i = this.partialString.length - 1; i >= 0; i--) {
        this.currStack.push(this.partialString.charCodeAt(i));
      }
      this.partialString = null;
    } else {
      this.partialString += instruction;
    }
  } else if (instruction == '"') {
    this.partialString = "";
  } else if ("0" <= instruction && instruction <= "9") {
    if (this.partialNumber !== null) {
      this.partialNumber = this.partialNumber + instruction;  // NB: concatenation!
    } else {
      this.partialNumber = instruction;
    }
    next = this.code.charAt((this.ip + 1) % this.length);
    if (next < "0" || "9" < next) {
      // Next instruction is non-numeric, so end number and push it
      this.currStack.push(+this.partialNumber);
      this.partialNumber = null;
    }
  } else if ("a" <= instruction && instruction <= "f") {
    // a-f push numbers 10 through 15
    var value = instruction.charCodeAt(0) - 87;
    this.currStack.push(value);
  } else if (instruction == "$") {
    // Toggle the current stack
    if (this.currStack === this.ownStack) {
      this.currStack = this.program.sharedStack;
    } else {
      this.currStack = this.ownStack;
    }
  } else if (instruction == "s") {
    this.currStack = this.ownStack;
  } else if (instruction == "S") {
    this.currStack = this.program.sharedStack;
  } else if (instruction == "l") {
    this.currStack.push(this.ownStack.length);
  } else if (instruction == "L") {
    this.currStack.push(this.program.sharedStack.length);
  } else if (instruction == ".") {
    var item = this.currStack.pop();
    this.currStack.push(item);
    this.currStack.push(item);
  } else if (instruction == "m") {
    var item = this.ownStack.pop();
    this.program.sharedStack.push(item);
  } else if (instruction == "M") {
    var item = this.program.sharedStack.pop();
    this.ownStack.push(item);
  } else if (instruction == "y") {
    var item = this.ownStack.top();
    this.program.sharedStack.push(item);
  } else if (instruction == "Y") {
    var item = this.program.sharedStack.top();
    this.ownStack.push(item);
  } else if (instruction == "\\") {
    var top = this.currStack.pop();
    var next = this.currStack.pop()
    this.currStack.push(top);
    this.currStack.push(next);
  } else if (instruction == "@") {
    var c = this.currStack.pop();
    var b = this.currStack.pop();
    var a = this.currStack.pop();
    this.currStack.push(c);
    this.currStack.push(a);
    this.currStack.push(b);
  } else if (instruction == ";") {
    this.currStack.pop();
  } else if (instruction == "+") {
    var b = this.currStack.pop();
    var a = this.currStack.pop();
    this.currStack.push(a + b);
  } else if (instruction == "-") {
    var b = this.currStack.pop();
    var a = this.currStack.pop();
    this.currStack.push(a - b);
  } else if (instruction == "*") {
    var b = this.currStack.pop();
    var a = this.currStack.pop();
    this.currStack.push(a * b);
  } else if (instruction == "/") {
    var b = this.currStack.pop();
    var a = this.currStack.pop();
    this.currStack.push(a / b);
  } else if (instruction == "%") {
    var b = this.currStack.pop();
    var a = this.currStack.pop();
    this.currStack.push(a % b);
  } else if (instruction == "_") {
    this.currStack.push(-this.currStack.pop());
  } else if (instruction == "I") {
    var value = this.currStack.pop();
    if (value < 0) {
      this.currStack.push(Math.ceil(value));
    } else {
      this.currStack.push(Math.floor(value));
    }
  } else if (instruction == ">") {
    var b = this.currStack.pop();
    var a = this.currStack.pop();
    this.currStack.push(+(a > b));
  } else if (instruction == "<") {
    var b = this.currStack.pop();
    var a = this.currStack.pop();
    this.currStack.push(+(a < b));
  } else if (instruction == "=") {
    var b = this.currStack.pop();
    var a = this.currStack.pop();
    this.currStack.push(+(a == b));
  } else if (instruction == "!") {
    this.currStack.push(+ !this.currStack.pop());
  } else if (instruction == "?") {
    this.currStack.push(Math.random());
  } else if (instruction == "n") {
    output = "" + this.currStack.pop();
  } else if (instruction == "o") {
    output = String.fromCharCode(this.currStack.pop());
  } else if (instruction == "r") {
    var input = this.program.io.getNumber();
    this.currStack.push(input);
  } else if (instruction == "i") {
    var input = this.program.io.getChar();
    this.currStack.push(input);
  } else if (instruction == "(") {
    this.length -= Math.floor(this.currStack.pop());
    this.length = Math.max(this.length, 0);
  } else if (instruction == ")") {
    this.length += Math.floor(this.currStack.pop());
    this.length = Math.min(this.length, this.code.length);
  } else if (instruction == "w") {
    this.wait = this.currStack.pop();
  }
  // Any unrecognized character is a no-op
  if (this.ip >= this.length) {
    // We've swallowed the IP, so this snake dies
    this.alive = false;
    this.program.snakesLiving--;
  } else {
    // Increment IP and loop if appropriate
    this.ip = (this.ip + 1) % this.length;
  }
  return output;
}
Snake.prototype.getHighlightedCode = function() {
  var result = "";
  for (var i = 0; i < this.code.length; i++) {
    if (i == this.length) {
      result += '';
    }
    if (i == this.ip) {
      if (this.wait > 0) {
        result += '';
      } else {
        result += '';
      }
      result += escapeEntities(this.code.charAt(i)) + '';
    } else {
      result += escapeEntities(this.code.charAt(i));
    }
  }
  if (this.length < this.code.length) {
    result += '';
  }
  return result;
}

// Define Program class
function Program(source, speed, io) {
  this.sharedStack = new Stack();
  this.snakes = source.split(/\r?\n/).map(function(snakeCode) {
    var snake = new Snake(snakeCode);
    snake.program = this;
    snake.sharedStack = this.sharedStack;
    return snake;
  }.bind(this));
  this.snakesLiving = this.snakes.length;
  this.io = io;
  this.speed = speed || 10;
  this.halting = false;
}
Program.prototype.run = function() {
  this.step();
  if (this.snakesLiving) {
    this.timeout = window.setTimeout(this.run.bind(this), 1000 / this.speed);
  }
}
Program.prototype.step = function() {
   for (var s = 0; s < this.snakes.length; s++) {
    var output = this.snakes[s].step();
    if (output) {
      this.io.print(output);
    }
  }
  this.io.displaySource(this.snakes.map(function (snake) {
      return snake.getHighlightedCode();
    }).join("
"));
 }
Program.prototype.halt = function() {
  window.clearTimeout(this.timeout);
}

var ioFunctions = {
  print: function (item) {
    var stdout = document.getElementById('stdout');
    stdout.value += "" + item;
  },
  getChar: function () {
    if (inputData) {
      var inputChar = inputData[0];
      inputData = inputData.slice(1);
      result = inputChar.charCodeAt(0);
    } else {
      result = -1;
    }
    var stdinDisplay = document.getElementById('stdin-display');
    stdinDisplay.innerHTML = escapeEntities(inputData);
    return result;
  },
  getNumber: function () {
    while (inputData && (inputData[0] < "0" || "9" < inputData[0])) {
      inputData = inputData.slice(1);
    }
    if (inputData) {
      var inputNumber = inputData.match(/\d+/)[0];
      inputData = inputData.slice(inputNumber.length);
      result = +inputNumber;
    } else {
      result = -1;
    }
    var stdinDisplay = document.getElementById('stdin-display');
    stdinDisplay.innerHTML = escapeEntities(inputData);
    return result;
  },
  displaySource: function (formattedCode) {
    var sourceDisplay = document.getElementById('source-display');
    sourceDisplay.innerHTML = formattedCode;
  }
};
var program = null;
var inputData = null;
function showEditor() {
  var source = document.getElementById('source'),
    sourceDisplayWrapper = document.getElementById('source-display-wrapper'),
    stdin = document.getElementById('stdin'),
    stdinDisplayWrapper = document.getElementById('stdin-display-wrapper');

  source.style.display = "block";
  stdin.style.display = "block";
  sourceDisplayWrapper.style.display = "none";
  stdinDisplayWrapper.style.display = "none";

  source.focus();
}
function hideEditor() {
  var source = document.getElementById('source'),
    sourceDisplay = document.getElementById('source-display'),
    sourceDisplayWrapper = document.getElementById('source-display-wrapper'),
    stdin = document.getElementById('stdin'),
    stdinDisplay = document.getElementById('stdin-display'),
    stdinDisplayWrapper = document.getElementById('stdin-display-wrapper');

  source.style.display = "none";
  stdin.style.display = "none";
  sourceDisplayWrapper.style.display = "block";
  stdinDisplayWrapper.style.display = "block";

  var sourceHeight = getComputedStyle(source).height,
    stdinHeight = getComputedStyle(stdin).height;
  sourceDisplayWrapper.style.minHeight = sourceHeight;
  sourceDisplayWrapper.style.maxHeight = sourceHeight;
  stdinDisplayWrapper.style.minHeight = stdinHeight;
  stdinDisplayWrapper.style.maxHeight = stdinHeight;
  sourceDisplay.textContent = source.value;
  stdinDisplay.textContent = stdin.value;
}
function escapeEntities(input) {
  return input.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>');
}
function resetProgram() {
  var stdout = document.getElementById('stdout');
  stdout.value = null;
  if (program !== null) {
    program.halt();
  }
  program = null;
  inputData = null;
  showEditor();
}
function initProgram() {
  var source = document.getElementById('source'),
    stepsPerSecond = document.getElementById('steps-per-second'),
    stdin = document.getElementById('stdin');
  program = new Program(source.value, +stepsPerSecond.innerHTML, ioFunctions);
  hideEditor();
  inputData = stdin.value;
}
function runBtnClick() {
  if (program === null || program.snakesLiving == 0) {
    resetProgram();
    initProgram();
  } else {
    program.halt();
    var stepsPerSecond = document.getElementById('steps-per-second');
    program.speed = +stepsPerSecond.innerHTML;
  }
  program.run();
}
function stepBtnClick() {
  if (program === null) {
    initProgram();
  } else {
    program.halt();
  }
  program.step();
}
function sourceDisplayClick() {
  resetProgram();
}
.container {
    width: 100%;
}
.so-box {
    font-family:'Helvetica Neue', Arial, sans-serif;
    font-weight: bold;
    color: #fff;
    text-align: center;
    padding: .3em .7em;
    font-size: 1em;
    line-height: 1.1;
    border: 1px solid #c47b07;
    -webkit-box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
    text-shadow: 0 0 2px rgba(0, 0, 0, 0.5);
    background: #f88912;
    box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
}
.control {
    display: inline-block;
    border-radius: 6px;
    float: left;
    margin-right: 25px;
    cursor: pointer;
}
.option {
    padding: 10px 20px;
    margin-right: 25px;
    float: left;
}
h1 {
    text-align: center;
    font-family: Georgia, 'Times New Roman', serif;
}
a {
    text-decoration: none;
}
input, textarea {
    box-sizing: border-box;
}
textarea {
    display: block;
    white-space: pre;
    overflow: auto;
    height: 100px;
    width: 100%;
    max-width: 100%;
    min-height: 25px;
}
span[contenteditable] {
    padding: 2px 6px;
    background: #cc7801;
    color: #fff;
}
#stdout-container, #stdin-container {
    height: auto;
    padding: 6px 0;
}
#reset {
    float: right;
}
#source-display-wrapper , #stdin-display-wrapper{
    display: none;
    width: 100%;
    height: 100%;
    overflow: auto;
    border: 1px solid black;
    box-sizing: border-box;
}
#source-display , #stdin-display{
    font-family: monospace;
    white-space: pre;
    padding: 2px;
}
.activeToken {
    background: #f93;
}
.nextActiveToken {
    background: #bbb;
}
.swallowedCode{
    color: #999;
}
.clearfix:after {
    content:".";
    display: block;
    height: 0;
    clear: both;
    visibility: hidden;
}
.clearfix {
    display: inline-block;
}
* html .clearfix {
    height: 1%;
}
.clearfix {
    display: block;
}

<textarea id="source" placeholder="Enter your program here" wrap="off">i.)o</textarea>

<textarea id="stdin" placeholder="Input" wrap="off">Hello, World!</textarea>

<input type="button" id="run" class="control so-box" value="Run" onclick="runBtnClick()" /><input type="button" id="pause" class="control so-box" value="Pause" onclick="program.halt()" /><input type="button" id="step" class="control so-box" value="Step" onclick="stepBtnClick()" /><input type="button" id="reset" class="control so-box" value="Reset" onclick="resetProgram()" />

<textarea id="stdout" placeholder="Output" wrap="off" readonly></textarea>

Steps per Second:
10

ಠ_ಠ, 7 bytes
ಠ_ಠ

Try it now! ಠ_ಠ
This isn't even a code-golfing language.

Seriously, 7 bytes
	W+	W+R

Hexdump (reversible with xxd -r):
00000000: 0957 2b09 572b 52                        .W+.W+R

Explanation (tabs are replaced with \t for clarity):
\tW+\tW+R
\t         read a single byte of input
  W+\tW    while TOS is truthy:
   +         append
    \t       read a single byte of input
       +R  append, reverse, and implicitly print

Try it online!

Link not found for IDE

just don't go breaking my heat

Link is dead. Also, why do you swap the top two elements? Is it that there is an element other than the input byte?

@EriktheOutgolfer Seriously is stack-based, so without swapping, the output would be reversed.

Shtriped, 20 bytes
e )
"
 r )
 s )
 "
"

This cheekily demonstrates that nearly any printable ASCII string is a valid identifier in Shtriped.
How it works:
e )   \ declares a variable named )
"     \ defines a function with 0 arguments named "
 r )  \ gets a line of string input, saving it to )
 s )  \ prints ) as a string
 "    \ recursively calls ", effectively looping forever
"     \ calls " from the main scope to get things started

There's no real way to detect EOF, so this loops forever like the Python answer.
You can easily make it stop when an empty line is given though (30 bytes):
e )
"
 r )
 d ) \ tries to decrement ), if it was the empty string, aka 0, it can't, so 0 is returned all the way up
 i ) \ increment ) to put it back to normal after possibly decrementing
 s )
 "
"

Note that Shtriped I/O only supports printable ASCII, tabs, line feeds, carriage returns, vertical tabs, and form feeds (100 chars in total). This is because internally, strings are represented as non-negative arbitrary precision integers, and there must be a finite alphabet of characters to be able to encode all strings.

Sesos, 1 byte
Y

This program handles both infinite streams and null bytes.
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 mask ; Switch to unsigned 8-bit cells.

         ; (implicit jmp)
         ;     Set an entry marker and jump to the jne instruction.
    put  ; Print the byte in the current cell to STDOUT.
jnz      ; (implicitly promoted to jne)
         ;     Read a byte from STDIN and save it in the current cell.
         ;     If EOF has not been hit, jump to the previous instruction.

How does set mask have anything to do with null bytes?

set mask has nothing to do will null bytes. Using character-based I/O would only work with certain locales though. If the locale uses, e.g., UTF-8, an input consisting of a single 0xFF byte would error.

Pyramid Scheme, 199 116 bytes
Saved 83 bytes thanks to Khuldraeseth na'Barya! Clever idea to use the "nameless" variable, an empty triangle.
   ^
  /d\
 / o \
^-----^
-    ^-^
    ^-/ \
   ^-/out\
  / \-----^
 /set\    -
^-----^
-    /l\
    /ine\
    -----

Try it online!

Old version (functionally equivalent)
      ^
     / \
    /do \
   ^-----^
  /A\   / \
  ---  /   \
      /     \
     /       \
    ^---------^
   / \       / \
  /set\     /out\
 ^-----^   ^-----
/A\   /l\ /A\
---  /ine\---
     -----

Try it online!
Explanation
This might look like this in a scheme/lisp-like language:
(do (pair (set A read-line) (print A)) A)

Or, in a C-like language:
do {
    A = gets();
    puts(A);
} while(A);

125 bytes

116

@Khuldraesethna'Barya Fascinating structure... Thanks!

Can you add some documentation for this language? I would like to try it out

@JoKing Sure thing! I'm going off to bed rn, I'll add it to my todo list and I'll ping you once I'm done.

unsure, 78 bytes
hm um err wait oops but um yeah err heh wait then well but oops okay well wait

I just invented this esolang, which is based off brain-flak. This program abuses a lot of control flow tricks, such as omitting the first but, which should start the first loop. It basically copies all of the input to the other stack (there's an active and non-active stack), and then outputs it all.
hm        Take input
um        Push 1 to the stack
err       Push the sum of the top 2 items
wait    Repeat if not 0
oops    Discard the top of the stack
but     Start another loop
um        Push 1 to the stack
yeah      Negate
err       Push the sum of the top 2 items
heh       Pop the active stack, push to the other one
wait    Repeat
then    Swap active stack
well    Push stack length
but     Start another loop
oops      Discard the top of the stack
okay      Output the top of the stack
well      Push the stack length
wait    Repeat

unsure, 22 bytes (doesn't work with null bytes)
hm uh okay um err wait

This one repeatedly takes input, duplicates it, outputs it, and increments it (as EOF is -1, and the wait will only stop when the top of the stack is 0).

NLRNIS, 12 bytes
&m>x
"_*m*x@

Explanation:
&#

Store input to m
>x
"

x = newline
_

if EOF then halt
*m*x

print variable m with newline
@

Repeat

Python 2, 52 bytes
from sys import*
while 1:stdout.write(stdin.read(1))

Python will only echo when a newline has been pressed because by default the terminal only sends input to the program after a newline.
OR, 25 bytes
while 1:print raw_input()

In this program, the code explicitly waits for a newline before printing

@Mego the issue is on read... but that only applies when input is a terminal, and depends on the terminal's mode. Though you can press Ctrl-D in the middle of a line to make it output immediately.

@Mego Not in the middle of the line unless you press it twice without typing anything else. Try it and see.

good catch, sorry

No, this code is invalid in Python 2 as well. The semicolon should be a newline.

@EriktheGolfer I'm doing stdin.read as well as stdout.write

@muddyfish Oh, sooo blind me!!

Befunge-93, 9 6 bytes
This solution (thanks to ninjalj!) depends on 0 % 0 throwing an error and halting, thus it will not work in all interpreters (like this one, where it's NaN instead and does not halt, though no more characters are outputted).
~:1+%,

~ reads in a character from input (-1 on EOF), then :1+ duplicates it and adds 1, so we now have either [0,0] or [n,n+1] on the stack. 0 % 0 is undefined, which (possibly) throws an error whereas n % (n+1) is simply n. , outputs as character.

Solution that does not depend on STDERR (9 bytes):
~:1+!#@_,

~ reads in a character from input (-1 on EOF), :1+ duplicates it and adds 1, ! "not"s this, then the # is a trampoline that jumps the program counter over the @. _ is a horizontal branch that goes right if the top of stack is 0, left otherwise. This is why I needed to ! the input + 1 earlier.

For what it's worth, you can try to get rid of the ! by reversing program flow. Unfortunately, to do this, you have to add a < and that simply produces another 9-byte solution:
<,_@#+1:~

Using the stderr rule, you can golf it to 6 bytes: ~:1+%,. This trick is used a lot in golf.shinh.org

@ninjalj: Nice tip! Doesn't work in the Befunge interpreter I usually use though; 00% results in NaN. I'll include it anyway.

Perl, 18 bytes
print while$_=getc

Will handle null bytes and infinite streams.

Since the currently top answer consists of a sed invocation with no commands, you could also shorten this to perl -pe ''. However for the scope of the question your current solution is way more interesting, so if you do switch to the cheaty perl -pe '' please also leave your current solution.

The problem with perl -pe '' is that it would only work if the input was finite or contained occasional newlines.  By using getc it can handle an infinite stream of input without newlines.

Javascript, 25 23 22 bytes
for(;;)alert(prompt())

Edit: Thanks to stefnotch for saving 2 3 bytes

You could golf it like this: for(;;alert(prompt()));  Here is a link that might help: http://codegolf.stackexchange.com/questions/2682/tips-for-golfing-in-javascript/

Just realized that you could have the function outside the loop, saving yet another byte for(;;)alert(prompt())

Perl 5, 11 + 1 (-p flag) = 12 bytes
perl -pe 'INIT{$/=\1}'

Sets the input record separator in an INIT block to work with infinite streams without newlines.

Is this version-dependent? I tried it with Strawberry 5.20.2 and it waited for newlines.

@msh210 That's something different. On a terminal, stdin is usually line-buffered, so this behavior is completely normal (just like cat).

Very cool! It's a shame you can't set this with -0. Also, -p only adds one byte, not two.

@ThisSuitIsBlackNot This page says: "This supposes stuff needs no quoting to go in single quotes, or it would need more characters to escape. If not, either the escape characters are counted in as well, or you put the script in a file, and count the difference to perl -nl file.pl, which now includes the hyphen as well as one of the spaces." I removed the single quotes at the expense of a backslash.

@nwellnhof That just means that if putting stuff in single quotes requires escaping things, you also have to count the escapes. For example, say"It's alive!" contains a single quote, so you can't put it inside single quotes without escaping. Your answer requires no escaping to go in single quotes, so it scores 11 bytes for the contents of the single quotes, and 1 byte for the -p flag, for 12 total. No need to remove the single quotes, and no need to count them.

Macaroni 0.0.2, 44 chars
label l print set s read map slice s 0 1 1 l

Explanation:
label l           "define a label, which we need later"
print set s read  "read a line, set the variable s to it, and print it"
map
  slice s 0 1 1   "get the first element of the array s"
                  "this returns an array of either length 0 (if s was originally
                   empty) or 1"
  l               "map the resulting array over label l—essentially a
                   conditional goto"

PDP-11 Unix Assembly, 38 bytes binary
s: xor r0, r0;      / set r0 to 0 (stdin)
   sys read; b; 1;  / read one byte
   tst r0; beq e;   / check return value, goto e if zero.
   sys write; b; 1; / fortuitously, r0 = 1 here. write one byte.
   br s;            / go to loop start.
e: sys exit;        / exit [r0 = 0]
.bss
b: .=.+1

I'll assemble it later to show the binary output (I haven't golfed the source yet either), but with symbols stripped this should come out to 36 bytes compiled: a 16-byte a.out header, and 2 bytes per instruction word (10, including arguments to system calls).
Note that the use of one-byte reads is not to save space (.bss variables take no space in the binary), it is so that the byte count argument to write can be hardcoded.
The OG is much larger by comparison. By my count, 60 instruction words, so 128 bytes. Of course, it has to loop through files on the command line (the original purpose of cat).
The binary output:
0000000 000407 000026 000000 000002 000000 000000 000000 000001
0000020 074000 104403 000026 000001 005700 001404 104404 000026
0000040 000001 000766 104401
0000046

38 bytes, as promised.
Source golfed: 59 bytes
s:74000
sys 3;b;1
5700;beq e
sys 4;b;1
br s
e:sys 1
b:.=.+1

Since I left out .bss, this generates a slightly larger binary at 40 bytes even.

D, 94 bytes
import std.stdio,std.algorithm;void main(){stdin.byChunk(1).copy(stdout.lockingTextWriter());}

I'm no D expert at all, so there might be a better way to do this.

I don't think you need the parens after stdout.lockingTextWriter.

Mathematica, 43 bytes
While[a=!=EndOfFile,Print[a=InputString[]]]

Uhh, I think you meant While[Echo[InputString[]]=!=EndOfFile] which has the same byte count, but can be shortened to While[Echo@InputString[]=!=EndOfFile]

Ruby, 19 bytes
This one handles arbitrary input like a champ:
print while gets 1

Ruby, 1 byte
An empty program run with the p flag behaves almost exactly like cat, but doesn't print until it hits a newline or EOF:
$ touch cat.rb
$ yes | ruby -p cat.rb
y
y
y
y

(...)
Ruby, 9 bytes
Basically the same, but doesn't need the p flag to be entered from the command line:
#!ruby -p

Not the most exciting entry, but I thought it should be in the catalogue.

touch echo.rb; (while true; do echo -n a; done) | ruby -p echo.rb never flushes for me.

@Mauris never? You don't know that unless you've solved the halting problem (or it crashes?) :) Kidding, but omg this question is tl;dr. I'm sure you're right though.

@Mauris there,  19 byte solution even works with your infinite stream of a's :)

Ah, that one does the trick. Very cool! :)

Marbelous, 11 bytes
00
\\/\]]!!

How it works.
The 00 is a language literal, it represents 0, but could be exchanged for any hexadecimal value in this case. On the first tick, this value will fall down and hit \\ which is a deflector and will shove the marble to the right.
/\ is a cloner, which puts one marble to the right, back onto the deflector, this creates an infinite loop. The second copy will be placed to the right. This copy will hit the ]] device, which fetches the first character on STDIN and outputs its ascii code below. This will put the resulting marble off the botom of the board ; any marble that falls off the board gets printed to STDOUT.
In case there is nothing on STDIN, the ]] device will push the input marble too the right. There it will trigger the !! device, which terminates the board.

Carrot (version: ^3), 3 1 bytes
#

Explanation of code:
Basically prints the input to the output. The caret ^ is not needed because we do not wish to use any commands. Every instance of # is replaced with the input.

Carrot cannot handle infinite output yet as # is the only way to get the input in a string format.

ngn APL, 7 bytes
{∇⍞←⍞}1

ngn APL only supports linewise input and has no actual looping constructs, so this recursive function is as good as it gets. It prints null bytes, but only if they do not occur on the last line.
How it works
{    }   Define a function.
  ⍞←⍞    Read and print a line.
 ∇       Call the function again.
      1  Call the function with dummy input.

⍞ exits automatically on EOF.

There is the looping construct ⍣. It's just not so procedural.

I haven't been able to get ⍣ working for this task. Anyway, -⍣≡1 leaks memory, so the result would probably be the same.

Rail, 19 bytes
$'main'
@-i\
  \o-@

Rail is such a pain to golf... :D
This terminates with an error upon hitting EOF but handles null bytes and infinite streams without an issue.
The execution path starts from the $ going South-East. On - the train turns East, i reads a character. On \ the train turns South-East, and on - East again. @ reverses movement direction. The train now moves West, where o outputs the character again. \ turns the train North-West, - turns it West and @ reverses it once more. At this point we're in a loop between the two @, which terminates when i tries to read the end of the stream.
With a properly tail recursive interpreter, there is an 18-byte solution as well, but I can't currently test whether the reference implementation could handle it (which I doubt):
$'main'
 -io{main}

GOTO++, 80 bytes
§1
J=ENTRETONTEXTE()
GOTOPRINT()
GOTONONNULPOURLESNULS %1 entreestd@Fin() - *(1)

Well, GOTO++…As far as I can see, you can either read a line or a number but you can't read a string of a given length. Or just a character for that matter. So this program unfortunately needs linefeeds in its input if it is to ever output anything.

Templates Considered Harmful, 4 bytes
A<1>

This is a language which is executed by having the C++ compiler figure out the type of a typedef in a template. The language only supports finite input.
A<1> refers to the first argument of an anonymous function. All user-defined functions are anonymous. A program is implicitly wrapped in Fun<>, so it defines a function that returns its first argument, which is the input.

Gaot++, 171 bytes
bleeeeeeeeeeeet
bleeeet bleeeeeet
bleeeeeeeeeet bleeeet blet
bleeeeeeeeeeeet bleeeet blet
bleeeeeeeeeeeeet bleeeet blet
bleeeeeeeeeeeeet bleeeet blet
bleeeeeeeet bleeeeeet

Compressed: 12e 4e 6e 10e 4e 1e 12e 4e 1e 13e 4e 1e 13e 4e 1e 8e 6e
Try it online!
Explanation
X 4e 1e, where 1e (blet) is a nop, basically forms a pattern where if you go from left to right, X is executed, but not from right to left.
Alternatively, if you have X 4e Y, then X is executed when you go from left to right, and Y otherwise.

Just a suggestion: use b instead of blet. Use b instead of 1e. I have tested it, and it works.

Addict, 31 bytes
Addict is my new Turing-tarpit esolang, based on PRINDEAL. Addict has 5 commands: alias, decrement, increment, char, and take. See the GitHub repo for more details.
a I
 t c
 O
 d
a O
 c c
 I
 d
I

Test it online here!
This basically defines a loop which repeatedly inputs a charcode and outputs it, until EOF is reached. Ungolfed version:
a input  # Define a command `input` that does the following:
 t char  #   Set variable `char` to the next charcode in the input.
 output  #   If there is a next charcode, run command `output`.
 d       #   Otherwise, just exit.

a output # Define a command `output` that does the following:
 c char  #   Output variable `char` as a charcode.
 input   #   Attempt to input again.
 d       #   (This line never gets run.)

input  # Run command `input`.

05AB1E, 4 2 bytes (not working)
|»

Try it online!
Golfed from 4 to 2 bytes thanks to @daHugLenny!
Explanation
|       Takes input as array separated by breaks
 »      Join input array by newline
        Implicitly print

You can replace vy, with ».

Doesn't I work?
http://05ab1e.tryitonline.net/#code=SQ&input=c2FkZ3NkZmdnaDM0NQ

@carusocomputing not for multiline input, unfortunately.

@carusocomputing try it here.

I missed the multi-line part, good call.

crossed out 4 is still regular 4 ;(

Unfortunately, this prints a newline after the input, and strips multiple trailing newlines in the input to one in the output.

Here's an even bigger violation of the spec. Double newline seems to halt the output entirely.

R, 14 bytes
Output stdin, nothing fancy.
cat(scan(,''))

If stdin consists solely of numbers, you can do it in 11 bytes with cat(scan()).
As far as I know, there's no way to handle infinite input.

I think it should be cat(readLines()). The issue with scan is that it does not behave properly with whitespace. What do you think?

Brain-Flak, 0 + 3 = 3 bytes
Needs the -c flag.

Try it online!
This language cannot possibly handle infinite input streams.
This language absolutely always appends a trailing newline to the output.
In the original Ruby interpreter, the input is a command-line arg instead of a STDIN stream. The online interpreter seems to have been modified.

Whitespace, 29 26 bytes

Try it online!
Continuously reads a character from STDIN and outputs it to STDOUT. Unprintable characters including NUL bytes are handled like any other character, only EOF will terminate the program.
Explanation
(s - space, t - tab, n - newline)
nssn # Label ''
sssn # Push 0 - stack: [0]
sns  # Duplicate the top item on the stack - stack: [0, 0]
tnts # Pop, read a character from STDIN and place it at the address given by the popped value - stack: [0] heap: [0:<char>]
ttt  # Pop, push the heap value at the address given by the popped value - stack: [<char>]
tnss # Pop, output the popped value as a character to STDOUT - stack: []
nsnn # Jump to label ''

Gol><>, 2 bytes
credit to Jo King
io

Try it online!
Errors out on EOF. The error message goes to stderr.
How it works
io

i   Push an input char
 o  Pop and print; error if last input hit EOF
    Repeat indefinitely

Gol><>, 4 bytes
iE;o

Try it online!
No-error version.
How it works
iE;o

i     Push an input char
 E;   Halt on EOF
   o  Pop and print
      Repeat indefinitely

Shakespeare Programming Language, 96 bytes
,.Ajax,.Page,.Act I:.Scene I:.[Exeunt][Enter Page and Ajax]Ajax:Open mind!Speak thy!Let usAct I!

Try it online!
Some nice and weird grammer. Terminates in an error.
Shakespeare Programming Language, 125 bytes
,.Ajax,.Page,.Act I:.Scene I:.[Exeunt][Enter Page and Ajax]Ajax:Open mind!Be you nicer a pig?If sospeak thy!If solet usAct I!

Try it online!
Non-erroring version. I especially liked constructing the sentence If solet usact I!

Grocery List, 14 bytes
*but it doesn't look like a grocery list
h

i
l
p
i
e
t

Explanation:
Title

i nput
l oop
p op and print
i nput
e nd loop if nonzero
t erminate

Keg, 0 8 bytes
{?(,)\
,

Supports multi-line input now. Halts in an error, which is allowed by default
Try it Online!

fixed (padding)

C, 17, 16 bytes
main(){tee(0,1);}

This only works on certain compilers (such as tutorialspoint which uses GCC), but it's really short.

main(){tee(1j);}

Edit: Now down to 16 bytes! j is a GNU suffix which acts as a complex
number. Basically tee(1j) == tee(0,1). This trick also only works in rare cases.

Plumber, 16 bytes
[]=[[]
 [[[[=
][][

First answer in my new esolang!
Programs in plumber are divided into 2 character wide units, each of which performs a certain function. All [] units on the top row will drop a packet containing the value 0. The one on the right will hit the [=, which will pop input and push it left into a right-facing branch dropper ([[). Branch droppers push in the direction they are facing, and also drop the value. When the value is pushed into the [=, it is outputted.
Plumber uses -1 for EOF, and outputting a negative value does nothing. When the value drops into the ][][, it moves upward on the far left, passes through an increment ( [) operator, and is picked up by the []. If it is not 0, is passes through the conditional (=[), and is dropped by the [] on the right. This continues until the input is -1.

vJASS (Warcraft 3), 202 181 bytes
Using //! import zinc "<code_path>" command to exclude //! zinc and //! endzinc.

library a{trigger t=CreateTrigger();function onInit(){TriggerRegisterPlayerChatEvent(t,Player(0),"",false);TriggerAddAction(t,function(){BJDebugMsg(GetEventPlayerChatString());});}}

Readable Version:
library a{
   trigger t = CreateTrigger();

   function onInit(){
      // Create an INPUT EVENT
      TriggerRegisterPlayerChatEvent(t, Player(0), "", false);
      TriggerAddAction(t, function(){BJDebugMsg(GetEventPlayerChatString());});
   }
}

MAWP, 7 bytes
|0~[;].

Try it!
Explanation:
|      Push input to stack
0      Add a zero to stack
~      Reverse stack
[;]    Output each character from stack until 0
.      Terminate program

v³, 5 bytes
No interpreter yet, but:
#@$,*

When unfolded into a cube, it adds a no-op:
  #
@ $ , *
  .

The IP starts in the top cell (#) and "falls" downwards, into the $. I'll try to explain the code the best I can (which is not very well):
#   Later acts as "ground," not letting the IP pass through it. However, the IP checks for ground AFTER running commands, so '#' does nothing here.
    (The IP falls downwards after running each command.)
$   Ignores the next command if the current memory cell is 0. The memory cells all start at 0, and since the memory has not been changed at all, it ignores the next command.
.   No-op, does not count as command.
    (If the IP goes out of the area, it goes to a corresponding cell and rotates its direction and , as if the code were written on the faces of a cube.)
*   Prints the output from the current memory cell. However, this is not run, because '$' ignored this command.
    (If the IP falls or moves into '#', it snaps back to its previous position and moves in its given direction. It starts facing right, however after leaving the cube's map, it now faces left, so the IP now moves left and continues to do this for the rest of the program's runtime.)

,   ("Actual" start of program) Inputs next ASCII character in input to the current memory cell.
$   Ignores next command if the end has been reached (EOF returns 0).
@   Terminates the program if the end has been reached.
*   Output ASCII character from the current memory cell.

(Program continues from last ',')

I don't think it's possible to golf it into 4 bytes, but I hope I'm wrong.

Looks like an interesting language! Did you make it?

@RedwolfPrograms Yep :) It's basically a mix between MarioLANG and Cubix.

If you write an interpreter make sure to let me know, as this (or another) answer will be able to receive a bounty!

@RedwolfPrograms Made an interpreter! https://repl.it/@BoTie/v3-Interpreter#script.txt

Looks really cool! Definitely deserves the bounty. Let me know if you want it on this answer, or if you think a different one would show off more of the features!

@RedwolfPrograms Thanks so much! I think this answer shows off the main features pretty well, so I think I'd like the bounty on this answer. Again, thank you!

Bounty added, thanks!

Arduino, 45 27 + ? bytes
This is a pretty standard diagnostic test for Arduino serial ports, just golfed down a little.
void setup(){}void loop(){}

After testing, it turns out the Serial.begin(300); is totally unnecessary, making this code the same as the shortest infinite loop.
The ? is because this requires a physical wire connecting pin 0 to pin 1, and I have no clue how to count that. For completeness' sake, here's a version that doesn't require that, which is 95 91 bytes:
#define S Serial
void setup(){S.begin(300);}void loop(){S.available()&&S.write(S.read());}

Or, cleaned up a little:
#define S Serial

void setup() {
  S.begin(300);
}

void loop() {
  S.available() &&
    S.write(S.read());
}

The S.available() check is necessary because Serial.read() returns -1, not 0, when there are no bytes available to read.

You don't generally have to count hardware stuff, which is a rule that mostly makes sense but breaks down for this sort of thing. The reasoning is that different hardware is a different language.  For example 45 bytes of clojure code that only works on intel processors is not better than 46 bytes of clojure that works on any processor, just like 6 bytes in Jelly is not better than 304 bytes of Java.  They are different.  So as weird as it sounds this is a 45 byte answer in the language "Arduino, with a wire connecting pin 0 to pin 1".

It kind of sucks that there is no official way to count this, but that's just kind of how it is.  Hardware stuff is just not super well supported.  Welcome to the site anyway!

Spice, 14 bytes
;n@REA n;OUT n

Explanation:
;n@     Declare 'n'
REA n;  Read input into 'n'
OUT n   Output value of 'n'

Python 3, 50 bytes
import sys
while 1:print(sys.stdin.read(1),end='')

See comment in my python 2 answer about newlines.
OR 29 bytes
while 1:print(input())

Waits explicitly for newlines before printing. (This means that it won't print anything after a newline before the next)

Adds trailing newline.

Can't you do print(end=sys.stdin.read(1))?

I've found a shorter one using os.read/write and fd numbers, it is 42 bytes. https://tio.run/##K6gsycjPM/7/P60oP1chv1ghM7cgv6hEi6s8IzMnVaG8KLMkVcNQpyg1MUXDQMdQU9PK4P//ktTiEgA

Feel free to post it yourself and take the credit for it^^

Does input always have to be read? If not you could cut off 8 bytes to print(input())

That'll only print until a newline, which isn't allowed

C--, 171 bytes
target byteorder little;import getchar,putchar;export main;foreign"C"main(){t:bits32 v;v=foreign "C" getchar();if(v!=-1){foreign"C"putchar(v);goto t;}foreign"C"return(0);}

Considering C-- is essentially a "portable assembler", I shouldn't be surprised that this was huge.

Befunge-98, 4 bytes
#@~,

The program counter starts moving to the right in the top-left corner of the program. # causes it to jump over @, landing on ~. This reads a character, or reflects the PC on EOF. If EOF is reached, this will cause it to run into @, which ends the program. Otherwise, it continues to ,, which prints the character that was read, and loops back to # thanks to Lahey-space.

Is the reflect-on-EOF behavior in the spec? I didn't know about it before. (Then again, I coded mostly in Befunge-93.)

Yeah: In the case of an end-of-file or other file error condition, the & and ~ both act like r.

Huh, interesting. The lack of this behavior in Befunge-93 added five bytes! Doubled the program length!

Pyth, 28 bytes
V$__import__('sys').stdin$pN

Not as short as @Mauris's Pyth answer, but it handles infinite input.

Erlang, 108 Bytes
Uses escript to run. Making the code a one-liner seems to cause an EOF error from the interpreter.
#!/usr/bin/env escript
main(_)->f(a).
f(eof)->ok;f([C])->f(io:format("~c",[C]));f(_)->f(io:get_chars('',1)).

Julia, 45 bytes
while !eof(STDIN) print(read(STDIN,Char))end

Ungolfed + explanation:
while !eof(STDIN)             # While EOF has not been encountered from STDIN
    r = read(STDIN, Char)     # Read a single character from STDIN
    print(r)                  # Print it to STDOUT with no trailing anything
end

This supports an infinite input stream and null bytes and has no extraneous output.
Thanks to Dennis and Martin Büttner for their help on this!

lua for windows, 38 bytes
Needs lua for windows
while true do io.write(io.read()) end

how it works
It prints the input from the terminal

You can make it shorter using a true condition _G (the global table) and removing the space after the last brace.

Java, 120 bytes
The other Java solution is shorter than mine but, it uses Apache libraries to get the job done. I think it's worthwhile to put forward a java solution that relies solely on the java standard libraries.
This code works for infinite input and for input that contains null bytes.
class C{public static void main(String[]a)throws Exception{byte[]b={0};while(System.in.read(b)>=0)System.out.write(b);}}

Ungolfed
import java.io.IOException;

public class Cat {
  public static void main(String[] args) throws IOException {
    byte[] input=new byte[1];
    while(System.in.read(input)>=0){
      System.out.write(input);
    }
  }
}

You don't need public in the class declaration. You can just throw Exception instead of IOException and not have to import anything in the Ungolfed version.

Using the stderr rule, you could abuse an enum: enum C{C;System z;{try{byte[]b={0};while(z.in.read(b)>=0)z.out.write(b);}catch(Exception e){}}}

@ninjalj I can't figure out how to get the compiled class to execute the code block without loading the class from some other program. Is there anyway to execute it from the command line?

@dohaqatar7: java -classpath <wherever> C should work.

Emmental, 20 bytes
;#44#46#35#57#63#9!<tab>

The program ends with a tab character. This beats the example on the wiki page by redefining and invoking the tab character (ASCII 9) instead of the asterisk (ASCII 42). The spec doesn't really mention what , does at EOF, but the reference implementation uses getChar, which raises an IOError when the file ends. (The , is "quoted" as #44 in the above program.)

QBasic, 15 bytes
?INPUT$(1);
RUN

QBasic doesn't have any concept of input or output streams (except maybe where files are concerned). The above program instead takes any character you enter and echoes it to the screen, which I think fits the spirit of the challenge. RUN restarts the program from scratch, thus continuing to read and echo forever (there's no EOF for keyboard input, and I don't think it's even possible to enter a null byte).
Here's a 34-byte version that quits when you press escape. The … should be replaced with a literal Esc character, ASCII 27. This can be entered in the QBasic editor by holding the Alt key while typing the character code; it shows up as a ←.
9?x$;
x$=INPUT$(1)
IF"…"<>x$THEN 9

TECO, 4 bytes
<^T^T>

^T is CTRL+T.  It should be self-explanatory how this works.

 For those of you who can't read this infamously write-only language, it simply loops over the input (<>), reading (^T) and immediately printing (^T) bytes.

PHP, 20 bytes
<? fpassthru(STDIN);

Kind of surprised there isn't one for PHP yet...

I bet you can get rid of the space.

Run it with -r and you can get rid of the opening tag altogether. echo -e "Hello\nWorld" | php -r 'fpassthru(STDIN);' 17 bytes

Groovy, 39 bytes
System.in.eachByte{System.out.write it}

Since I wrote a proof-of-concept to confirm that Groovy can handle infinite stream, might as well post it as an answer.
Usage:
groovy `

var pipe = function () { output.textContent = input.value; },
    output = document.getElementById('output'),
    input = document.getElementById('input');
input.addEventListener('keyup', pipe);
<input id="input"/>

Fishing, Dock length 2, 9 bytes
v+CC
  IP

I takes an input and P prints it. Note that N can be substituted for P to produce a trailing newline.

You might want to note that Fishing is not capable of a) preserving linefeeds, b) determining EOF, c) reading arbitrary infinite streams, because it always reads lines (waiting for a linefeed character)... at least as far as the reference interpreter goes. Also I don't think it's fair to count this by the dock length. The byte count of this code is 9 bytes.

Go, 66 bytes
package main
import("io"
."os")
func main(){io.Copy(Stdout,Stdin)}

Go has an io.Copy function which writes what reads; until EOF.

ROOP, 5 bytes
I
W
O

Never ends.

WhoScript, 39 bytes
1pr;v;#0 1;-;i;>;e;<;t=;ti;o;tl;pw;pr;d

I think its best explained by watching the stack change over time.
psychic_paper read          @ [input]
time_vortex                 @ [input]
  # 0 1                     @ [input, 0, 1]
  -                         @ [input, -1.0]
  integer                   @ [input, -1]
  pop                       @ [input]
  duplicate                 @ [input, input]
  push                      @ [input, input, -1]
  TARDIS =                  @ [input, input==-1]
  TARDIS if                 @ [input]
    opening                 @ [-1] (it won't come this far otherwise)
  TARDIS landing            @ [input | -1]
  psychic_paper write       @ []
  psychic_paper read        @ [input]
paradox                     @ Phew!

The program will accept any input so long as you don't find a character whose ASCII code is -1. The program works best if input is provided from the command line, else it will just take one character at a time until you quit providing new ones.

AnnieFlow, 2 bytes
11

The first 1 indicates that the program accepts input, and the second 1 indicates that there is one stack. The output stack has no changeable behavior, so that's the only information the program needs. Because the output stack is always the first stack and the input stack is always the last stack, they coincide in this case, so when the input stack is filled, it outputs the same to STDOUT instead of storing it. In any program, after the input stack is filled it is popped to start the program. However, popping from the output stack halts the program. Therefore the program halts immediately after outputting the input. This was not an intended feature, it just happened to work out the way it does because of how the programming language works.

Y, 4 bytes
i:gF

Simple enough. This two-link program takes input characters and prints them out as you feed input. Input an empty string to terminate. Explanation:
i:g F
i      take input (string)
 :     duplicate
  g    print one item
    F  conditional link: pop N, and if N is zero (falsey), i.e. empty string, continue.
       otherwise, move to beginning of current link

SPARC (V9) assembly, 64 bytes
This runs on NetBSD (I seem to be running version 6.1.5). Disassembly with objdump:
0000000000100078 <.text>:
  100078:   9c 23 a0 08     sub  %sp, 8, %sp
  10007c:   82 10 20 03     mov  3, %g1
  100080:   90 10 00 00     mov  %g0, %o0
  100084:   92 10 00 0e     mov  %sp, %o1
  100088:   94 10 20 01     mov  1, %o2
  10008c:   91 d0 20 00     ta  0
  100090:   02 ca 00 07     brz  %o0, 0x1000ac
  100094:   82 10 20 04     mov  4, %g1
  100098:   90 10 20 01     mov  1, %o0
  10009c:   92 10 00 0e     mov  %sp, %o1
  1000a0:   94 10 20 01     mov  1, %o2
  1000a4:   10 bf ff f6     b  0x10007c
  1000a8:   91 d0 20 00     ta  0
  1000ac:   9c 03 a0 08     add  %sp, 8, %sp
  1000b0:   82 10 20 01     mov  1, %g1
  1000b4:   91 d0 20 00     ta  0

Explanation (line-by-line):
First of all, the SPARC architecture has a ton of registers. You have access to 32 of them at a time, called %gX, %iX, %lX, and %oX for X in [0..7].  There are also %pc for the program counter and %sp for the stack pointer.
sub %sp, 8, %sp

The stack grows downward. I didn't want to include a .data section, so I'm using the stack as storage. This expands it by 8 bytes.
mov 3, %g1
mov %g0, %o0
mov %sp, %o1
mov 1, %o2

Getting ready to do a syscall. The ABI in use here requires the syscall number in %g1 and the arguments in %o0, %o1, etc. According to syscall.h, read is 3. Register %g0 is always 0, so these lines equate to read(0, sp, 1).
ta 0

Those familiar with x86 assembly might want int 0x80 to do the syscall. In SPARC, we use a user-mode trap, and in NetBSD specifically it is the first one. Thus, ta 0.
brz %o0, 0x1000ac

A conditional branch: jump to address 0x1000ac if %o0 contains zero. We sometimes have to be careful with instruction order though, because every time the program encounters a branch, the next instruction is executed as well. In this case it doesn't make a difference, but it will later.
mov 4, %g1
mov 1, %o0
mov %sp, %o1
mov 1, %o2

Just like with read before, except we're using write (4) and stdout (1).
b 0x10007c
ta 0

An unconditional branch. Remember that thing about branches being weird? This executes the ta 0 to call the write we just prepared, then jumps back to address 0x10007c (to prepare to read again).
add %sp, 8, %sp

The target of the first branch we saw, here we prepare to exit. Start by putting the stack pointer back where it was.
mov 1, %g1
ta 0

We know that %o0 contains zero, since that was the condition of the branch that got us here. We want to exit with that status, so we simply call exit (1).
Source:
.global _start
.section .text
_start:
sub %sp,8,%sp
1:
mov 3,%g1
mov %g0,%o0
mov %sp,%o1
mov 1,%o2
t 0
brz %o0,2f
mov 4,%g1
mov 1,%o0
mov %sp,%o1
mov 1,%o2
b 1b
t 0
2:
add %sp,8,%sp
mov 1,%g1
t 0

Reng v.1.2, 4 bytes
is~o

This takes input, skips if not a negative one (i.e. no input found). When s find a regular character, it skips over the ~ and outputs the input with o. Otherwise, it meets the ~ and ends execution. Input is like "string1" "string2" ... "stringN". Try it here!
The following 13-byte program allows you to feed input more than once, but only yields correct output provided you feed it in at the right time.
>isvo
/$$>is!

Input "Meow":

Fuzzy Octo Guacamole, 3 bytes
(non-competing, FOG is newer than the challenge)
(^)

Looks emotish (that's totally a word).
The ^ gets input, the X pops it and prints it.
The ( and ) denote the start and end of an infinite loop.
4 byte solution with a for loop:
?[?^]

The [ and ] denote a for loop, and the ? increments the counter, so it never runs out.
Weird implicit outputs means it prints the outputs automatically.

Cool!!!!!!!!!!!

This is the infinite cat challenge. If it is at all possible in your language to support an arbitrary infinite input stream (i.e. if you can start printing bytes to the output before you hit EOF in the input), your program has to work correctly in this case.

Jelly, 1 byte
¹

Simply the identity function.

Lua, 30 Bytes
Heavily base upon Lynn's answer, but as it is not updated anymore, I'll feel free ot post this 30 bytes answer.
::a::io.write(io.read())goto a

Tellurium, 2 bytes
i^

Pretty simple, eh?
What it does is get input from the user using the i command, and stores it in the tape in the currently selected item (in the code above, it's 0, the default).
After that, it prints the currently selected item's value using the ^ command. (whatever the user input).

APL, 6 bytes
⎕←⍞
→1

This has worked in all APLs since the beginning of time.
⍞ wait for input
⎕← Output that
→1 go to line 1

Javascript (browser), 16 15 bytes
alert(prompt())

I like the rules abuse here... :-) By the way, you can save a byte by dropping the semicolon - JavaScript has automatic semicolon insertion, with only a few exceptions. Also, you probably should specify state this is for browsers only, since Node.js doesn't have either of these, but it does support console IO.

Done! Thanks for the edit btw

Welcome!

Archway, 7 bytes
/.\
\,/

According to Esolangs, this is the only useful program that can be written in the original Archway language.

Archway 2, 19 bytes
   \
// .
  , /
+/\

Clojure, 18 bytes
(print(read-line))

This 30-bytes program runs forever:
(while true(print(read-line)))

Wouldn't this only read and print a single line? I'm pretty sure Clojure would be able to deal with arbitrary finite and even infinite streams instead.

Wouldn't this only read and print a single line? 24 days later, I worked around it.

@dorukayhan It ((while true) still (prints a (read-line)))! You need to support infinite input without newlines if you can.

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Well, considering Clojure is Java in disguise, (read-line) uses System.in, which can theoretically take infinitely many bytes.

@dorukayhan Does it support input without newlines?

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ It requires you to press Enter now and then, but omits newlines. Does that count?

@dorukayhan If you run (sh) echo No newlines!|clojure script, will it output No newlines!?

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Huh?

@dorukayhan i.e. If you input indirectly with no newlines, will it work?

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Um... probably.

Badly overdue disclaimer: This might be the first Clojure program I wrote

@dorukayhan I think what Erik is trying to say is that this doesn't seem to print anything for an infinite input stream which doesn't contain linefeeds, since read-line won't return until it finds a linefeed, so you never start printing in that case.

Wat, 6 + 1 = 7 bytes
åó#ÐÑÅ

(This code don't have any rapport with DNA)
Explanation:
åó#ÐÑÅ

å      Read a character
 ó     Duplicate the top of the stack
  #    Skip the next character
   Ð   End the program
    Ñ  If the top of the stack is 0, go backward (execute Ð and end the program), otherwise go forward
     Å Print the character on the top of the stack
       After, the IP wrap and the line is reexecuted

Wat

Omam, 137 bytes
the screams all sound the same
though the truth may vary
don't listen to a word i say
the screams all sound the same
this ship will carry
Note that I haven't copied it. In fact, I added this code there today.

Well, this is a beautiful language.

@dorukayhan It's in fact BF, but with different commands. Note that this, technically, is 5 lines, i.e. 5 commands. BF golfing tips apply.

Apps Script + Google Sheets, 29 bytes
Script
function Q(s){return s}

Sheet
=q(B1)

Cell B1 is the input.

By convention A1 is the input cell for cell-based languages, and you should be able to reduce =q(b1) to =q(A1 where Google Sheets will autoformat in the terminating )

C++ (109 Bytes)
Thanks to Eʀɪᴋ ᴛʜᴇ Gᴏʟғᴇʀ for reducing 4 bytes.
#include <iostream>
#include <string>
using namespace std;main(){string A,W;while(cin>>A)W+=A;cout<<W<<endl;}

Can't you remove it though? Also, if I'm correct, char*A is -2 string A. That way then, I think, you can remove #include <string>\n for -18, and use #include<iostream> for -1. Also, since you will use std:: 2-3 times, you can remove using namespace std;, and replace cin, cout (and possibly endl?) with std::cin, std::cout and possible std::endl.

J, 14 bytes
stdout]stdin''

Reads the entire input from stdin until EOF is reached and store it as an array of characters. Then output all of it to stdout. This will work when saved as a script to be run using jconsole, where scripts are programs for interpreted languages.

Fith, 7 bytes
read \.

read gets input from STDIN.
The language cannot handle infinite streams.
\. prints the string on top of the stack without a trailing newline.

Can't do read\.?

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ No. Fith's identifier rules are very lax, so read\. would be counted as a single token.

And why can't you do read . then?

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ That adds a newline at the end of the string. My understanding was that that shouldn't happen.

Oh, okay then..

BruhScript, 22 bytes
Source:
↺₀1Λ₀⍈+⍰'
∇

Encoded version hexdump:
0000000: 0099 009a 003a 0087 009a 008f 0051 008e  .....:.......Q..
0000010: 0061 0000 0069                           .a...i

Explanation:
↺                While loop. Take two niladic functions as arguments.
 ₀1Λ             A function that always return 1
    ₀⍈+⍰'<LF>∇   `'<c>` is a shorthand for «<c>», so this code print (⍈) the input (⍰) + a newline ('<LF>), and return None (∇)

Racket, 52 bytes
A classical approach.
(copy-port(current-input-port)(current-output-port))

In Racket, default settings are stored in parameters which are invoked to obtain their value (or invoked with an argument to set them). This mechanism is also used to access/set the default input and output ports.

Clora, 1 byte
!

Explanation:
! use Input as Output value

Python 3, 21 bytes
print(input(),end='')

This doesn't support multiple lines nor an infinite stream

Also, why not use print(end=input())? :P

QBIC, 4 bytes
_??A

Unfortunately, QBasic (and by extension QBIC) doesn't handle input very well. Comma's are only allowed if quotes are used (which then get stripped from the output). Newlines are another no-go.

Pyke, 2 bytes
zr

Try it here!
z  - read_line()
 r - if no error: goto_start()

Jelly, 5 bytes
ƈȮøL¿

Try it online!
This one is valid, unlike the other 1-byte one, which is 100% invalid:
¹

(command-line arg, not STDIN)

Thanks to Dennis for implementing EOF detection for that.

Emotinomicon, 16 bytes
⏫⏪⏬⏩

Explanation:
⏫⏪⏬⏩
⏫             Get input
             Reverse Stack
    ⏪  ⏩     Loop
      ⏬       Output one char

There is alerady a shorter answer.

Yes but if input multiple chars in  the input popup the output is reversed

Racket 35 bytes
(let l()(displayln(read-line))(l))

Ungolfed:
(define (f)
    (let loop()
      (displayln
       (read-line))
      (loop)))

To run:
(f)

Common Lisp (Lispworks), 50 bytes
(defun f()(let((x(read-char)))(format t"~A"x)(f)))

Usage:
    CL-USER 165 > (f)
    aabbccdd

    112233

    ddeeff

reticular, 2 bytes
ip

This exits with an error, but works fine. Try it online!
ip
i   take a line of input (no newline)
 p  print it with a newline after

ABCR, 4 bytes
5cQx

Explanation:
5      while(peek(B)){  //Queue B peeks default to 1, so this infinite-loops
 c        dequeue(c)  // Queue C dequeues default to an input character if C is empty
  Q       print(c)   /* Prints peek at the queue, and peeks on an empty queue C
                        default to the register value, which was set by `c` */
   x    }

C#, 79 bytes
using x=System.Console;class P{static void Main(){x.Write(x.In.ReadToEnd());}}

Thanks Lynn for the hint about using alias vs using static.

FEU, 0 bytes

Yep, the empty program works as a cat program...

pb, 20 bytes
^w[B!0]{t[B]vb[T]^>}

It will print an input prompt, but I can't do anything about it. This language has no way of supporting infinite input.

Lolo, 2 bytes
Lo

Not very interesting for a language only made up of Ls and Os.
It's basically printing whats in the stack. Since there is nothing, it gets the input.

TCL, 28 bytes
puts -nonewline [read stdin]

Arcyóu, 2 bytes
(q

Try it online!
Strange, a search for arcyóu inquestion:62230 doesn't seem to turn anything up.
Arcyóu has a strange behavior: if there isn't a trailing newline in the output, it will unavoidably append one. If there is a trailing newline, another one will not be appended. (p(q will not fix the problem, it will just forcibly append another \n.
This language cannot possibly handle infinite input.
Arcyóu is weird.
First Arcyóu answer of mine :D

tcl, 17
puts [read stdin]

available to run on http://www.tutorialspoint.com/execute_tcl_online.php?PID=0Bw_CjBb95KQMeHVzQWNwMjZGZVk
To stop it from running, press Ctrl+D.

Actually, 6 bytes
○W◙○WX

Try it online!
+2 bytes because I fixed the trailing newline issue.

Perl 6, 25 bytes
.print while $_=$*IN.getc

Supports null-bytes, and infinite streams without newlines.
If we were allowed to work on a line-by-line basis and always print a trailing newline, it would be only 14 bytes:
.say for lines

You can save 5 bytes by nuking the $*IN.; global getc will read from stdin by default.

Del|m|t, 14 bytes (non-competing)
Try it Online!
7 /  1 3 > ? 9

No command line argument, because   is the default
Explanation:
(7) 23    Gets the next char from input (-1 if its EOF)
(/) 15    Duplicate
()  0     Pushes 0 (there are no characters -> ASCII sum = 0)
(1) 17    Swap top 2 (Stack is [C, 0, C])
(3) 19    Pushes 0 if (C >= 0), 1 Otherwise (i.e. EOF)

(>) 30, (?) 31    If the EOF has been reached, exit the program

(9) 25    Print the character
          Repeat

Chip, 16 bytes
AabBCcdDEefFGghH

Try it online!

How it works:
Each capital letter corresponds to one bit of the input, and each lowercase letter to a bit of the output.
An input element, B will propagate its value to its immediate neighbors; in this case b and C. Being an output, b will take the value it has been given, and place that in the output. C will ignore B's signal, since input elements don't read the signals around them.
There won't be any cross-talk between output elements either, such as a and b, since neither produce any signal.
This isn't the only cat program, but all one-liners of this length will exhibit the wave-like pattern seen here. A 2D cat program (+3 bytes for newlines, but prettier imo) could be:
AabB
CcdD
EefF
GghH

SmileBASIC, 13 bytes
LINPUT S$?S$;

very simple.

Alice, 4 bytes
i.To

Try it online!
Alice is a 2D language with two modes — Cardinal (i.e. up/down/left/right) which deals with integers and Ordinal (i.e. diagonal) which deals with strings. Here we only need Cardinal mode.
The naïve way would be
i.h%o

which would perform in a wraparound loop:
i        Read byte b, or produce -1 on EOF
.h%      Compute b%(b+1), erroring out for -1 or staying as b otherwise
         '.' here is duplication, 'h' is increment and '%' is mod
o        Output (b mod 256) as a byte

However, instead of .h%, the answer uses a shorter way of erroring out:
i        Read byte b, or produce -1 on EOF
.T       Duplicate and sleep for b milliseconds, erroring out if b is negative
o        Output (b mod 256) as a byte

Of course, this means that the higher the byte values in the input, the longer the program will take to run!

OIL, 12 bytes
Can handle infinite input, but the input has to be newline-terminated (any other way isn't possible in OIL currently).
5
9
4
9
11
6

Aceto, 5 bytes
When reading input, Aceto always waits for a newline, meaning input has to be \n-terminated.
pn
r<

In the current version, EOF will crash the program, but that only prints to STDERR.

Python 2, 28 bytes
while 1:
 print(raw_input())

Try it online!

Quite sure someone has tried that already. This is not gonna work for infinite input (without newline) :/

@daniero : Edited it.

According to the rules, you should be able to run yes | tr -d \\n | python your_program.py and get some output. That doesn't seem to happen.

GW-BASIC, 33 bytes
WHILE 1:INPUT "",X$:PRINT X$:WEND

Pretty simple:

WHILE 1 is an infinite loop
INPUT "",X$ reads a string with no prompt
PRINT X$ prints the string
WEND is the end of the while loop

Screenshot:

LOLCODE, 261 bytes
HAI 1.2
I HAS A s
I HAS A n ITZ 0
IM IN YR l
GIMMEH s
s,O RLY?
YA RLY
IM IN YR o UPPIN YR i TIL BOTH SAEM i AN n
VISIBLE ""
IM OUTTA YR o
VISIBLE s
n R 0
NO WAI
n R SUM OF 1 AN n
DIFFRINT n AN SMALLR OF n AN 9000,O RLY?
YA RLY
GTFO
OIC
OIC
IM OUTTA YR l
KTHXBYE

Try it online!
Cats aren't so simple after all. LOLCODE treats a blank line as falsey, and a "simple" cat program would stop and decide to take a nap as soon as it hits a blank line.
Given the 2008-era memes that spawned LOLCODE, I've decided that cats can't handle power levels over 9000, therefore this program will break if there are over 9000 empty lines. It also doesn't follow the rules about newlines (it will always print exactly one trailing newline, no matter how many trailing newlines the input had). I'm not sure any other way to do it in LOLCODE, since there's no way to differentiate between a blank line and the end of input.

Triangular, 6 bytes
\@~/;<

Triangular is my first attempt at a two-dimensional language. It is stack-based and the playing field is organized into the shape of a triangle. The above source code shapes into:
  \
 @ ~
/ ; <

Each Triangular program starts at the top of the triangle with the IP moving Southwest.

The \ command directs the IP to Southwest (the default direction but required for the loop).
The ~ command reads a character from standard input and pushes it to the stack.
The < command directs the IP to West.
The ; command terminates the program if the top of stack is < 1.
The / command directs the IP Northeast
The @ command prints the top of stack as a character.
The IP hits \ and loops.

Note that since the stack is never popped, this has a finite size. However, Triangular has 30kb stack, so I think this will suffice for most normal files, and you shouldn't be cat-ing executables anyway! ;-)
However, here's a version that can handle infinite input:
(.~..;)p@<

This shapes into a larger triangle:
   (
  . ~
 . . ;
) p @ <

There are only three different commands (and no IP redirects):

( open a loop
p pop stack
) go to the most recent loop if the top of stack is > 0

I may be able to golf this if I change how Triangular reacts to playing field edges.

CPU-16 assembly, 56 bytes
load-a INPUT
write-flag EQ
cjmp EQ
write-extern A
jmp EQ

Needs a keyboard connected to the input port and a TTY to the output port.
Reads the input in a loop until it isn't zero, in which case it sends the input to the output and jumps back to the start of the program.

Foam, 5 bytes
,* ."

,* reads all the input, and then ." prints it as a string.

Unwanted, Unnecessary, Opportunistic, 0 bytes

If the script is empty -  Unwanted, Unnecessary, Opportunistic just prints the input.

Emmental, 24 bytes
;#44#46#35#52#50#63#42!*

Caker, 10 bytes
ωΩ(ξΘ)

(uses UTF-8)

MOO, 81/75/41/35 bytes
while(!player:tell(read(player)))endwhile

or, 36 byte version if being run with wizard permissions:
while(!player:tell(read()))endwhile

Each of these versions will wait for a newline before printing, unless set_connection_option(player, "binary", 1) (40 bytes long) is called previously, as that is the nature of the input system.

Cubically, 13 12 bytes
(~-1/1=&6@7)

Cubically can finally do this! Yay! We've been working on adding input/conditionals/loops for a while and just got it finished.
Explanation:
(             open loop (can be looped unconditionally)
 ~            read character as input
  -1/1        set notepad to -1 (EOF)
      =       compare with input buffer (implicit = defaults to =7)
       &6     if truthy, quit
         @7   print character
           )  loop infinitely

Try it online!

:0 is unnecessary because it will exit the program if the notepad is ever set to anything but 0

@TehPers Oh, didn't notice! Thanks

Forked, 3 bytes
~,@

Yay, Forked is getting implemented!

~ - read character as input
, - exit if <= 0
@ - output as character
wrap around (infinite loop)

Here's another, more interesting one: 9 bytes
>~,v
^-@<

Uses these directionals and no-ops (self-explanatory):
>  v
^- <

So the code is an infinite-loop like this:
~,@

Here's one that utilizes the fork: 13 bytes
>~v
@ |
^-:-&

Directionals and no-ops:
> v
  |
^-:-

The fork will redirect the IP West if truthy and East if falsy. & is an exit.

Ly, 4 bytes
&i&o

Try it online!
&i will copy all input onto the stack, &o outputs the stack.

;#*:), 5 bytes
*:#*)

Try it here!
Input must be terminated by a NUL byte. Can handle infinite input stream, and terminates at NUL bytes.
How it works
*     - Take a character of input
 :  ) - While input is not a null byte...
  #   -     Print as character
   *  -     Take a character of input

var'aq, 25 bytes
~ Q { 'Ij cha' Q } pong Q

Explanation
A function named Q is pushed onto the stack which,'Ij - read from STDIN, cha' - write to STDOUT, and then calls itself recursively.

Thotpatrol, 119 bytes
JACKING IN
DM THAUGHTY JO
  JO
  JO
REPORT UNPATRIOTIC ACTIVITY

Thotpatrol does not support support key-events outside of console input, so this is the most correct solution.
Link to implementation:
https://github.com/MindyGalveston/thotpatrol-

Nhohnhehr, 41 bytes
+----+
| /0\|
|$?@\|
| \1\|
|   #|
+----+

Try it online!

Bash, 2 bytes
A less known(?) alternative to dd and cat itself:
m4

Try it online!

This isn't a valid answer because m4 processes its input; it doesn't just copy stdin to stdout.  Here's a TIO example.

Whispers, 22 bytes
> InputAll
>> Output 1

Try it online!

Funky, 28 bytes
io.stdin().pipe(io.stdout())

Shouldn't be too surprising. Just pipes STDIN to STDOUT.
Try it online!

Rust, 59 bytes
use std::io::*;fn main(){copy(&mut stdin(),&mut stdout());}

A glob import can be used to shorten previous Rust solution.

Icon, 40 bytes
procedure main()
while write(read())
end

Try it online!

Ly, 16 bytes
Posting because I didn't know that &i existed when I did this.
i[&oi[r91+r&oi]]

Demo

Pepe, 8 bytes
REEeReee

Try it online!
Explanation
Simple.
REEe     - Get all input as string
    Reee - Print all input

You could change your code to REEeReee because numbers will print char code

@u_ndefined Oh, you're right. Fixed it, thanks.

Stax, 1 byte
_

Run and debug it
Null-bytes are always converted to spaces upon output. There are no ways to override this.
Multiple newlines are handled correctly. No extra trailing newlines if there are no trailing newlines in the input.
The language does not support infinite stream input.

2DFuck, 79 bytes
!x>>>>>>>>vxvx[^^r![<r!]v![,x>r!]^![<r!]vr![>r!]vr![^^r![<r!]vv![^r.x>vr!]<]r!]

Try it online!
Explanation:
!x>>>>>>>>vxvx         Set [0|0], [8|1], [8|2] to true
[                      While the accumulator is true:
    ^^r![<r!]v           Go back to [0|1]
    ![,x>r!]             Read rightwards until first 1 ([8|1]) -> 8 bits
    ^![<r!]v             Go back to [0|1]
    r![>r!]              Find first one bit. This is [8|1] if we get a null byte (EOF)
    vr![                 If the bit below is 0:
        ^^r![<r!]v         Go back to [0|1]
        v![^r.x>vr!]<      Print everything til the first 1 in row 2 ([8|2]),
                             clearing all bits on row 1 before it. Stop at [7|2]
    ]r!                  Read and flip (so, exit if we have a 1 -> null byte)
]

Ahead, 6 bytes
~oi@j~

~ causes the head to ignore all commands and keep moving until it encounters another ~. This means the head moves to the right edge of the board at the beginning. It then bounces off the edge and begins traveling left on its next movement step. When the head goes back to the left side and encounters the ~, it bounces off the left edge and travels right, skipping cells, and the cycle continues.
Try it online!
~  keep moving, ignoring commands until next ~
o  pop and print character
i  read character from stdin, bounce back if no input
@  end program
j  skip next cell
~

PUBERTY, 123 bytes
It is May 1st, 2019, 4:21:09 AM.Y is in his bed, bored.His secret kink is J.Soon the following sounds become audible.oh yes

The first 3 sentences are the required header as short as possible. Puberty only supports inputs of one character so this program only reads and outputs one character
The oh command stores the character in the current register, and the yes command prints the ASCII char corresponding to the value of the current register.

Flobnar, 6 bytes
~,_@
e

Try it online!
Suggested by Esolanging Fruit, this solution is much shorter, but ends in an error. Thanks!
Below is my old solution, which terminates correctly, but doesn't handle EOF correctly.
Flobnar, 15 bytes
|\<@:
:~
,0
_ ^

Try it online!
Explanation:
We start at the @, going left. The \ evaluates below it, and stores it in the call stack. This is either the next byte of input from ~, or 0 if it is EOF. Next, it passes through the | to check if the top value of the call stack (:) is non-zero. If it is not, the pointer goes down from the | and returns the top value of the call stack. Otherwise, it goes up and wraps around to the _. This is also a conditional, which first evaluates printing (,) the top of the call stack. Printing always returns 0, so it goes right to the ^ which starts the loop all over again.

6-byte version that exits with an error

Also, I think this treats null bytes identically to EOF, which violates the rule that "If it is at all possible in your language to distinguish null bytes in the standard input stream from the EOF, your program must support null bytes like any other bytes (that is, they have to be written to the standard output stream as well)".

x86 assembly (16-bit, DOS), 6 bytes
Machine code:
b4 01 cd 21 eb fa

Source:
     mov $1, ah
.L1: int $0x21
     jmp .L1

Runs forever copying stdin to stdout, until you kill it.

Your program has to exit on EOF.

I don't think that's meaningful here.

What do you mean?

21h interrupt checks ^C if that counts.

Scratch (scratchblocks2), 40 bytes
when gf clicked
ask[]and wait
say(answer

Clojure, 19 bytes
(print(slurp *in*))

Try it online!

Beam - 10 bytes
>r@v
^? <

Explanation:
|   >    When it loops around, > makes it go right
|   r    Reads a character from STDIN
|   @    Prints the character
|   v    Sends the pointer down
|   <    Sends the pointer left
|   ?    Bounces if EOF (which is supposed to cause a loop, but it stops the program I guess)
|   ^    Sends the pointer up, which makes a loop

Brainflub, 3 bytes
 *|

Explanation
 : takes user input
* :  outputs contents of stdin
| : ends program
Compiler

x86 assembly, 24 bytes (or 20 bytes)
Machine code:
42 b0 03 8d 0c 24 cd 80 3c 01 75 08 b0 04 43 cd 80 4b eb ed b0 01 cd 80

Source (AT&T syntax):
.section .text
.globl _start

_start:
    leal (%esp), %ecx  # read to (%esp)
    incl %edx          # read one byte

loop:
    movb $3, %al       # read (this is safe because %eax is initially 0)
    int $0x80          # %ebx starts at 0, so we're reading from stdin

    cmpb $1, %al       # exit if we didn't get exactly one byte
    jne quit

    movb $4, %al       # write (this is safe because return value of read is 1)
    incl %ebx          # stdout
    int $0x80
    decl %ebx          # back to stdin

    jmp loop

quit:
    movb $1, %al
    int $0x80

Try it online!
This program exits cleanly
(with an exit code of 0, as a happy accident).
A version that exits unpredictably
(most likely with a segfault)
can be produced by deleting the last four bytes,
resulting in a 20 byte solution.
Tricks used:

Since %eax is only ever used to store bytes,
and it is initially zero at the start of the program,
we can treat %al as its own 8-bit register
and never have to worry about the upper bits.
This saves bytes with e.g. mov instructions,
since movl with a constant takes up 5 bytes
(1 for the instruction and 4 for the constant)
whereas movb only takes 2
(1 for the instruction and 1 for the constant).
Similarly,
instead of movl $1, %edx (5 bytes),
incl %edx is only 1 byte
and has the same effect,
since %edx is initially zero.
We can take advantage of the fact that syscalls only clobber %eax
by using the same values of the other registers for calls to sys_read
as calls to sys_write.
The only difference is the file descriptor,
which we adjust from STDIN to STDOUT by a simple incl
and change back afterwards with decl.

Turing Machine But Way Worse, 419 bytes
0 0 0 1 1 0 0
1 0 1 1 A 0 0
0 1 0 1 2 0 0
1 1 1 1 a 0 0
0 2 0 1 3 0 0
1 2 1 1 b 0 0
0 3 0 1 4 0 0
1 3 1 1 c 0 0
0 4 0 1 5 0 0
1 4 1 1 d 0 0
0 5 0 1 6 0 0
1 5 1 1 e 0 0
0 6 0 1 7 0 0
1 6 1 1 f 0 0
0 7 0 1 7 0 1
1 7 1 1 7 0 1
0 A 0 1 a 0 0
1 A 1 1 a 0 0
0 a 0 1 b 0 0
1 a 1 1 b 0 0
0 b 0 1 c 0 0
1 b 1 1 c 0 0
0 c 0 1 d 0 0
1 c 1 1 d 0 0
0 d 0 1 e 0 0
1 d 1 1 e 0 0
0 e 0 1 f 0 0
1 e 1 1 f 0 0
0 f 0 1 0 1 0
1 f 1 1 0 1 0

Try it online!
Full cat program.

Your efforts to make this answer have been modified to solve this challenge. Thought I'd let you know

05AB1E, 2 bytes
I?

Try it online!
Blank program is not allowed since OP specified "You should write a full program which reads..."

Doesn't seem to work for multiple lines. Though for one line, the empty program does work

@JoKing Thanks, I'll improve my this version.

Also, I don't see why zero-length programs aren't valid "full programs" (that rule means functions aren't allowed)

@pppery Oh, really. I thought they mean no 0 byte programs, since I don't see any 0b programs.

The very old TeaScript answer is 0 bytes, and that's just the first one that I've noticed, so as long as it works a 0-byter is fine. In this case, it doesn't work, and neither does I?

It seems like to construct a fully functional cat program in 05ab1e, you'd need to use a strange interaction between I and | to detect EOF.

@UnrelatedString Even if you somehow managed to get that to work, it wouldn't support infinite streams like yes. See my answer.

Reflections, 61 53 bytes
\ v0):v+\
*/;++ ^;/
0 >~\
  |:^+|
#@_
\ ^  0\
 \   */

Test it in the browser!
Can handle infinite input (check the "Interactive" box), but not null bytes.
As Reflections takes linewise input, but doesn't preserve the newlines, getting those right was the first problem. Basically, a newline is printed
before every line but the first.
Another problem was empty lines. An empty stack is falsy, just like a stack containing a 0 indicating end-of-file. Therefor stack size is explicitly checked.
Check the "Time between steps" box to see the messy control flow. Not that messy anymore.

Stax, 1 bytes
m

Run and debug it
Explaination
m as the first character uses the rest of the program to map input to output.  A blank program just directly maps it.  A blank stax program only outputs the first line of input.

4, 16 bytes
3.70080050070094

Try it online!
3.   |
7 00 | grid[0] = getc()
8 00 | while grid[0]:
5 00 |     putc(grid[0])
7 00 |     grid[0] = getc()
4    |

Grass, 17 bytes
wWWWWWwWWWwWWWwww

Defines one function, which in Lua would look like:
function Main(arg)
    local c = In(arg)
    Out(c)
    return arg(arg)
end

The interpreter will call this Main function with itself as its argument. When EOF is reached, In returns its argument, which is Main. Passing the non-character Main to Out is an error, terminating the program.
Try it online!

Brainetry 0.1, 71 bytes
The golfed version is followed by the original reference program.
a b c d e f
a b c d e f g h
a b c d e f g
a b c d e f
a b c d e f g h i

To try this online head over to this link, paste the code in the btry/replit.btry file and hit the green "Run" button.
Ungolfed:
This program you are currently reading
has the particularity of explaining itself. In fact,
this program has one simple mission :
Take some input provided by you
and throw it right back at your face !!!

Windows Batch, 9 bytes
@type con

The type command is intended for reading files, but is perfectly capable of reading from STDIN.

Java, 91 bytes
interface M{static void main(String[]a)throws Exception{System.in.transferTo(System.out);}}

Try it online!
Java, 101 bytes
interface M{static void main(String[]a)throws Exception{System.out.write(System.in.readAllBytes());}}

Try it online!
Java, 119 bytes
interface M{static void main(String[]a)throws Throwable{for(int i;(i=System.in.read())>-1;)System.out.print((char)i);}}

Try it online!
Java, 120 bytes
interface M{static void main(String[]a){System.out.print(new java.util.Scanner(System.in).useDelimiter("\\A").next());}}

Try it online!

Jellyfish, 7 bytes
PJ-1
 5

Try it online!
The trailing newline is unavoidable since matrix print is the only printing function which keeps the input as is.
A jellyfish program is effectively a huge function which takes args via its branches that move down and to the right. So, effectively, this is what it parses to:
P         (J    (-1,5))
print_grid(input(-1,5))

-1 tells J to take input till EOF is reached.

Vyxal, 2 1 byte
-1 byte thanks to Underslash
₴

Try it Online!

This does work, you can remove the ? for implicit input, no?

@Underslash Oh, right... I forgot the default argument is the input

Dis, 2 bytes.
}{

Olmstead's cat program is too long, and it does not do really use the features of the language; just use that non-commands are NOP and the program counter loops over! Though the output would be slow, but this is pretty simple.
Try it online!

Mascarpone, 10 bytes
[,.:!]v*:!

Try It Online!

CSASM v2.5.1, 36 bytes
func main:
ink ""
print
call main
ret
end

Waits for a key to be pressed, then prints that key (the input key is also printed by ink due to how it's coded) forever.
Explanation:
ink prompts the user with whatever string is used as its operand -- an empty string in this case -- then gets the input from the user and pushes it to the stack as a char value.
print prints the str representation of whatever value is on the stack and does not append a newline.
The code will then call main, causing infinite recursion.  Eventually, it will stop due to a StackOverflowException but it will work just fine up until that point.  The program can be halted by doing Ctrl + X.

CLC-INTERCAL, 82 bytes.
DO;2<-#1DOCOMEFROM#9DOWRITEIN;2(1)DO:1<-;2SUB#1DDOCOMEFROM':1~:1'~#1(9)DOREADOUT;2

Copy and paste to try it online!
How it works
DONOTE it shall have at most one byte
DO;2<-#1

DOCOMEFROM#9
   DONOTE similar to getchar() but not really
   DOWRITEIN;2
   DONOTE checks if EOF
   (1)DO:1<-;2SUB#1
   DONOTE error exit
   D
   DONOTE come here unless EOF
   DOCOMEFROM':1~:1'~#1
   DONOTE no need to modify the array before outputting
   (9)DOREADOUT;2

How I/O works in CLC-INTERCAL

Has four methods but I know only three.
Numeric I/O. Applied for spot and two-spot variables, almost as in INTERCAL-72 and C-INTERCAL.

Input is done for each line. Each digit spelled. E.g. ONE THREE TWO.
Output is done for each line, in Roman number. Instead of overlines, backslashes are used to indicate "times 1M".

Baudot I/O. Applied for tail. Input is done like gets(); outputs like puts() so it's done every line.

It uses extended Baudot character set; a character ` is missing.

Binary I/O. Applied for hybrid array.

How WRITE IN works: if an array to be WRITTEN has N items, then N bytes are WRITTEN.

Let io=172 and i=1.
If i>N; then end.
Let c=getchar().
If c is EOF, then i-th item will be #0.
If c is not EOF, then i-th item will be interleave(select(c,io),select(~c,~io)). In this expression c and io have 8 bits.
If c is not EOF, then io=c.
If c is not EOF, then most significant 16 bits of i-th item will be randomized so that at least one bit of them will be 1.
Increment i. Go to step 2.

READING OUT is done in reverse way.
Variable "io" is initialized to 172 every time you WRITEIN and READOUT.

Python, 14 bytes
print(input())

Print input... couldn't be more self-explanatory.

makina, 6 3 bytes
I misread the requirements as needing a loop, whoops
Because makina is written in Python and uses Python's I/O methods, the information from the Python answer also applies to this answer.
P
i

C#, 76 bytes
for(int c=Console.Read();c!=-1;c=Console.Read())Console.Write((char)c);

C (clang), 37 bytes
main(c){for(;read(0,&c,1);)write(1);}

Stack reutilization inspired by this tip.
Try it online!

Trianguish, 8 bytes
00000000: 4041 01a1 040c 50bf

Try it online!

Fig, \$1\log_{256}(96)\approx\$ 0.823 bytes
x

Try it online!
Fig only implicitly inputs if there is a need, so we have to explicitly input here.

x86 assembly (32-bit Linux), 19 bytes
Turned out almost identical to Doorknob's answer, so I'm not sure where the one byte saved came from. Uses same tricks: registers start zeroed and syscalls don't clobber any registers besides eax. (Probably) segfaults on EOF.
global _start

section .text
_start:
        inc     edx         ; set edx = 1
        mov     ecx, esp    ; read/write to sp
loop:
        mov     al, 3       ; read call number 3
                            ; ebx: read from stdin (fd=0)
                            ; edx: read 1 char
        int     0x80        ; syscall

        test    eax, eax    ; check if byte read
        jz      exit

        mov     al, 4       ; write call number
        inc     ebx         ; write to stdout (fd=1)
                            ; ecx: use char in buf
                            ; edx: write 1 char
        int     0x80        ; syscall

        dec     ebx         ; ebx = 0
        jmp     loop

exit:
                            ; segfault instead of exiting

Objdump:
08049000 <_start>:
 8049000:   42                      inc    edx
 8049001:   89 e1                   mov    ecx,esp

08049003 <loop>:
 8049003:   b0 03                   mov    al,0x3
 8049005:   cd 80                   int    0x80
 8049007:   85 c0                   test   eax,eax
 8049009:   74 08                   je     8049013 <exit>
 804900b:   b0 04                   mov    al,0x4
 804900d:   43                      inc    ebx
 804900e:   cd 80                   int    0x80
 8049010:   4b                      dec    ebx
 8049011:   eb f0                   jmp    8049003 <loop>

Trilangle, 14  8 bytes
<>i,@##o

Try it on the online interpreter!
The interpreter loads this into a triangular grid and adds trailing .s as necessary. When expanded, this program becomes:
   <
  > i
 , @ #
# o . .

The IP starts on the north corner headed southwest.

Starting on the red path, the interpreter hits the following instructions:

<: Redirect the IP left, where it wraps around to the right side of the next row
i: Read a single character from input
>: Branch

When it hits the branch instruction, the IP changes direction depending on the sign of the character read. EOF is -1 and all other characters are positive, so it branches on EOF.
When it reads EOF, it continues on the green path, and quickly hits @, terminating the program. Otherwise, it continues on the blue path:

o: Output a character
,: Pop from the stack
#: Skip the next instruction (twice)

After this, it reaches the <, where it merges with the red path.
The , instruction is necessary to keep memory bounded when fed an infinite input stream (e.g. when piping yes into it).

Uiua, 18 bytes SBCS
These take advantage of &sc returning 0 upon reaching EOF.
⍢&pf(≠0⊡0⇌utf.&sc)

This version errors since upon reaching EOF, Uiua then tries to index a non-existent first element of the utf array, which in that case is empty (has length 0).
⍢&pf(≠0⊡0⇌utf.&sc)
               &sc  # Read a line from stdin
              .     # Duplicate
           utf      # Convert to array of UTF-8 bytes
          ⇌         # Reverse array
       ⊡0           # Index the first element of said array
     ≠0             # Is not equal to 0?
    (             ) # Enclose as function
⍢&pf                # Print to stdout while function condition is true (without trailing newline)

Try it online!
Non-erroring, 20 bytes SBCS
⍢&pf(≠0⊡0⇌⊂0utf.&sc)

This version does not error since it takes 2 more bytes to join a 0 to the utf array before indexing.
⍢&pf(≠0⊡0⇌⊂0utf.&sc)
                 &sc  # Read a line from stdin
                .     # Duplicate
             utf      # Convert to array of UTF-8 bytes
           ⊂0         # Join a 0 to said array
          ⇌           # Reverse array
        ⊡0            # Index the first element of array
      ≠0              # Is not equal to 0?
     (              ) # Enclose as function
⍢&pf                  # Print to stdout while function condition is true (without trailing newline)

Try it online!

Implicit, 10 2 bytes
©"

© reads all input to the stack as ASCII characters, " turns the entire stack into a string.
Try it online!
A proper version
~.(-1@~.)&

Try it online! Explanation:
~+1(-1@;~+1)&
~            read character
 +1          increment
   (....     do
    -1        decrement
      @       print
       ~      read character
        +1    increment
          )  while top of stack truthy
           & exit (no implicit output)

All that incrementing and decrementing is to get the loop to exit on EOF (0).

Bitwise, 27 bytes
IN 1 &1 2
OUT 1 2
JMP &-3 2

Commented:
IN 1 &1 2   read a character from standard input into register 1 if literal 1 is nonzero, store result in 2
OUT 1 2     output the character in register 1 if register 2 is nonzero, discard result
JMP &-3 2   jump 3 (2) lines backwards if register 2 is nonzero

The proper program would look like this:
LABEL &1    create label 1
IN 1 &1 2   (same as previous)
OUT 1 2     (same as previous)
JMP @1 2    jump back to label 1 if register 2 is nonzero

shortC, 10 bytes
AW_=~G)P~_

Dennis' winning C answer in shortC. Try it online!

Pyt, 3 bytes
`ƥł

Try it online!

`...ł  loops while top of stack is not 0
ƥ      prints top element

Momema, 18 bytes
z1-9*0z00*-9z=+1*0

Try it online!
Explanation
                                                                  #  var a
z   1      #  label z0: jump past label z1                        #  loop body (initially skip this):
-9  *0     #            print chr [0]                             #    print chr a
z   0      #  label z1: jump past label z1 (no-op)                #  end loop body
0   *-9    #            [0] = read chr                            #    a = read chr
z   =+1*0  #  label z2: jump past label z((!!([0] + 1) + 2) % 3)  #  if a != -1, go to loop body

rk, 52 bytes
read: key #
while # > -1 do
print: #
read: #
done

Requires the -e flag (remove necessity for rk:start). Try it online!
Ungolfed:
rk:start
  key #
  read: #

  while # > -1 do
    print: #
    read: #
  done
rk:end

Canvas, 0 bytes

Try it here!
Canvas automatically adds the input to the stack before doing anything else, and also automatically prints the object at the top of the stack once all other instructions have been completed. Therefore, an empty program functions as an implicit cat.

Good, but not a very unique solution (any program which does that, like 05AB1E, would have a 0-byte solution). Try adding on another solution and try getting to 1 byte with that one.

Bitwise Cyclic Tag, 1 bit, 0.125 bytes
0

This will delete bits from the data tape (taking the starting data configuration as input) in order until there are none remaining to delete, at which point the program exits gracefully.
I'm on a phone now, but when I get the chance, I'll write an interpreter and post a TIO link.

Procedural Footnote Language, 33 bytes
[1]
[PFL1.0]
[1] [INPUT]
[PFLEND]

This program simply defines the body of the document as a reference to footnote [1], then defines the footnote as the value of the input from STDIN. The evaluated body of the document is printed as a result.

Reality, 0 bytes

This assumes that input is given (if it is not it will output something else)

Z80Golf, 7 bytes
00000000: cd03 8030 0176 d5                        ...0.v.

Try it online!
Disassembly
start:
  call $8003
  jr nc, skip
  halt
skip:
  push de

call $8003: Calls getchar. It sets carry flag on EOF, otherwise writes a byte to register a.
jr nc, skip: If carry flag is not set, jump to skip:. Otherwise the program hits halt and terminates.
push de: Pushes two zero bytes to the stack. The program runs through the NOPs in memory until it hits putchar at address $8000. Then the value in the register a is printed, and the program returns to the popped address, which is zero (start of the program).

This happens to be a slightly modified version of the one on the Esolangs page, where the position of push de is different. Using bc or hl instead of de equally works.

SNUSP (Modular), 11 bytes
/$\
. ,
\?/

Try it online!
Please note that the TIO doesn't work with input correctly, but the program is correct. In SNUSP, the instruction pointer starts at the $ moving right, and bounces off of slashes. When the IP goes over a ,, it reads a character from STDIN to the current memory cell. The ? tests whether or not the current value is 0. If it is, then then IP jumps over the next instruction (the \) and goes off the end of the program, terminating. Otherwise, the IP goes onto the \, reflects, and hits the ., printing the current value as a character to STDOUT. When the IP goes over the $ again, it doesn't do anything.

bit, 16 bytes
IN
PRINT
PRINTLN

Explanation:
IN $$ Take input from user and push to stack
PRINT $$ add to printing queue
PRINTLN $$ Print the printing queue with a trailing newline

Bit is my own language, get the interpreter from GitHub and run:
java -jar bit.jar filename.bit

Backhand, 2 bytes
io

Try it online!
Seems obvious that i gets a character from the input and o outputs that character. However, the control flow is different from normal 2D languages in that it doesn't wrap around. Instead, the pointer moves three spaces, reflecting off the sides twice for each instruction.

Dots, 43453 bytes
....................................................................................................................................................................................................................................................................................................................................................................... and so on until 43453 bytes
I'll golf this later Nevermind, this is the least possible number of bytes, unless we assume that STDIN is one character long

Is this just another Unary clone? It's kinda hard to golf ,[.,]

whats Unary? Also, once you learn the programming language, it becomes easy to golf

It's just brainfuck converted to binary converted to unary. Unary

Yikes, the programming language is remarkably similar.

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

Try it online!
Explanation
*!^(!_++@*!^)
*                add input to top of stack
 !               duplicate
  ^              increment
   (        )    while not zero (while not EOF):
    !_++         pop incremented entry (duplicate, negate, add twice)
        @        output original input
         *       add input to top of stack
          !      duplicate
           ^     increment

Common Lisp, 46 bytes
This is another, shorte, solution:
(loop while(setq x(read-char t()))do(princ x))

Try it online!
Note in that Common Lisp every output on standard output always produces a newline at end (due to its nature as interactive language). If the program above is run on a different output stream, the file does not contains the final newline if this is not present in the input stream.

Re:direction -A, 1 byte of codepage 437
◄

Try it online!
The -A option allows Re:direction to interpret the input as the list of its character codes, rather than trying to parse numbers from it.
Explanation
In Re:direction, an arrow on a line by itself is a halt command. Arrows also change the command queue, but leftwards and upwards arrows don't have an effect on how the command queue is interpreted as I/O.
The input specifies the initial command queue, and the output is taken from the final command queue. So if we don't change it at all before halting (or change it only by adding leftwards or upwards arrows), the output will be the same as the input.
Re:direction also supports a more efficient character encoding than codepage 437, but the program wouldn't be any shorter.

Tamsin, 12 bytes
main=any/''.

Try it online!

Java, 133 bytes
No external libraries for me!
interface A{static void main(String[]a)throws Exception{for(;;)if(System.in.available()>0)System.out.print((char)System.in.read());}}

Try it online!

@, 6 bytes
¤ōč

Explanation
¤   Forever,
 ō  output the
  č character input

W, 0 bytes
Indeed just a boring built-in.

Pretty obvious. Execute the program like this:
python W.py code.w ['your-string']

Remember to escape non-alphanumeric characters.

Re-forking done.

Ral, 18 bytes
,:1-1:+:+:+:+?.10?

Try it online!
Explanation
,                  Input a character n, zero if end of file is reached
 :1-1:+:+:+:+?     Jump to opcode 16 if n ≤ 0.
                   If we didn't jump:
              .     Output n
               10?  Jump to the start
                   If we did jump:
                0?  Jump to the start if false (don't jump)

Rockstar, 37 bytes
listen to S
while S
say S
listen to S

Try it here (Code will need to be pasted in)

BRASCA, 0 bytes
I wasn't sure if I should post this one, but since there's a lot of 0-byters here, it should be fine, right?

Explanation
<implicit input>   - Push STDIN to the stack
<implicit output>  - Output the stack in reverse

Language Link
Github Repo

C (gcc), 39 bytes
f(c){for(;c=getchar(),c+1;putchar(c));}

Try it online!
f(c){c=getchar(),c+1?putchar(c),f():0;}

Try it online!

36 bytes Note that the requirements specifically ask for a Full Program :-(

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

Filename (escaped unprintable): .w.o.i.c\001.+.a
Content: empty

With comments
XX.z
.a.wXX.z # while empty || pop!=0; do
  .a.oXX.z # if !empty; then putchar pop; fi
  .a.iXX.z # push getchar (* NOTE EOF IS -1 *)
  .a.c\001.+XX.x # dup; push 1; push pop+pop
.a.aXX.z # done
.a

Try it online!

M4, 11 bytes, cheating.
syscmd(cat)

Try it online!

This isn't cheating. There are no rules that say you can't do this.

Duocentehexaquinquagesimal, 2 bytes
ßD

Try it online!

Sandwich, 10 bytes
lv<i:
p$v

Sandwich is comprised of opcodes. The first character of every line is the opcode, and everything else is the arguments passed to the opcode.
Above code with comments:
lv=0|i:i-1@(g:s.sub:i,i+1;r:r+g);print:r

Explanation coming soon TM

Unlambda, 9 bytes
``ci`c`@|

Try it online!
This works much the same way as https://codegolf.stackexchange.com/a/223645.

Numberwang, 5 bytes
24837

Try it online (with explanation)!

Locksmith, 5 bytes
85986
8      Push input to stack
 5  6  Repeat until top of stack is zero
  9    Pop from stack to output
   8   Push input

Lost, 5 bytes
%@
@%

Try it online!
Lost is a 2D Language, where the position and direction of the instruction pointer is random. So from any starting point, going into any direction, the instructions are:
implicitly read the input into the stack.
% turn off "safe mode", so the program will end at the next @
@ end the program and implicitly print the contents of the stack
The ip will wrap around edges and it will ignore @ as long as the safe mode is active

RASEL, 3 bytes
~@,

 text to make the answer be at least 30 chars otherwise I can't post it

Emmy, 13834 bytes
Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy Emmy

Emmy machine:
inp out

Thunno, 0 bytes

Attempt This Online!
Yet another golflang with implicit input/output.
Also works in Thunno 2: Attempt This Online!

Do you even need to show the code if the programme is empty?

@Hippopotomonstrosesquipedalian it's not necessary but I did it anyway.

GAIA, 1byte
p

Try it online!
p prints the input to the output
Alternative: 1byte
@

@ pushes input to stack (and it's printed by default)
The catch is that since the input itself doesn't support new lines, they cannot be printed.
I don't think the language supports null bytes either.
For infinite sequences it works but the output will be cut with a warning at some point just for displaying reasons.

Desmoslang Assembly, 3 Bytes
EIO

Old Mac Donald had a farm, EIEIO!

(,), 14 Chars or \$14\times \log_{256}(3)\approx2.77\$ Bytes
(,,,((())),())

Terminating version: 23 Chars or 4.56 Bytes
(,,,(()),((),((()()))))

K (oK), 6 bytes
`0:0:`

Try it online!

Positionally, 102 76 \$71\log_{256}(3)\approx\$ 14.07 bytes

        >      ^
      @ ^
> . :  v
v      <      ;<
\ s            /

\$\log_{256}3\$ is because each character is either a space, a newline, or non-whitespace.

Swift, 45 bytes
Seriously? It's been 8 years and no one's uploaded a Swift answer?
print(CommandLine.arguments[1],terminator:"")

Try it on SwiftFiddle.
Okay, fine, I'll admit, there's nothing special about this thing.

[Matlab], 13 bytes
input('','s')

Rec, 9 bytes
r[0:/^pr]

Try it online!

YASEPL, 12 10 4 bytes
i seem to have misunderstood the prompt, but heres a fixed version:
=a'~

authors: J. А. del Rio - слава СССР